docs: Update all documentation and samples for new expect API

This commit updates all documentation, sample code, and tests to use the
new expect API introduced in probitas v0.4.0 (PR #25) and probitas-client
(PR #55).

Changes:
- Replace .ok() with .toBeSuccessful()
- Replace .status(code) with .toHaveStatus(code)
- Replace .dataContains() with .toHaveContentContaining()
- Replace .count() with .toHaveRowCount() or .toHaveContent()
- Replace .contentType() with .toHaveHeader("content-type", ...)
- Replace .textContains() with .toHaveText()
- Replace .durationLessThan() with .toHaveDurationLessThan()

Modified files:
- docs/overview.md, docs/client.md, docs/scenario.md
- data/index/*.probitas.ts (all sample codes)
- probitas/site-health.probitas.ts
- .claude/content.md

Author: lambdalisue

.claude/content.md

@@ -86,7 +86,7 @@ export default scenario("Example")
   .resource("http", client.http.createHttpClient())
   .step("make request", async ({ http }) => {
     const res = await http.get("/api/users");
-    expect(res).ok().status(200);
+    expect(res).toBeSuccessful().toHaveStatus(200);
   })
   .build();
 ```

data/index/graphql_api.probitas.ts

@@ -16,8 +16,8 @@ export default scenario("GraphQL API Test", {
     `);
 
     expect(res)
-      .ok()
-      .dataContains({ echo: "Hello GraphQL" });
+      .toBeSuccessful()
+      .toHaveContentContaining({ echo: "Hello GraphQL" });
   })
   .step("echo - with variables", async (ctx) => {
     const { gql } = ctx.resources;
@@ -31,8 +31,8 @@ export default scenario("GraphQL API Test", {
     );
 
     expect(res)
-      .ok()
-      .dataContains({ echo: "variable message" });
+      .toBeSuccessful()
+      .toHaveContentContaining({ echo: "variable message" });
   })
   .step("createMessage - mutation", async (ctx) => {
     const { gql } = ctx.resources;
@@ -45,6 +45,6 @@ export default scenario("GraphQL API Test", {
       }
     `);
 
-    expect(res).ok();
+    expect(res).toBeSuccessful();
   })
   .build();

data/index/grpc_service.probitas.ts

@@ -14,8 +14,8 @@ export default scenario("gRPC Service Test", {
     });
 
     expect(res)
-      .ok()
-      .dataContains({ message: "Hello from probitas" });
+      .toBeSuccessful()
+      .toHaveContentContaining({ message: "Hello from probitas" });
   })
   .step("EchoWithDelay - delayed response", async (ctx) => {
     const { grpc } = ctx.resources;
@@ -25,8 +25,8 @@ export default scenario("gRPC Service Test", {
     });
 
     expect(res)
-      .ok()
-      .dataContains({ message: "delayed" })
-      .durationLessThan(5000);
+      .toBeSuccessful()
+      .toHaveContentContaining({ message: "delayed" })
+      .toHaveDurationLessThan(5000);
   })
   .build();

data/index/redis_cache.probitas.ts

@@ -19,14 +19,14 @@ export default scenario("Redis Cache Test", {
     await redis.set(key, "hello world");
     const res = await redis.get(key);
 
-    expect(res).ok().value("hello world");
+    expect(res).toBeSuccessful().toHaveContent("hello world");
   })
   .step("INCR counter", async (ctx) => {
     const { redis } = ctx.resources;
     await redis.set("test:counter", "0");
     const res = await redis.incr("test:counter");
 
-    expect(res).ok().count(1);
+    expect(res).toBeSuccessful().toHaveContent(1);
 
     // Cleanup
     await redis.del("test:counter");

data/index/user_api.probitas.ts

@@ -37,8 +37,8 @@ export default scenario("User API Integration Test", {
     const res = await http.get(`/users/${user.id}`);
 
     expect(res)
-      .ok()
-      .status(200)
-      .dataContains({ id: user.id, name: user.name });
+      .toBeSuccessful()
+      .toHaveStatus(200)
+      .toHaveContentContaining({ id: user.id, name: user.name });
   })
   .build();

docs/client.md

@@ -26,7 +26,7 @@ export default scenario("API Test")
   .step("Make request", async (ctx) => {
     const { http } = ctx.resources;
     const res = await http.get("/health");
-    expect(res).ok();
+    expect(res).toBeSuccessful();
   })
   .build();
 ```
@@ -118,16 +118,16 @@ Validate responses with chainable assertions:
 
 ```typescript
 expect(res)
-  .ok() // Status 2xx
-  .status(200) // Exact status code
-  .contentType(/application\/json/) // Content-Type pattern
-  .dataContains({ name: "Alice" }) // Partial JSON match
-  .durationLessThan(1000); // Response time limit
+  .toBeSuccessful() // Status 2xx
+  .toHaveStatus(200) // Exact status code
+  .toHaveHeader("content-type", /application\/json/) // Content-Type pattern
+  .toHaveContentContaining({ name: "Alice" }) // Partial JSON match
+  .toHaveDurationLessThan(1000); // Response time limit
 
 // Additional assertions
-expect(res).notOk(); // Status not 2xx
-expect(res).headerExists("X-Request-Id");
-expect(res).textContains("success");
+expect(res).not.toBeSuccessful(); // Status not 2xx
+expect(res).toHaveHeader("X-Request-Id");
+expect(res).toHaveText(/success/);
 ```
 
 ## SQL Clients
@@ -201,12 +201,12 @@ Validate query results:
 
 ```typescript
 expect(result)
-  .ok()
-  .count(1)
-  .dataContains({ name: "Alice" });
+  .toBeSuccessful()
+  .toHaveRowCount(1)
+  .toHaveContentContaining({ name: "Alice" });
 
 // Match multiple rows
-expect(result).dataEquals([
+expect(result).toHaveContent([
   { id: 1, name: "Alice" },
   { id: 2, name: "Bob" },
 ]);
@@ -235,7 +235,7 @@ const res = await grpc.call("echo.EchoService", "Echo", {
   message: "Hello",
 });
 
-expect(res).ok().dataContains({ message: "Hello" });
+expect(res).toBeSuccessful().toHaveContentContaining({ message: "Hello" });
 const data = res.data();
 ```
 
@@ -250,7 +250,7 @@ for await (
     count: 3,
   })
 ) {
-  expect(res).ok();
+  expect(res).toBeSuccessful();
   messages.push(res.data());
 }
 ```
@@ -269,7 +269,7 @@ const res = await grpc.clientStream(
     yield { message: "Third" };
   },
 );
-expect(res).ok();
+expect(res).toBeSuccessful();
 ```
 
 ### Bidirectional Streaming
@@ -287,7 +287,7 @@ for await (
     },
   )
 ) {
-  expect(res).ok();
+  expect(res).toBeSuccessful();
   console.log("Received:", res.data());
 }
 ```
@@ -310,7 +310,7 @@ const res = await connect.call("echo.EchoService", "Echo", {
   message: "Hello",
 });
 
-expect(res).ok().dataContains({ message: "Hello" });
+expect(res).toBeSuccessful().toHaveContentContaining({ message: "Hello" });
 ```
 
 ### Server Streaming
@@ -321,7 +321,7 @@ for await (
     count: 3,
   })
 ) {
-  expect(res).ok();
+  expect(res).toBeSuccessful();
   console.log("Received:", res.data());
 }
 ```
@@ -360,7 +360,9 @@ const res = await graphql.query(
   { id: "1" },
 );
 
-expect(res).ok().dataContains({ user: { name: "Alice" } });
+expect(res).toBeSuccessful().toHaveContentContaining({
+  user: { name: "Alice" },
+});
 const user = res.data().user;
 ```
 
@@ -381,7 +383,7 @@ const res = await graphql.mutate(
   { input: { name: "Alice", email: "alice@example.com" } },
 );
 
-expect(res).ok();
+expect(res).toBeSuccessful();
 const newUser = res.data().createUser;
 ```
 
@@ -400,7 +402,7 @@ const subscription = graphql.subscribe(outdent`
 `);
 
 for await (const res of subscription) {
-  expect(res).ok();
+  expect(res).toBeSuccessful();
   console.log("New user:", res.data().userCreated);
 }
 ```
@@ -426,7 +428,7 @@ Common Redis operations:
 await redis.set("key", "value");
 await redis.set("key", "value", { ex: 3600 }); // With TTL
 const result = await redis.get("key");
-expect(result).ok().value("value");
+expect(result).toBeSuccessful().toHaveContent("value");
 
 // Hashes
 await redis.hset("user:1", { name: "Alice", age: "30" });
@@ -469,11 +471,11 @@ const result = await users.insertOne({
   name: "Alice",
   email: "alice@example.com",
 });
-expect(result).ok();
+expect(result).toBeSuccessful();
 
 // Find
 const user = await users.findOne({ _id: result.insertedId });
-expect(user).ok().documentContains({ name: "Alice" });
+expect(user).toBeSuccessful().toHaveContentContaining({ name: "Alice" });
 
 // Find many
 const allUsers = await users.find({ age: { $gte: 18 } }).toArray();
@@ -504,7 +506,7 @@ By default, an in-memory database is used for testing.
 // Set and get
 await kv.set(["users", "1"], { name: "Alice" });
 const result = await kv.get(["users", "1"]);
-expect(result).ok().value({ name: "Alice" });
+expect(result).toBeSuccessful().toHaveContent({ name: "Alice" });
 
 // List by prefix
 const users = await kv.list({ prefix: ["users"] });
@@ -549,7 +551,7 @@ await channel.sendToQueue("my-queue", content);
 
 // Receive message
 const result = await channel.get("my-queue");
-expect(result).ok().hasContent();
+expect(result).toBeSuccessful().toHaveContent();
 if (result.message) {
   await channel.ack(result.message);
 }
@@ -582,7 +584,7 @@ await sqs.ensureQueue("my-queue");
 
 // Send message
 const result = await sqs.send(JSON.stringify({ event: "user.created" }));
-expect(result).ok().hasMessageId();
+expect(result).toBeSuccessful().toHaveMessageId();
 
 // Receive and process
 const messages = await sqs.receive({ maxMessages: 10 });
@@ -650,11 +652,11 @@ Use assertions for expected successes, explicit checks for expected failures:
 ```typescript
 // Expected success - use assertions
 const res = await http.get("/users/1");
-expect(res).ok().status(200);
+expect(res).toBeSuccessful().toHaveStatus(200);
 
 // Expected failure - disable throwing, check manually
 const res = await http.get("/users/nonexistent", { throwOnError: false });
-expect(res).status(404);
+expect(res).toHaveStatus(404);
 ```
 
 ### Configure Retries
@@ -668,7 +670,7 @@ Use retry configuration for network-dependent operations. See
   const res = await http.get("/external-api", {
     retry: { maxAttempts: 3, backoff: "exponential" },
   });
-  expect(res).ok();
+  expect(res).toBeSuccessful();
 }, {
   timeout: 10000, // Allow time for retries
 })

docs/overview.md

@@ -12,7 +12,7 @@ other backend services.
   message queues with unified APIs
 - **Type-safe**: Full type inference through the builder chain
 - **Fluent assertions**: Natural syntax like
-  `expect(result).ok().dataContains({...})`
+  `expect(result).toBeSuccessful().toHaveContentContaining({...})`
 
 ## Installation
 
@@ -72,9 +72,9 @@ export default scenario("User API Test")
     const res = await http.get("/users/1");
 
     expect(res)
-      .ok()
-      .status(200)
-      .dataContains({ id: 1 });
+      .toBeSuccessful()
+      .toHaveStatus(200)
+      .toHaveContentContaining({ id: 1 });
   })
   .build();
 ```
@@ -183,13 +183,20 @@ The `expect()` function auto-dispatches based on result type:
 
 ```typescript
 // HTTP response
-expect(httpResponse).ok().status(200).dataContains({ id: 1 });
+expect(httpResponse)
+  .toBeSuccessful()
+  .toHaveStatus(200)
+  .toHaveContentContaining({ id: 1 });
 
 // SQL result
-expect(sqlResult).count(1).dataContains({ name: "Alice" });
+expect(sqlResult)
+  .toHaveRowCount(1)
+  .toHaveContentContaining({ name: "Alice" });
 
 // gRPC response
-expect(grpcResponse).ok().dataContains({ id: "123" });
+expect(grpcResponse)
+  .toBeSuccessful()
+  .toHaveContentContaining({ id: "123" });
 ```
 
 ## Included Utilities