@durable-streams/client-conformance-tests 0.1.1 → 0.1.2

package/dist/benchmark-runner-CLAR9oLd.cjs

@@ -0,0 +1,1400 @@
+"use strict";
+const require_chunk = require('./chunk-BCwAaXi7.cjs');
+const require_protocol = require('./protocol-XeAOKBD-.cjs');
+const node_child_process = require_chunk.__toESM(require("node:child_process"));
+const node_readline = require_chunk.__toESM(require("node:readline"));
+const node_crypto = require_chunk.__toESM(require("node:crypto"));
+const __durable_streams_server = require_chunk.__toESM(require("@durable-streams/server"));
+const node_fs = require_chunk.__toESM(require("node:fs"));
+const node_path = require_chunk.__toESM(require("node:path"));
+const yaml = require_chunk.__toESM(require("yaml"));
+const __durable_streams_client = require_chunk.__toESM(require("@durable-streams/client"));
+
+//#region src/test-cases.ts
+/**
+* Load all test suites from a directory.
+*/
+function loadTestSuites(dir) {
+	const suites = [];
+	function walkDir(currentDir) {
+		const entries = node_fs.readdirSync(currentDir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = node_path.join(currentDir, entry.name);
+			if (entry.isDirectory()) walkDir(fullPath);
+			else if (entry.isFile() && (entry.name.endsWith(`.yaml`) || entry.name.endsWith(`.yml`))) {
+				const content = node_fs.readFileSync(fullPath, `utf-8`);
+				const suite = yaml.default.parse(content);
+				suites.push(suite);
+			}
+		}
+	}
+	walkDir(dir);
+	return suites;
+}
+/**
+* Load test suites from the embedded test-cases directory.
+*/
+function loadEmbeddedTestSuites() {
+	const testCasesDir = node_path.join(__dirname, `..`, `test-cases`);
+	return loadTestSuites(testCasesDir);
+}
+/**
+* Filter test suites by category.
+*/
+function filterByCategory(suites, category) {
+	return suites.filter((s) => s.category === category);
+}
+/**
+* Get total test count.
+*/
+function countTests(suites) {
+	return suites.reduce((sum, suite) => sum + suite.tests.length, 0);
+}
+
+//#endregion
+//#region src/runner.ts
+var ClientAdapter = class {
+	process;
+	readline;
+	pendingResponse = null;
+	initialized = false;
+	constructor(executable, args = []) {
+		this.process = (0, node_child_process.spawn)(executable, args, { stdio: [
+			`pipe`,
+			`pipe`,
+			`pipe`
+		] });
+		if (!this.process.stdout || !this.process.stdin) throw new Error(`Failed to create client adapter process`);
+		this.readline = (0, node_readline.createInterface)({
+			input: this.process.stdout,
+			crlfDelay: Infinity
+		});
+		this.readline.on(`line`, (line) => {
+			if (this.pendingResponse) {
+				try {
+					const result = require_protocol.parseResult(line);
+					this.pendingResponse.resolve(result);
+				} catch {
+					this.pendingResponse.reject(new Error(`Failed to parse client response: ${line}`));
+				}
+				this.pendingResponse = null;
+			}
+		});
+		this.process.stderr?.on(`data`, (data) => {
+			console.error(`[client stderr] ${data.toString().trim()}`);
+		});
+		this.process.on(`error`, (err) => {
+			if (this.pendingResponse) {
+				this.pendingResponse.reject(err);
+				this.pendingResponse = null;
+			}
+		});
+		this.process.on(`exit`, (code) => {
+			if (this.pendingResponse) {
+				this.pendingResponse.reject(new Error(`Client adapter exited with code ${code}`));
+				this.pendingResponse = null;
+			}
+		});
+	}
+	async send(command, timeoutMs = 3e4) {
+		if (!this.process.stdin) throw new Error(`Client adapter stdin not available`);
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.pendingResponse = null;
+				reject(new Error(`Command timed out after ${timeoutMs}ms: ${command.type}`));
+			}, timeoutMs);
+			this.pendingResponse = {
+				resolve: (result) => {
+					clearTimeout(timeout);
+					resolve(result);
+				},
+				reject: (error) => {
+					clearTimeout(timeout);
+					reject(error);
+				}
+			};
+			const line = require_protocol.serializeCommand(command) + `\n`;
+			this.process.stdin.write(line);
+		});
+	}
+	async init(serverUrl) {
+		const result = await this.send({
+			type: `init`,
+			serverUrl
+		});
+		if (result.success) this.initialized = true;
+		return result;
+	}
+	async shutdown() {
+		if (this.initialized) try {
+			await this.send({ type: `shutdown` }, 5e3);
+		} catch {}
+		this.process.kill();
+		this.readline.close();
+	}
+	isInitialized() {
+		return this.initialized;
+	}
+};
+function resolveVariables(value, variables) {
+	return value.replace(/\$\{([^}]+)\}/g, (match, expr) => {
+		if (expr === `randomUUID`) return (0, node_crypto.randomUUID)();
+		const parts = expr.split(`.`);
+		let current = variables.get(parts[0]);
+		if (current === void 0) throw new Error(`Undefined variable: ${parts[0]} (in ${match})`);
+		for (let i = 1; i < parts.length && current != null; i++) current = current[parts[i]];
+		return String(current ?? ``);
+	});
+}
+function generateStreamPath() {
+	return `/test-stream-${(0, node_crypto.randomUUID)()}`;
+}
+async function executeOperation(op, ctx) {
+	const { client, variables, verbose, commandTimeout } = ctx;
+	switch (op.action) {
+		case `create`: {
+			const path = op.path ? resolveVariables(op.path, variables) : generateStreamPath();
+			if (op.as) variables.set(op.as, path);
+			const result = await client.send({
+				type: `create`,
+				path,
+				contentType: op.contentType,
+				ttlSeconds: op.ttlSeconds,
+				expiresAt: op.expiresAt,
+				headers: op.headers
+			}, commandTimeout);
+			if (verbose) console.log(`  create ${path}: ${result.success ? `ok` : `failed`}`);
+			return { result };
+		}
+		case `connect`: {
+			const path = resolveVariables(op.path, variables);
+			const result = await client.send({
+				type: `connect`,
+				path,
+				headers: op.headers
+			}, commandTimeout);
+			if (verbose) console.log(`  connect ${path}: ${result.success ? `ok` : `failed`}`);
+			return { result };
+		}
+		case `append`: {
+			const path = resolveVariables(op.path, variables);
+			const data = op.data ? resolveVariables(op.data, variables) : ``;
+			const result = await client.send({
+				type: `append`,
+				path,
+				data: op.binaryData ?? data,
+				binary: !!op.binaryData,
+				seq: op.seq,
+				headers: op.headers
+			}, commandTimeout);
+			if (verbose) console.log(`  append ${path}: ${result.success ? `ok` : `failed`}`);
+			if (result.success && result.type === `append` && op.expect?.storeOffsetAs) variables.set(op.expect.storeOffsetAs, result.offset);
+			return { result };
+		}
+		case `append-batch`: {
+			const path = resolveVariables(op.path, variables);
+			const results = [];
+			for (const item of op.items) {
+				const result = await client.send({
+					type: `append`,
+					path,
+					data: item.binaryData ?? item.data ?? ``,
+					binary: !!item.binaryData,
+					seq: item.seq,
+					headers: op.headers
+				}, commandTimeout);
+				results.push(result);
+			}
+			if (verbose) {
+				const succeeded = results.filter((r) => r.success).length;
+				console.log(`  append-batch ${path}: ${succeeded}/${results.length} succeeded`);
+			}
+			const allSucceeded = results.every((r) => r.success);
+			return { result: {
+				type: `append`,
+				success: allSucceeded,
+				status: allSucceeded ? 200 : 207
+			} };
+		}
+		case `read`: {
+			const path = resolveVariables(op.path, variables);
+			const offset = op.offset ? resolveVariables(op.offset, variables) : void 0;
+			if (op.background && op.as) {
+				const resultPromise = client.send({
+					type: `read`,
+					path,
+					offset,
+					live: op.live,
+					timeoutMs: op.timeoutMs,
+					maxChunks: op.maxChunks,
+					waitForUpToDate: op.waitForUpToDate,
+					headers: op.headers
+				}, commandTimeout);
+				ctx.backgroundOps.set(op.as, resultPromise);
+				if (verbose) console.log(`  read ${path}: started in background as ${op.as}`);
+				return {};
+			}
+			const result = await client.send({
+				type: `read`,
+				path,
+				offset,
+				live: op.live,
+				timeoutMs: op.timeoutMs,
+				maxChunks: op.maxChunks,
+				waitForUpToDate: op.waitForUpToDate,
+				headers: op.headers
+			}, commandTimeout);
+			if (verbose) console.log(`  read ${path}: ${result.success ? `ok` : `failed`}`);
+			if (result.success && result.type === `read`) {
+				if (op.expect?.storeOffsetAs) variables.set(op.expect.storeOffsetAs, result.offset);
+				if (op.expect?.storeDataAs) {
+					const data = result.chunks.map((c) => c.data).join(``);
+					variables.set(op.expect.storeDataAs, data);
+				}
+			}
+			return { result };
+		}
+		case `head`: {
+			const path = resolveVariables(op.path, variables);
+			const result = await client.send({
+				type: `head`,
+				path,
+				headers: op.headers
+			}, commandTimeout);
+			if (verbose) console.log(`  head ${path}: ${result.success ? `ok` : `failed`}`);
+			if (result.success && op.expect?.storeAs) variables.set(op.expect.storeAs, result);
+			return { result };
+		}
+		case `delete`: {
+			const path = resolveVariables(op.path, variables);
+			const result = await client.send({
+				type: `delete`,
+				path,
+				headers: op.headers
+			}, commandTimeout);
+			if (verbose) console.log(`  delete ${path}: ${result.success ? `ok` : `failed`}`);
+			return { result };
+		}
+		case `wait`: {
+			await new Promise((resolve) => setTimeout(resolve, op.ms));
+			return {};
+		}
+		case `set`: {
+			const value = resolveVariables(op.value, variables);
+			variables.set(op.name, value);
+			return {};
+		}
+		case `assert`: {
+			if (op.equals) {
+				const left = resolveVariables(op.equals.left, variables);
+				const right = resolveVariables(op.equals.right, variables);
+				if (left !== right) return { error: op.message ?? `Assertion failed: expected "${left}" to equal "${right}"` };
+			}
+			if (op.notEquals) {
+				const left = resolveVariables(op.notEquals.left, variables);
+				const right = resolveVariables(op.notEquals.right, variables);
+				if (left === right) return { error: op.message ?? `Assertion failed: expected "${left}" to not equal "${right}"` };
+			}
+			if (op.contains) {
+				const value = resolveVariables(op.contains.value, variables);
+				const substring = resolveVariables(op.contains.substring, variables);
+				if (!value.includes(substring)) return { error: op.message ?? `Assertion failed: expected "${value}" to contain "${substring}"` };
+			}
+			if (op.matches) {
+				const value = resolveVariables(op.matches.value, variables);
+				const pattern = op.matches.pattern;
+				try {
+					const regex = new RegExp(pattern);
+					if (!regex.test(value)) return { error: op.message ?? `Assertion failed: expected "${value}" to match /${pattern}/` };
+				} catch {
+					return { error: `Invalid regex pattern: ${pattern}` };
+				}
+			}
+			return {};
+		}
+		case `server-append`: {
+			const path = resolveVariables(op.path, variables);
+			const data = resolveVariables(op.data, variables);
+			try {
+				const headResponse = await fetch(`${ctx.serverUrl}${path}`, { method: `HEAD` });
+				const contentType = headResponse.headers.get(`content-type`) ?? `application/octet-stream`;
+				const response = await fetch(`${ctx.serverUrl}${path}`, {
+					method: `POST`,
+					body: data,
+					headers: {
+						"content-type": contentType,
+						...op.headers
+					}
+				});
+				if (verbose) console.log(`  server-append ${path}: ${response.ok ? `ok` : `failed (${response.status})`}`);
+				if (!response.ok) return { error: `Server append failed with status ${response.status}` };
+				return {};
+			} catch (err) {
+				return { error: `Server append failed: ${err instanceof Error ? err.message : String(err)}` };
+			}
+		}
+		case `await`: {
+			const ref = op.ref;
+			const promise = ctx.backgroundOps.get(ref);
+			if (!promise) return { error: `No background operation found with ref: ${ref}` };
+			const result = await promise;
+			ctx.backgroundOps.delete(ref);
+			if (verbose) console.log(`  await ${ref}: ${result.success ? `ok` : `failed`}`);
+			return { result };
+		}
+		case `inject-error`: {
+			const path = resolveVariables(op.path, variables);
+			try {
+				const response = await fetch(`${ctx.serverUrl}/_test/inject-error`, {
+					method: `POST`,
+					headers: { "content-type": `application/json` },
+					body: JSON.stringify({
+						path,
+						status: op.status,
+						count: op.count ?? 1,
+						retryAfter: op.retryAfter
+					})
+				});
+				if (verbose) console.log(`  inject-error ${path} ${op.status}x${op.count ?? 1}: ${response.ok ? `ok` : `failed`}`);
+				if (!response.ok) return { error: `Failed to inject error: ${response.status}` };
+				return {};
+			} catch (err) {
+				return { error: `Failed to inject error: ${err instanceof Error ? err.message : String(err)}` };
+			}
+		}
+		case `clear-errors`: try {
+			const response = await fetch(`${ctx.serverUrl}/_test/inject-error`, { method: `DELETE` });
+			if (verbose) console.log(`  clear-errors: ${response.ok ? `ok` : `failed`}`);
+			return {};
+		} catch (err) {
+			return { error: `Failed to clear errors: ${err instanceof Error ? err.message : String(err)}` };
+		}
+		case `set-dynamic-header`: {
+			const result = await client.send({
+				type: `set-dynamic-header`,
+				name: op.name,
+				valueType: op.valueType,
+				initialValue: op.initialValue
+			}, commandTimeout);
+			if (verbose) console.log(`  set-dynamic-header ${op.name}: ${result.success ? `ok` : `failed`}`);
+			return { result };
+		}
+		case `set-dynamic-param`: {
+			const result = await client.send({
+				type: `set-dynamic-param`,
+				name: op.name,
+				valueType: op.valueType
+			}, commandTimeout);
+			if (verbose) console.log(`  set-dynamic-param ${op.name}: ${result.success ? `ok` : `failed`}`);
+			return { result };
+		}
+		case `clear-dynamic`: {
+			const result = await client.send({ type: `clear-dynamic` }, commandTimeout);
+			if (verbose) console.log(`  clear-dynamic: ${result.success ? `ok` : `failed`}`);
+			return { result };
+		}
+		default: return { error: `Unknown operation: ${op.action}` };
+	}
+}
+function isReadResult(result) {
+	return result.type === `read` && result.success;
+}
+function isAppendResult(result) {
+	return result.type === `append` && result.success;
+}
+function isHeadResult(result) {
+	return result.type === `head` && result.success;
+}
+function isErrorResult(result) {
+	return result.type === `error` && !result.success;
+}
+function validateExpectation(result, expect) {
+	if (!expect) return null;
+	if (expect.status !== void 0 && `status` in result) {
+		if (result.status !== expect.status) return `Expected status ${expect.status}, got ${result.status}`;
+	}
+	if (expect.errorCode !== void 0) {
+		if (result.success) return `Expected error ${expect.errorCode}, but operation succeeded`;
+		if (isErrorResult(result) && result.errorCode !== expect.errorCode) return `Expected error code ${expect.errorCode}, got ${result.errorCode}`;
+	}
+	if (expect.data !== void 0 && isReadResult(result)) {
+		const actualData = result.chunks.map((c) => c.data).join(``);
+		if (actualData !== expect.data) return `Expected data "${expect.data}", got "${actualData}"`;
+	}
+	if (expect.dataContains !== void 0 && isReadResult(result)) {
+		const actualData = result.chunks.map((c) => c.data).join(``);
+		if (!actualData.includes(expect.dataContains)) return `Expected data to contain "${expect.dataContains}", got "${actualData}"`;
+	}
+	if (expect.dataContainsAll !== void 0 && isReadResult(result)) {
+		const actualData = result.chunks.map((c) => c.data).join(``);
+		const missing = expect.dataContainsAll.filter((s) => !actualData.includes(s));
+		if (missing.length > 0) return `Expected data to contain all of [${expect.dataContainsAll.join(`, `)}], missing: [${missing.join(`, `)}]`;
+	}
+	if (expect.upToDate !== void 0 && isReadResult(result)) {
+		if (result.upToDate !== expect.upToDate) return `Expected upToDate=${expect.upToDate}, got ${result.upToDate}`;
+	}
+	if (expect.chunkCount !== void 0 && isReadResult(result)) {
+		if (result.chunks.length !== expect.chunkCount) return `Expected ${expect.chunkCount} chunks, got ${result.chunks.length}`;
+	}
+	if (expect.minChunks !== void 0 && isReadResult(result)) {
+		if (result.chunks.length < expect.minChunks) return `Expected at least ${expect.minChunks} chunks, got ${result.chunks.length}`;
+	}
+	if (expect.contentType !== void 0 && isHeadResult(result)) {
+		if (result.contentType !== expect.contentType) return `Expected contentType "${expect.contentType}", got "${result.contentType}"`;
+	}
+	if (expect.hasOffset !== void 0 && isHeadResult(result)) {
+		const hasOffset = result.offset !== void 0 && result.offset !== ``;
+		if (hasOffset !== expect.hasOffset) return `Expected hasOffset=${expect.hasOffset}, got ${hasOffset}`;
+	}
+	if (expect.headersSent !== void 0) {
+		const expectedHeaders = expect.headersSent;
+		let actualHeaders;
+		if (isAppendResult(result)) actualHeaders = result.headersSent;
+		else if (isReadResult(result)) actualHeaders = result.headersSent;
+		if (!actualHeaders) return `Expected headersSent but result does not contain headersSent`;
+		for (const [key, expectedValue] of Object.entries(expectedHeaders)) {
+			const actualValue = actualHeaders[key];
+			if (actualValue !== expectedValue) return `Expected headersSent[${key}]="${expectedValue}", got "${actualValue ?? `undefined`}"`;
+		}
+	}
+	if (expect.paramsSent !== void 0) {
+		const expectedParams = expect.paramsSent;
+		let actualParams;
+		if (isAppendResult(result)) actualParams = result.paramsSent;
+		else if (isReadResult(result)) actualParams = result.paramsSent;
+		if (!actualParams) return `Expected paramsSent but result does not contain paramsSent`;
+		for (const [key, expectedValue] of Object.entries(expectedParams)) {
+			const actualValue = actualParams[key];
+			if (actualValue !== expectedValue) return `Expected paramsSent[${key}]="${expectedValue}", got "${actualValue ?? `undefined`}"`;
+		}
+	}
+	return null;
+}
+/**
+* Map feature names from YAML (kebab-case) to client feature property names (camelCase).
+*/
+function featureToProperty(feature) {
+	const map = {
+		batching: `batching`,
+		sse: `sse`,
+		"long-poll": `longPoll`,
+		longPoll: `longPoll`,
+		streaming: `streaming`,
+		dynamicHeaders: `dynamicHeaders`,
+		"dynamic-headers": `dynamicHeaders`
+	};
+	return map[feature];
+}
+/**
+* Check if client supports all required features.
+* Returns list of missing features, or empty array if all satisfied.
+*/
+function getMissingFeatures(requires, clientFeatures) {
+	if (!requires || requires.length === 0) return [];
+	return requires.filter((feature) => {
+		const prop = featureToProperty(feature);
+		return !prop || !clientFeatures[prop];
+	});
+}
+async function runTestCase(test, ctx) {
+	const startTime = Date.now();
+	if (test.skip) return {
+		suite: ``,
+		test: test.id,
+		passed: true,
+		duration: 0,
+		skipped: true,
+		skipReason: typeof test.skip === `string` ? test.skip : void 0
+	};
+	const missingFeatures = getMissingFeatures(test.requires, ctx.clientFeatures);
+	if (missingFeatures.length > 0) return {
+		suite: ``,
+		test: test.id,
+		passed: true,
+		duration: 0,
+		skipped: true,
+		skipReason: `missing features: ${missingFeatures.join(`, `)}`
+	};
+	ctx.variables.clear();
+	ctx.backgroundOps.clear();
+	try {
+		if (test.setup) for (const op of test.setup) {
+			const { error } = await executeOperation(op, ctx);
+			if (error) return {
+				suite: ``,
+				test: test.id,
+				passed: false,
+				duration: Date.now() - startTime,
+				error: `Setup failed: ${error}`
+			};
+		}
+		for (const op of test.operations) {
+			const { result, error } = await executeOperation(op, ctx);
+			if (error) return {
+				suite: ``,
+				test: test.id,
+				passed: false,
+				duration: Date.now() - startTime,
+				error
+			};
+			if (result && `expect` in op && op.expect) {
+				const validationError = validateExpectation(result, op.expect);
+				if (validationError) return {
+					suite: ``,
+					test: test.id,
+					passed: false,
+					duration: Date.now() - startTime,
+					error: validationError
+				};
+			}
+		}
+		if (test.cleanup) for (const op of test.cleanup) try {
+			await executeOperation(op, ctx);
+		} catch {}
+		return {
+			suite: ``,
+			test: test.id,
+			passed: true,
+			duration: Date.now() - startTime
+		};
+	} catch (err) {
+		return {
+			suite: ``,
+			test: test.id,
+			passed: false,
+			duration: Date.now() - startTime,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+async function runConformanceTests(options) {
+	const startTime = Date.now();
+	const results = [];
+	let suites = loadEmbeddedTestSuites();
+	if (options.suites) suites = suites.filter((s) => options.suites.includes(s.category));
+	if (options.tags) suites = suites.map((suite) => ({
+		...suite,
+		tests: suite.tests.filter((test) => test.tags?.some((t) => options.tags.includes(t)) || suite.tags?.some((t) => options.tags.includes(t)))
+	})).filter((suite) => suite.tests.length > 0);
+	const totalTests = countTests(suites);
+	console.log(`\nRunning ${totalTests} client conformance tests...\n`);
+	const server = new __durable_streams_server.DurableStreamTestServer({ port: options.serverPort ?? 0 });
+	await server.start();
+	const serverUrl = server.url;
+	console.log(`Reference server started at ${serverUrl}\n`);
+	let adapterPath = options.clientAdapter;
+	let adapterArgs = options.clientArgs ?? [];
+	if (adapterPath === `ts` || adapterPath === `typescript`) {
+		adapterPath = `npx`;
+		adapterArgs = [`tsx`, new URL(
+			`./adapters/typescript-adapter.ts`,
+			// Multi-status
+			// No result yet - will be retrieved via await
+			// Clean up
+			require("url").pathToFileURL(__filename).href
+).pathname];
+	}
+	const client = new ClientAdapter(adapterPath, adapterArgs);
+	try {
+		const initResult = await client.init(serverUrl);
+		if (!initResult.success) throw new Error(`Failed to initialize client adapter: ${initResult.message}`);
+		let clientFeatures = {};
+		if (initResult.type === `init`) {
+			console.log(`Client: ${initResult.clientName} v${initResult.clientVersion}`);
+			if (initResult.features) {
+				clientFeatures = initResult.features;
+				const featureList = Object.entries(initResult.features).filter(([, v]) => v).map(([k]) => k);
+				console.log(`Features: ${featureList.join(`, `) || `none`}\n`);
+			}
+		}
+		const ctx = {
+			serverUrl,
+			variables: new Map(),
+			client,
+			verbose: options.verbose ?? false,
+			clientFeatures,
+			backgroundOps: new Map(),
+			commandTimeout: options.testTimeout ?? 3e4
+		};
+		for (const suite of suites) {
+			console.log(`\n${suite.name}`);
+			console.log(`─`.repeat(suite.name.length));
+			const suiteMissingFeatures = getMissingFeatures(suite.requires, clientFeatures);
+			for (const test of suite.tests) {
+				if (suiteMissingFeatures.length > 0) {
+					const result$1 = {
+						suite: suite.id,
+						test: test.id,
+						passed: true,
+						duration: 0,
+						skipped: true,
+						skipReason: `missing features: ${suiteMissingFeatures.join(`, `)}`
+					};
+					results.push(result$1);
+					console.log(`  ○ ${test.name} (skipped: missing features: ${suiteMissingFeatures.join(`, `)})`);
+					continue;
+				}
+				const result = await runTestCase(test, ctx);
+				result.suite = suite.id;
+				results.push(result);
+				const icon = result.passed ? result.skipped ? `○` : `✓` : `✗`;
+				const status = result.skipped ? `skipped${result.skipReason ? `: ${result.skipReason}` : ``}` : result.passed ? `${result.duration}ms` : result.error;
+				console.log(`  ${icon} ${test.name} (${status})`);
+				if (options.failFast && !result.passed && !result.skipped) break;
+			}
+			if (options.failFast && results.some((r) => !r.passed && !r.skipped)) break;
+		}
+	} finally {
+		await client.shutdown();
+		await server.stop();
+	}
+	const passed = results.filter((r) => r.passed && !r.skipped).length;
+	const failed = results.filter((r) => !r.passed).length;
+	const skipped = results.filter((r) => r.skipped).length;
+	const summary = {
+		total: results.length,
+		passed,
+		failed,
+		skipped,
+		duration: Date.now() - startTime,
+		results
+	};
+	console.log(`\n` + `═`.repeat(40));
+	console.log(`Total: ${summary.total} tests`);
+	console.log(`Passed: ${summary.passed}`);
+	console.log(`Failed: ${summary.failed}`);
+	console.log(`Skipped: ${summary.skipped}`);
+	console.log(`Duration: ${(summary.duration / 1e3).toFixed(2)}s`);
+	console.log(`═`.repeat(40) + `\n`);
+	if (failed > 0) {
+		console.log(`Failed tests:`);
+		for (const result of results.filter((r) => !r.passed)) console.log(`  - ${result.suite}/${result.test}: ${result.error}`);
+		console.log();
+	}
+	return summary;
+}
+
+//#endregion
+//#region src/benchmark-scenarios.ts
+const appendLatencyScenario = {
+	id: `latency-append`,
+	name: `Append Latency`,
+	description: `Measure time to complete a single append operation`,
+	category: `latency`,
+	config: {
+		warmupIterations: 10,
+		measureIterations: 100,
+		messageSize: 100
+	},
+	criteria: {
+		maxP50Ms: 20,
+		maxP99Ms: 100
+	},
+	createOperation: (ctx) => ({
+		op: `append`,
+		path: `${ctx.basePath}/stream`,
+		size: 100
+	}),
+	setup: (ctx) => {
+		ctx.setupData.streamPath = `${ctx.basePath}/stream`;
+		return Promise.resolve({});
+	}
+};
+const readLatencyScenario = {
+	id: `latency-read`,
+	name: `Read Latency`,
+	description: `Measure time to complete a single read operation`,
+	category: `latency`,
+	config: {
+		warmupIterations: 10,
+		measureIterations: 100,
+		messageSize: 100
+	},
+	criteria: {
+		maxP50Ms: 20,
+		maxP99Ms: 100
+	},
+	createOperation: (ctx) => ({
+		op: `read`,
+		path: `${ctx.basePath}/stream`,
+		offset: ctx.setupData.offset
+	}),
+	setup: (ctx) => {
+		ctx.setupData.streamPath = `${ctx.basePath}/stream`;
+		return Promise.resolve({});
+	}
+};
+const roundtripLatencyScenario = {
+	id: `latency-roundtrip`,
+	name: `Roundtrip Latency`,
+	description: `Measure time to append and immediately read back via long-poll`,
+	category: `latency`,
+	requires: [`longPoll`],
+	config: {
+		warmupIterations: 5,
+		measureIterations: 50,
+		messageSize: 100
+	},
+	criteria: {
+		maxP50Ms: 50,
+		maxP99Ms: 200
+	},
+	createOperation: (ctx) => ({
+		op: `roundtrip`,
+		path: `${ctx.basePath}/roundtrip-${ctx.iteration}`,
+		size: 100,
+		live: `long-poll`
+	})
+};
+const createLatencyScenario = {
+	id: `latency-create`,
+	name: `Create Latency`,
+	description: `Measure time to create a new stream`,
+	category: `latency`,
+	config: {
+		warmupIterations: 5,
+		measureIterations: 50,
+		messageSize: 0
+	},
+	criteria: {
+		maxP50Ms: 30,
+		maxP99Ms: 150
+	},
+	createOperation: (ctx) => ({
+		op: `create`,
+		path: `${ctx.basePath}/create-${ctx.iteration}`,
+		contentType: `application/octet-stream`
+	})
+};
+const smallMessageThroughputScenario = {
+	id: `throughput-small-messages`,
+	name: `Small Message Throughput`,
+	description: `Measure throughput for 100-byte messages at high concurrency`,
+	category: `throughput`,
+	requires: [`batching`],
+	config: {
+		warmupIterations: 2,
+		measureIterations: 10,
+		messageSize: 100,
+		concurrency: 200
+	},
+	criteria: { minOpsPerSecond: 1e3 },
+	createOperation: (ctx) => ({
+		op: `throughput_append`,
+		path: `${ctx.basePath}/throughput-small`,
+		count: 1e4,
+		size: 100,
+		concurrency: 200
+	})
+};
+const largeMessageThroughputScenario = {
+	id: `throughput-large-messages`,
+	name: `Large Message Throughput`,
+	description: `Measure throughput for 1MB messages`,
+	category: `throughput`,
+	requires: [`batching`],
+	config: {
+		warmupIterations: 1,
+		measureIterations: 5,
+		messageSize: 1024 * 1024,
+		concurrency: 10
+	},
+	criteria: { minOpsPerSecond: 20 },
+	createOperation: (ctx) => ({
+		op: `throughput_append`,
+		path: `${ctx.basePath}/throughput-large`,
+		count: 50,
+		size: 1024 * 1024,
+		concurrency: 10
+	})
+};
+const readThroughputScenario = {
+	id: `throughput-read`,
+	name: `Read Throughput`,
+	description: `Measure JSON parsing and iteration speed reading back messages`,
+	category: `throughput`,
+	config: {
+		warmupIterations: 1,
+		measureIterations: 5,
+		messageSize: 100
+	},
+	criteria: { minMBPerSecond: 3 },
+	createOperation: (ctx) => ({
+		op: `throughput_read`,
+		path: `${ctx.basePath}/throughput-read`,
+		expectedCount: ctx.setupData.expectedCount
+	}),
+	setup: (ctx) => {
+		ctx.setupData.expectedCount = 1e4;
+		return Promise.resolve({ data: { expectedCount: 1e4 } });
+	}
+};
+const sseLatencyScenario = {
+	id: `streaming-sse-latency`,
+	name: `SSE First Event Latency`,
+	description: `Measure time to receive first event via SSE`,
+	category: `streaming`,
+	requires: [`sse`],
+	config: {
+		warmupIterations: 3,
+		measureIterations: 20,
+		messageSize: 100
+	},
+	criteria: {
+		maxP50Ms: 100,
+		maxP99Ms: 500
+	},
+	createOperation: (ctx) => ({
+		op: `roundtrip`,
+		path: `${ctx.basePath}/sse-latency-${ctx.iteration}`,
+		size: 100,
+		live: `sse`,
+		contentType: `application/json`
+	})
+};
+const allScenarios = [
+	appendLatencyScenario,
+	readLatencyScenario,
+	roundtripLatencyScenario,
+	createLatencyScenario,
+	smallMessageThroughputScenario,
+	largeMessageThroughputScenario,
+	readThroughputScenario,
+	sseLatencyScenario
+];
+const scenariosByCategory = {
+	latency: allScenarios.filter((s) => s.category === `latency`),
+	throughput: allScenarios.filter((s) => s.category === `throughput`),
+	streaming: allScenarios.filter((s) => s.category === `streaming`)
+};
+function getScenarioById(id) {
+	return allScenarios.find((s) => s.id === id);
+}
+function getScenariosByCategory(category) {
+	return scenariosByCategory[category];
+}
+
+//#endregion
+//#region src/benchmark-runner.ts
+var BenchmarkClientAdapter = class {
+	process;
+	readline;
+	pendingResponse = null;
+	initialized = false;
+	constructor(executable, args = []) {
+		this.process = (0, node_child_process.spawn)(executable, args, { stdio: [
+			`pipe`,
+			`pipe`,
+			`pipe`
+		] });
+		if (!this.process.stdout || !this.process.stdin) throw new Error(`Failed to create client adapter process`);
+		this.readline = (0, node_readline.createInterface)({
+			input: this.process.stdout,
+			crlfDelay: Infinity
+		});
+		this.readline.on(`line`, (line) => {
+			if (this.pendingResponse) {
+				try {
+					const result = require_protocol.parseResult(line);
+					this.pendingResponse.resolve(result);
+				} catch {
+					this.pendingResponse.reject(new Error(`Failed to parse client response: ${line}`));
+				}
+				this.pendingResponse = null;
+			}
+		});
+		this.process.stderr?.on(`data`, (data) => {
+			console.error(`[client stderr] ${data.toString().trim()}`);
+		});
+		this.process.on(`error`, (err) => {
+			if (this.pendingResponse) {
+				this.pendingResponse.reject(err);
+				this.pendingResponse = null;
+			}
+		});
+		this.process.on(`exit`, (code) => {
+			if (this.pendingResponse) {
+				this.pendingResponse.reject(new Error(`Client adapter exited with code ${code}`));
+				this.pendingResponse = null;
+			}
+		});
+	}
+	async send(command, timeoutMs = 6e4) {
+		if (!this.process.stdin) throw new Error(`Client adapter stdin not available`);
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.pendingResponse = null;
+				reject(new Error(`Command timed out after ${timeoutMs}ms: ${command.type}`));
+			}, timeoutMs);
+			this.pendingResponse = {
+				resolve: (result) => {
+					clearTimeout(timeout);
+					resolve(result);
+				},
+				reject: (error) => {
+					clearTimeout(timeout);
+					reject(error);
+				}
+			};
+			const line = require_protocol.serializeCommand(command) + `\n`;
+			this.process.stdin.write(line);
+		});
+	}
+	async init(serverUrl) {
+		const result = await this.send({
+			type: `init`,
+			serverUrl
+		});
+		if (result.success) this.initialized = true;
+		return result;
+	}
+	async benchmark(iterationId, operation) {
+		const result = await this.send({
+			type: `benchmark`,
+			iterationId,
+			operation
+		});
+		if (result.type === `benchmark`) return result;
+		return null;
+	}
+	async shutdown() {
+		if (this.initialized) try {
+			await this.send({ type: `shutdown` }, 5e3);
+		} catch {}
+		this.process.kill();
+		this.readline.close();
+	}
+	isInitialized() {
+		return this.initialized;
+	}
+};
+async function runScenario(scenario, client, serverUrl, clientFeatures, verbose, log) {
+	if (scenario.requires) {
+		const missing = scenario.requires.filter((f) => !clientFeatures[f]);
+		if (missing.length > 0) return {
+			scenario,
+			stats: require_protocol.calculateStats([]),
+			criteriaMet: true,
+			criteriaDetails: [],
+			skipped: true,
+			skipReason: `missing features: ${missing.join(`, `)}`
+		};
+	}
+	const basePath = `/bench-${(0, node_crypto.randomUUID)()}`;
+	const durations = [];
+	try {
+		const setupCtx = {
+			basePath,
+			iteration: 0,
+			setupData: {}
+		};
+		if (scenario.setup) await scenario.setup(setupCtx);
+		if (scenario.id === `latency-append` || scenario.id === `latency-read` || scenario.id.startsWith(`throughput-`)) {
+			const streamUrl = `${serverUrl}${basePath}/stream`;
+			await __durable_streams_client.DurableStream.create({
+				url: streamUrl,
+				contentType: `application/octet-stream`
+			});
+			if (scenario.id === `latency-read`) {
+				const stream = new __durable_streams_client.DurableStream({
+					url: streamUrl,
+					contentType: `application/octet-stream`
+				});
+				const chunk = new Uint8Array(1024).fill(42);
+				for (let i = 0; i < 10; i++) await stream.append(chunk);
+			}
+			if (scenario.id === `throughput-read`) {
+				const url = `${serverUrl}${basePath}/throughput-read`;
+				await __durable_streams_client.DurableStream.create({
+					url,
+					contentType: `application/json`
+				});
+				const ds = new __durable_streams_client.DurableStream({
+					url,
+					contentType: `application/json`
+				});
+				const messages = [];
+				for (let i = 0; i < 1e4; i++) messages.push({
+					n: i,
+					data: `message-${i}-padding-for-size`
+				});
+				await Promise.all(messages.map((msg) => ds.append(msg)));
+			}
+		}
+		if (verbose) log(`  Warmup: ${scenario.config.warmupIterations} iterations...`);
+		for (let i = 0; i < scenario.config.warmupIterations; i++) {
+			const ctx = {
+				basePath,
+				iteration: i,
+				setupData: setupCtx.setupData
+			};
+			const operation = scenario.createOperation(ctx);
+			await client.benchmark(`warmup-${i}`, operation);
+		}
+		if (verbose) log(`  Measuring: ${scenario.config.measureIterations} iterations...`);
+		let totalMessagesProcessed = 0;
+		let totalBytesTransferred = 0;
+		for (let i = 0; i < scenario.config.measureIterations; i++) {
+			const ctx = {
+				basePath,
+				iteration: i,
+				setupData: setupCtx.setupData
+			};
+			const operation = scenario.createOperation(ctx);
+			const result = await client.benchmark(`measure-${i}`, operation);
+			if (result) {
+				durations.push(BigInt(result.durationNs));
+				if (result.metrics) {
+					totalMessagesProcessed += result.metrics.messagesProcessed ?? 0;
+					totalBytesTransferred += result.metrics.bytesTransferred ?? 0;
+				}
+			}
+		}
+		if (scenario.cleanup) await scenario.cleanup(setupCtx);
+		if (durations.length === 0) return {
+			scenario,
+			stats: require_protocol.calculateStats([]),
+			criteriaMet: false,
+			criteriaDetails: [],
+			skipped: false,
+			error: `No benchmark samples collected (adapter returned no results)`
+		};
+		const stats = require_protocol.calculateStats(durations);
+		const totalTimeMs = durations.reduce((sum, ns) => sum + Number(ns) / 1e6, 0);
+		const totalTimeSec = totalTimeMs / 1e3;
+		let computedOpsPerSec;
+		let computedMbPerSec;
+		if (scenario.category === `throughput`) {
+			if (totalMessagesProcessed > 0 && totalTimeSec > 0) computedOpsPerSec = totalMessagesProcessed / totalTimeSec;
+			else if (stats.mean > 0) computedOpsPerSec = 1e3 / stats.mean;
+			if (totalBytesTransferred > 0 && totalTimeSec > 0) computedMbPerSec = totalBytesTransferred / 1024 / 1024 / totalTimeSec;
+		}
+		const criteriaDetails = [];
+		let criteriaMet = true;
+		if (scenario.criteria) {
+			if (scenario.criteria.maxP50Ms !== void 0) {
+				const met = stats.median <= scenario.criteria.maxP50Ms;
+				criteriaDetails.push({
+					criterion: `p50 <= ${scenario.criteria.maxP50Ms}ms`,
+					met,
+					actual: stats.median,
+					expected: scenario.criteria.maxP50Ms
+				});
+				if (!met) criteriaMet = false;
+			}
+			if (scenario.criteria.maxP99Ms !== void 0) {
+				const met = stats.p99 <= scenario.criteria.maxP99Ms;
+				criteriaDetails.push({
+					criterion: `p99 <= ${scenario.criteria.maxP99Ms}ms`,
+					met,
+					actual: stats.p99,
+					expected: scenario.criteria.maxP99Ms
+				});
+				if (!met) criteriaMet = false;
+			}
+			if (scenario.criteria.minOpsPerSecond !== void 0) {
+				const opsPerSec = computedOpsPerSec ?? 0;
+				const met = opsPerSec >= scenario.criteria.minOpsPerSecond;
+				criteriaDetails.push({
+					criterion: `ops/sec >= ${scenario.criteria.minOpsPerSecond}`,
+					met,
+					actual: opsPerSec,
+					expected: scenario.criteria.minOpsPerSecond
+				});
+				if (!met) criteriaMet = false;
+			}
+			if (scenario.criteria.minMBPerSecond !== void 0) {
+				const mbPerSec = totalTimeSec > 0 ? totalBytesTransferred / 1024 / 1024 / totalTimeSec : 0;
+				const met = mbPerSec >= scenario.criteria.minMBPerSecond;
+				criteriaDetails.push({
+					criterion: `MB/sec >= ${scenario.criteria.minMBPerSecond}`,
+					met,
+					actual: mbPerSec,
+					expected: scenario.criteria.minMBPerSecond
+				});
+				if (!met) criteriaMet = false;
+			}
+		}
+		return {
+			scenario,
+			stats,
+			criteriaMet,
+			criteriaDetails,
+			skipped: false,
+			opsPerSec: computedOpsPerSec,
+			mbPerSec: computedMbPerSec
+		};
+	} catch (err) {
+		return {
+			scenario,
+			stats: require_protocol.calculateStats([]),
+			criteriaMet: false,
+			criteriaDetails: [],
+			skipped: false,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+function printConsoleResults(summary) {
+	console.log(`\n${`=`.repeat(60)}`);
+	console.log(`CLIENT BENCHMARK RESULTS`);
+	console.log(`${`=`.repeat(60)}`);
+	console.log(`Adapter: ${summary.adapter} v${summary.adapterVersion}`);
+	console.log(`Server: ${summary.serverUrl}`);
+	console.log(`Timestamp: ${summary.timestamp}`);
+	console.log(`Duration: ${(summary.duration / 1e3).toFixed(2)}s`);
+	console.log();
+	const byCategory = {
+		latency: summary.results.filter((r) => r.scenario.category === `latency`),
+		throughput: summary.results.filter((r) => r.scenario.category === `throughput`),
+		streaming: summary.results.filter((r) => r.scenario.category === `streaming`)
+	};
+	for (const [category, results] of Object.entries(byCategory)) {
+		if (results.length === 0) continue;
+		console.log(`\n${category.toUpperCase()}`);
+		console.log(`${`-`.repeat(40)}`);
+		for (const result of results) {
+			const icon = result.skipped ? `○` : result.criteriaMet ? `✓` : `✗`;
+			const status = result.skipped ? `skipped: ${result.skipReason}` : result.error ? `error: ${result.error}` : result.criteriaMet ? `passed` : `failed`;
+			console.log(`${icon} ${result.scenario.name} (${status})`);
+			if (!result.skipped && !result.error) {
+				const formatted = require_protocol.formatStats(result.stats);
+				if (result.scenario.category === `throughput`) {
+					const mbStr = result.mbPerSec ? result.mbPerSec.toLocaleString(`en-US`, {
+						minimumFractionDigits: 1,
+						maximumFractionDigits: 1
+					}) : `N/A`;
+					if (result.scenario.id === `throughput-read`) console.log(`    MB/sec: ${mbStr}`);
+					else {
+						const opsStr = result.opsPerSec ? result.opsPerSec.toLocaleString(`en-US`, { maximumFractionDigits: 0 }) : `N/A`;
+						console.log(`    Ops/sec: ${opsStr}  MB/sec: ${mbStr}`);
+					}
+				} else console.log(`    Median: ${formatted.Median}  P99: ${formatted.P99}`);
+				if (!result.criteriaMet) for (const c of result.criteriaDetails.filter((d) => !d.met)) console.log(`    ✗ ${c.criterion}: got ${c.actual.toFixed(2)}, expected ${c.expected}`);
+			}
+		}
+	}
+	console.log(`\n${`=`.repeat(60)}`);
+	console.log(`Summary: ${summary.passed} passed, ${summary.failed} failed, ${summary.skipped} skipped`);
+	console.log(`${`=`.repeat(60)}\n`);
+}
+function generateMarkdownReport(summary) {
+	const lines = [];
+	const statusIcon = summary.failed === 0 ? `✓` : `✗`;
+	const statusText = summary.failed === 0 ? `${summary.passed} passed` : `${summary.passed} passed, ${summary.failed} failed`;
+	lines.push(`<details>`);
+	lines.push(`<summary><strong>${summary.adapter}</strong>: ${statusText} ${statusIcon}</summary>`);
+	lines.push(``);
+	lines.push(`### ${summary.adapter} v${summary.adapterVersion}`);
+	lines.push(``);
+	lines.push(`**Server**: ${summary.serverUrl}`);
+	lines.push(`**Date**: ${summary.timestamp}`);
+	lines.push(`**Duration**: ${(summary.duration / 1e3).toFixed(2)}s`);
+	lines.push(``);
+	const latencyResults = summary.results.filter((r) => r.scenario.category === `latency` && !r.skipped && !r.error);
+	if (latencyResults.length > 0) {
+		lines.push(`#### Latency`);
+		lines.push(``);
+		lines.push(`Single-operation latency tests measure the time for individual operations to complete.`);
+		lines.push(``);
+		lines.push(`| Scenario | Description | Min | Median | P95 | P99 | Max | Status |`);
+		lines.push(`|----------|-------------|-----|--------|-----|-----|-----|--------|`);
+		for (const r of latencyResults) {
+			const s = r.stats;
+			const status = r.criteriaMet ? `Pass` : `Fail`;
+			lines.push(`| ${r.scenario.name} | ${r.scenario.description} | ${s.min.toFixed(2)}ms | ${s.median.toFixed(2)}ms | ${s.p95.toFixed(2)}ms | ${s.p99.toFixed(2)}ms | ${s.max.toFixed(2)}ms | ${status} |`);
+		}
+		lines.push(``);
+	}
+	const throughputResults = summary.results.filter((r) => r.scenario.category === `throughput` && !r.skipped && !r.error);
+	if (throughputResults.length > 0) {
+		lines.push(`#### Throughput`);
+		lines.push(``);
+		lines.push(`Throughput tests measure how quickly the client can batch and send/receive data.`);
+		lines.push(`Writes use automatic batching to maximize operations per second.`);
+		lines.push(`Reads measure JSON parsing and iteration speed.`);
+		lines.push(``);
+		lines.push(`| Scenario | Description | Ops/sec | MB/sec | Status |`);
+		lines.push(`|----------|-------------|---------|--------|--------|`);
+		for (const r of throughputResults) {
+			const opsPerSec = r.scenario.id === `throughput-read` ? `-` : r.opsPerSec !== void 0 ? r.opsPerSec.toLocaleString(`en-US`, { maximumFractionDigits: 0 }) : `N/A`;
+			const mbPerSec = r.mbPerSec !== void 0 ? r.mbPerSec.toLocaleString(`en-US`, {
+				minimumFractionDigits: 1,
+				maximumFractionDigits: 1
+			}) : `N/A`;
+			const status = r.criteriaMet ? `Pass` : `Fail`;
+			lines.push(`| ${r.scenario.name} | ${r.scenario.description} | ${opsPerSec} | ${mbPerSec} | ${status} |`);
+		}
+		lines.push(``);
+	}
+	const streamingResults = summary.results.filter((r) => r.scenario.category === `streaming` && !r.skipped && !r.error);
+	if (streamingResults.length > 0) {
+		lines.push(`#### Streaming`);
+		lines.push(``);
+		lines.push(`Streaming tests measure real-time event delivery via SSE (Server-Sent Events).`);
+		lines.push(``);
+		lines.push(`| Scenario | Description | Min | Median | P95 | P99 | Max | Status |`);
+		lines.push(`|----------|-------------|-----|--------|-----|-----|-----|--------|`);
+		for (const r of streamingResults) {
+			const s = r.stats;
+			const status = r.criteriaMet ? `Pass` : `Fail`;
+			lines.push(`| ${r.scenario.name} | ${r.scenario.description} | ${s.min.toFixed(2)}ms | ${s.median.toFixed(2)}ms | ${s.p95.toFixed(2)}ms | ${s.p99.toFixed(2)}ms | ${s.max.toFixed(2)}ms | ${status} |`);
+		}
+		lines.push(``);
+	}
+	lines.push(`#### Summary`);
+	lines.push(``);
+	lines.push(`- **Passed**: ${summary.passed}`);
+	lines.push(`- **Failed**: ${summary.failed}`);
+	lines.push(`- **Skipped**: ${summary.skipped}`);
+	lines.push(``);
+	lines.push(`</details>`);
+	return lines.join(`\n`);
+}
+async function runBenchmarks(options) {
+	const startTime = Date.now();
+	const results = [];
+	const log = (message) => {
+		if (options.format === `json` || options.format === `markdown`) process.stderr.write(message + `\n`);
+		else console.log(message);
+	};
+	let scenarios = allScenarios;
+	if (options.scenarios && options.scenarios.length > 0) scenarios = options.scenarios.map((id) => getScenarioById(id)).filter((s) => s !== void 0);
+	if (options.categories && options.categories.length > 0) scenarios = scenarios.filter((s) => options.categories.includes(s.category));
+	log(`\nRunning ${scenarios.length} benchmark scenarios...\n`);
+	const server = new __durable_streams_server.DurableStreamTestServer({ port: options.serverPort ?? 0 });
+	await server.start();
+	const serverUrl = server.url;
+	log(`Reference server started at ${serverUrl}\n`);
+	let adapterPath = options.clientAdapter;
+	let adapterArgs = options.clientArgs ?? [];
+	if (adapterPath === `ts` || adapterPath === `typescript`) {
+		adapterPath = `npx`;
+		adapterArgs = [`tsx`, new URL(`./adapters/typescript-adapter.ts`, require("url").pathToFileURL(__filename).href).pathname];
+	}
+	const client = new BenchmarkClientAdapter(adapterPath, adapterArgs);
+	let adapterName = `unknown`;
+	let adapterVersion = `0.0.0`;
+	let clientFeatures = {};
+	try {
+		const initResult = await client.init(serverUrl);
+		if (!initResult.success) throw new Error(`Failed to initialize client adapter`);
+		if (initResult.type === `init`) {
+			adapterName = initResult.clientName;
+			adapterVersion = initResult.clientVersion;
+			clientFeatures = initResult.features ?? {};
+			log(`Client: ${adapterName} v${adapterVersion}`);
+			const featureList = Object.entries(clientFeatures).filter(([, v]) => v).map(([k]) => k);
+			log(`Features: ${featureList.join(`, `) || `none`}\n`);
+		}
+		for (const scenario of scenarios) {
+			log(`\n${scenario.name}`);
+			log(`${`─`.repeat(scenario.name.length)}`);
+			log(`${scenario.description}`);
+			const result = await runScenario(scenario, client, serverUrl, clientFeatures, options.verbose ?? false, log);
+			results.push(result);
+			if (result.skipped) log(`  Skipped: ${result.skipReason}`);
+			else if (result.error) log(`  Error: ${result.error}`);
+			else {
+				const icon = result.criteriaMet ? `✓` : `✗`;
+				if (result.scenario.category === `throughput`) {
+					const mbStr = result.mbPerSec ? result.mbPerSec.toLocaleString(`en-US`, {
+						minimumFractionDigits: 1,
+						maximumFractionDigits: 1
+					}) : `N/A`;
+					if (result.scenario.id === `throughput-read`) log(`  ${icon} MB/sec: ${mbStr}`);
+					else {
+						const opsStr = result.opsPerSec ? result.opsPerSec.toLocaleString(`en-US`, { maximumFractionDigits: 0 }) : `N/A`;
+						log(`  ${icon} Ops/sec: ${opsStr}, MB/sec: ${mbStr}`);
+					}
+				} else log(`  ${icon} Median: ${result.stats.median.toFixed(2)}ms, P99: ${result.stats.p99.toFixed(2)}ms`);
+			}
+		}
+	} finally {
+		await client.shutdown();
+		await server.stop();
+	}
+	const summary = {
+		adapter: adapterName,
+		adapterVersion,
+		serverUrl,
+		timestamp: new Date().toISOString(),
+		duration: Date.now() - startTime,
+		results,
+		passed: results.filter((r) => !r.skipped && !r.error && r.criteriaMet).length,
+		failed: results.filter((r) => !r.skipped && (!r.criteriaMet || r.error)).length,
+		skipped: results.filter((r) => r.skipped).length
+	};
+	switch (options.format) {
+		case `json`:
+			console.log(JSON.stringify(summary, null, 2));
+			break;
+		case `markdown`:
+			console.log(generateMarkdownReport(summary));
+			break;
+		default: printConsoleResults(summary);
+	}
+	return summary;
+}
+
+//#endregion
+Object.defineProperty(exports, 'allScenarios', {
+  enumerable: true,
+  get: function () {
+    return allScenarios;
+  }
+});
+Object.defineProperty(exports, 'countTests', {
+  enumerable: true,
+  get: function () {
+    return countTests;
+  }
+});
+Object.defineProperty(exports, 'filterByCategory', {
+  enumerable: true,
+  get: function () {
+    return filterByCategory;
+  }
+});
+Object.defineProperty(exports, 'getScenarioById', {
+  enumerable: true,
+  get: function () {
+    return getScenarioById;
+  }
+});
+Object.defineProperty(exports, 'getScenariosByCategory', {
+  enumerable: true,
+  get: function () {
+    return getScenariosByCategory;
+  }
+});
+Object.defineProperty(exports, 'loadEmbeddedTestSuites', {
+  enumerable: true,
+  get: function () {
+    return loadEmbeddedTestSuites;
+  }
+});
+Object.defineProperty(exports, 'loadTestSuites', {
+  enumerable: true,
+  get: function () {
+    return loadTestSuites;
+  }
+});
+Object.defineProperty(exports, 'runBenchmarks', {
+  enumerable: true,
+  get: function () {
+    return runBenchmarks;
+  }
+});
+Object.defineProperty(exports, 'runConformanceTests', {
+  enumerable: true,
+  get: function () {
+    return runConformanceTests;
+  }
+});
+Object.defineProperty(exports, 'scenariosByCategory', {
+  enumerable: true,
+  get: function () {
+    return scenariosByCategory;
+  }
+});