@danypops/vehicle-conformance 0.1.0 → 0.2.0

package/README.md

@@ -13,5 +13,5 @@ bun add -d @danypops/vehicle-conformance
 import { registerConformanceOperations, runVehicleClientConformance } from "@danypops/vehicle-conformance";
 ```
 
-See the [workspace README](https://github.com/DanyPops/daemon-kit#readme) for
+See the [workspace README](https://github.com/DanyPops/vehicle#readme) for
 the full Vehicle package layout.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@danypops/vehicle-conformance",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"description": "Host-neutral conformance suite for any VehicleClient implementation: one shared bun:test assertion set that LocalVehicleClient, RemoteVehicleClient, and any future transport must satisfy identically. A Bun-only devDependency for testing, not a runtime library -- ships raw TypeScript, never precompiled.",
 	"license": "MIT",
 	"type": "module",
@@ -14,19 +14,26 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@danypops/vehicle-core": "workspace:*",
-		"@danypops/vehicle-server": "workspace:*"
+		"@danypops/vehicle-core": "^0.10.0",
+		"@danypops/vehicle-server": "^0.11.0"
 	},
 	"devDependencies": {
-		"@danypops/vehicle-client": "workspace:*",
+		"@danypops/vehicle-client": "^0.5.0",
 		"@types/node": "^22.0.0",
-		"typescript": "latest"
+		"typescript": "^5.9.2"
 	},
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/DanyPops/daemon-kit.git",
+		"url": "git+https://github.com/DanyPops/vehicle.git",
 		"directory": "packages/vehicle-conformance"
 	},
-	"keywords": ["vehicle", "agent-tools", "testing"],
-	"files": ["src", "README.md"]
+	"keywords": [
+		"vehicle",
+		"agent-tools",
+		"testing"
+	],
+	"files": [
+		"src",
+		"README.md"
+	]
 }

package/src/vehicle-conformance.ts

@@ -19,8 +19,8 @@
  * scope this generalizes.
  */
 import { describe, expect, it } from "bun:test";
-import { bindVehicleOperation, defineVehicleOperation, defineVehicleSchema, VehicleError } from "@danypops/vehicle-core";
 import type { VehicleClient } from "@danypops/vehicle-core";
+import { bindVehicleOperation, defineVehicleOperation, defineVehicleSchema, VehicleError } from "@danypops/vehicle-core";
 import type { VehicleRegistry } from "@danypops/vehicle-server";
 
 const passthroughSchema = defineVehicleSchema<{ value: string }>({
@@ -105,6 +105,22 @@ const ConformanceNever = defineVehicleOperation({
 	limits: LIMITS,
 });
 
+/** Genuinely slow (unlike ConformanceProgress, which resolves near-instantly) -- the streaming-progress-required check needs real elapsed time to exceed its threshold before the "did it report progress" assertion means anything. */
+const SLOW_PROGRESS_DELAY_MS = 60;
+const ConformanceSlowProgress = defineVehicleOperation({
+	name: "conformance.slow-progress",
+	version: 1,
+	description:
+		"Reports one progress event partway through a real delay, then resolves -- streaming: true declares it must never silently block.",
+	input: passthroughSchema,
+	output: outputSchema,
+	permissions: [],
+	effect: "read",
+	idempotency: { mode: "safe" },
+	streaming: true,
+	limits: LIMITS,
+});
+
 /** Registers the fixed conformance operation set onto `registry`. Every fixture must call this before handing back its client. */
 export function registerConformanceOperations(registry: VehicleRegistry): void {
 	registry.register(
@@ -137,8 +153,19 @@ export function registerConformanceOperations(registry: VehicleRegistry): void {
 			});
 		}),
 	);
+	registry.register(
+		"conformance",
+		bindVehicleOperation(ConformanceSlowProgress, () => async (context) => {
+			context.reportProgress({ step: 1 });
+			await new Promise((resolve) => setTimeout(resolve, SLOW_PROGRESS_DELAY_MS));
+			return { echoed: context.input.value };
+		}),
+	);
 }
 
+/** Every operation this suite declares with streaming: true -- the streaming-progress-required check generates one named it() per entry, per this project's own "per-check test isolation" requirement. */
+const STREAMING_OPERATIONS = [{ descriptor: ConformanceSlowProgress.descriptor, thresholdMs: SLOW_PROGRESS_DELAY_MS / 2 }] as const;
+
 export interface VehicleConformanceFixture {
 	/** Used in describe() block titles, e.g. "LocalVehicleClient" or "RemoteVehicleClient (HTTP)". */
 	label: string;
@@ -159,6 +186,7 @@ export function runVehicleClientConformance(fixture: VehicleConformanceFixture):
 					"conformance.keyed@1",
 					"conformance.never@1",
 					"conformance.progress@1",
+					"conformance.slow-progress@1",
 				]);
 				const echo = manifest.operations.find((op) => op.name === "conformance.echo");
 				expect(echo?.permissions).toEqual(["conformance:echo"]);
@@ -176,7 +204,12 @@ export function runVehicleClientConformance(fixture: VehicleConformanceFixture):
 		it("invoke() returns the real handler output on success", async () => {
 			const { client, cleanup } = await fixture.create();
 			try {
-				const result = await client.invoke<{ echoed: string }>("conformance.echo", 1, { value: "hi" }, { permissions: ["conformance:echo"] });
+				const result = await client.invoke<{ echoed: string }>(
+					"conformance.echo",
+					1,
+					{ value: "hi" },
+					{ permissions: ["conformance:echo"] },
+				);
 				expect(result).toEqual({ echoed: "hi" });
 			} finally {
 				await cleanup();
@@ -235,7 +268,9 @@ export function runVehicleClientConformance(fixture: VehicleConformanceFixture):
 			const { client, cleanup } = await fixture.create();
 			try {
 				const oversized = "x".repeat(1024);
-				await expect(client.invoke("conformance.echo", 1, { value: oversized }, { permissions: ["conformance:echo"] })).rejects.toMatchObject({
+				await expect(
+					client.invoke("conformance.echo", 1, { value: oversized }, { permissions: ["conformance:echo"] }),
+				).rejects.toMatchObject({
 					code: "request-too-large",
 				});
 			} finally {
@@ -257,12 +292,17 @@ export function runVehicleClientConformance(fixture: VehicleConformanceFixture):
 			try {
 				const progress: unknown[] = [];
 				let resolved = false;
-				const result = await client.invoke<{ echoed: string }>("conformance.progress", 1, { value: "hi" }, {
-					onProgress: (p) => {
-						expect(resolved).toBe(false);
-						progress.push(p);
+				const result = await client.invoke<{ echoed: string }>(
+					"conformance.progress",
+					1,
+					{ value: "hi" },
+					{
+						onProgress: (p) => {
+							expect(resolved).toBe(false);
+							progress.push(p);
+						},
 					},
-				});
+				);
 				resolved = true;
 				expect(progress).toEqual([{ step: 1 }, { step: 2 }]);
 				expect(result).toEqual({ echoed: "hi" });
@@ -287,7 +327,9 @@ export function runVehicleClientConformance(fixture: VehicleConformanceFixture):
 		it("invoke() respects an explicit deadline that has already elapsed", async () => {
 			const { client, cleanup } = await fixture.create();
 			try {
-				await expect(client.invoke("conformance.echo", 1, { value: "hi" }, { permissions: ["conformance:echo"], deadline: Date.now() - 1 })).rejects.toMatchObject({
+				await expect(
+					client.invoke("conformance.echo", 1, { value: "hi" }, { permissions: ["conformance:echo"], deadline: Date.now() - 1 }),
+				).rejects.toMatchObject({
 					code: "deadline-exceeded",
 				});
 			} finally {
@@ -304,5 +346,75 @@ export function runVehicleClientConformance(fixture: VehicleConformanceFixture):
 				await cleanup();
 			}
 		});
+
+		// Schema-rejection timing: an invalid-input invocation must resolve (with a
+		// validation error) within a small bound, never falling through to a general
+		// timeout -- catches a handler whose validation path accidentally does real
+		// I/O before checking input shape. Ported from Alef's own adapter-contract.ts
+		// runSchemaContract (200ms bound), a separate named check from the existing
+		// "rejects invalid input" test above per this suite's own per-check isolation.
+		it("invoke() rejects invalid input within a bounded time, never falling through to a general timeout", async () => {
+			const { client, cleanup } = await fixture.create();
+			try {
+				const start = Date.now();
+				await expect(client.invoke("conformance.echo", 1, { value: 123 }, { permissions: ["conformance:echo"] })).rejects.toMatchObject({
+					code: "invalid-input",
+				});
+				const elapsed = Date.now() - start;
+				expect(elapsed, `schema rejection took ${elapsed}ms -- should be immediate (<200ms)`).toBeLessThan(200);
+			} finally {
+				await cleanup();
+			}
+		});
+
+		// Human-readable error messages: a validation failure's own .message must
+		// never leak an internal validation-library-specific type name or a bare
+		// stringified object -- a real bug class this ports from Alef's own
+		// adapter-contract.ts (a live zod "[InputValidation]" prefix leak there).
+		it("invoke() rejects invalid input with a human-readable message, never a raw validation-library leak", async () => {
+			const { client, cleanup } = await fixture.create();
+			try {
+				const error = await client.invoke("conformance.echo", 1, { value: 123 }, { permissions: ["conformance:echo"] }).catch((e) => e);
+				const message = (error as { message?: unknown }).message;
+				expect(typeof message).toBe("string");
+				expect(message).not.toBe("[object Object]");
+				expect(message as string).not.toMatch(/ValueError|TypeBoxError|\[InputValidation\]|ZodError/);
+				// Genuinely readable: names which operation failed, not just "invalid".
+				expect(message as string).toContain("conformance.echo");
+			} finally {
+				await cleanup();
+			}
+		});
+
+		// Streaming-progress-required: any operation declared streaming: true must
+		// emit at least one progress event before resolving, once its real
+		// execution exceeds a threshold duration -- catches a handler that
+		// silently blocks the caller instead of reporting progress despite
+		// declaring progress support. One named it() per discovered
+		// streaming-capable operation (this suite currently declares exactly one),
+		// per this project's own per-check test isolation.
+		describe("streaming-progress-required (operations declared streaming: true)", () => {
+			for (const { descriptor, thresholdMs } of STREAMING_OPERATIONS) {
+				it(`${descriptor.name}@${descriptor.version} emits progress before resolving, once it runs past ${thresholdMs}ms`, async () => {
+					const { client, cleanup } = await fixture.create();
+					try {
+						const progress: unknown[] = [];
+						const start = Date.now();
+						await client.invoke(descriptor.name, descriptor.version, { value: "hi" }, { onProgress: (p) => progress.push(p) });
+						const elapsed = Date.now() - start;
+						expect(
+							elapsed,
+							`test fixture ran in ${elapsed}ms, below its own ${thresholdMs}ms threshold -- this check can't prove anything`,
+						).toBeGreaterThan(thresholdMs);
+						expect(
+							progress.length,
+							`${descriptor.name} ran for ${elapsed}ms but emitted zero progress events -- a streaming: true operation must never silently block`,
+						).toBeGreaterThan(0);
+					} finally {
+						await cleanup();
+					}
+				});
+			}
+		});
 	});
 }