@jterrazz/test 16.1.1 → 18.0.0

package/dist/stubs.js

@@ -0,0 +1,657 @@
+import { t as isRecord } from "./shared-json-shape.js";
+import { n as refusal } from "./shared-refusal.js";
+import { a as defineStubs, d as structuralEquals, f as structuralSubset, i as defineStub, o as describeRoute, r as declared, t as STREAM_BODY, y as CaptureScope } from "./shared-exchange.js";
+//#region src/stubs/kinds/http-filter.ts
+function rawOf(body) {
+	return typeof body === "string" ? body : JSON.stringify(body ?? "");
+}
+function matchesBody(body, expected) {
+	if (typeof expected === "string") return rawOf(body).includes(expected);
+	if (expected instanceof RegExp) return expected.test(rawOf(body));
+	return structuralSubset(expected, body, new CaptureScope());
+}
+function matchesEntries(expected, lookup) {
+	return Object.entries(expected).every(([key, value]) => {
+		const actual = lookup(key);
+		if (actual === void 0) return false;
+		return value instanceof RegExp ? value.test(actual) : actual === value;
+	});
+}
+function buildMatch(filter) {
+	if (!filter) return;
+	return (request) => {
+		if (filter.body !== void 0 && !matchesBody(request.body, filter.body)) return false;
+		if (filter.headers && !matchesEntries(filter.headers, (key) => request.headers[key.toLowerCase()])) return false;
+		if (filter.query) {
+			let params;
+			try {
+				params = new URL(request.url, "http://stub.invalid").searchParams;
+			} catch {
+				return false;
+			}
+			if (!matchesEntries(filter.query, (key) => params.get(key) ?? void 0)) return false;
+		}
+		return true;
+	};
+}
+function absentHeadersOf(filter = {}) {
+	const absent = filter.without?.headers?.map((name) => name.toLowerCase()) ?? [];
+	if (absent.length === 0) return;
+	const required = new Set(Object.keys(filter.headers ?? {}).map((name) => name.toLowerCase()));
+	const contradicted = absent.filter((name) => required.has(name));
+	if (contradicted.length > 0) {
+		const names = contradicted.join(", ");
+		throw new Error(refusal({
+			fix: `state ${names} in \`headers\` or in \`without.headers\`, never both`,
+			found: `an http stub filter that both requires and forbids the header(s) ${names}`,
+			read: "docs/reference/stubs.md#http-any-url",
+			why: "A header both required and absent matches no request, so the stub could never fire."
+		}));
+	}
+	return absent;
+}
+//#endregion
+//#region src/stubs/kinds/http.ts
+function wrapJson(data) {
+	return {
+		status: 200,
+		body: data
+	};
+}
+const TEXT_CONTENT_TYPE = "text/plain; charset=utf-8";
+const STREAM_CONTENT_TYPE = "application/octet-stream";
+const SSE_CONTENT_TYPE = "text/event-stream";
+function frameEvent(event) {
+	const lines = [];
+	if (event.event !== void 0) lines.push(`event: ${event.event}`);
+	if (event.id !== void 0) lines.push(`id: ${event.id}`);
+	if (event.retry !== void 0) lines.push(`retry: ${event.retry}`);
+	const payload = typeof event.data === "string" ? event.data : JSON.stringify(event.data);
+	for (const line of payload.split("\n")) lines.push(`data: ${line}`);
+	return `${lines.join("\n")}\n\n`;
+}
+function declare(method, url, filter) {
+	const absentHeaders = absentHeadersOf(filter);
+	return {
+		...absentHeaders && { absentHeaders },
+		adapter: "http",
+		match: buildMatch(filter),
+		method,
+		url,
+		wrap: wrapJson
+	};
+}
+/** Generic HTTP stub helpers: an absolute URL, or a path form (`/articles/{{uuid}}`) matching any origin. */
+const http = {
+	any(url, filter) {
+		return declare("*", url, filter);
+	},
+	delete(url, filter) {
+		return declare("DELETE", url, filter);
+	},
+	get(url, filter) {
+		return declare("GET", url, filter);
+	},
+	patch(url, filter) {
+		return declare("PATCH", url, filter);
+	},
+	post(url, filter) {
+		return declare("POST", url, filter);
+	},
+	put(url, filter) {
+		return declare("PUT", url, filter);
+	},
+	/** A stub the chain fails on if the subject reaches its route: `required` with `times: 0`. */
+	never(request) {
+		return {
+			request,
+			required: true,
+			response: {
+				status: 418,
+				body: { error: `@jterrazz/test: ${describeRoute(request)} is declared never requested` }
+			},
+			times: 0
+		};
+	},
+	/** Response: a body-less reply (204 by default). */
+	empty(status = 204) {
+		return {
+			status,
+			body: null
+		};
+	},
+	/** Response: an error status. Without a body, `{ error: 'HTTP <status>' }`. */
+	error(status, body) {
+		return {
+			status,
+			body: body === void 0 ? { error: `HTTP ${status}` } : body
+		};
+	},
+	/** Response: a JSON body (200 by default). */
+	json(body, init) {
+		return {
+			status: init?.status ?? 200,
+			body,
+			delay: init?.delay,
+			headers: init?.headers
+		};
+	},
+	/** Response: no response at all; `fetch` rejects, as when no server is running. */
+	unreachable() {
+		return {
+			body: null,
+			transport: "network-error"
+		};
+	},
+	/** Response: a body that arrives in pieces, written in order. */
+	stream(chunks, init) {
+		return {
+			status: init?.status ?? 200,
+			body: {
+				chunks: [...chunks],
+				contentType: init?.contentType ?? STREAM_CONTENT_TYPE,
+				delayBetweenChunks: init?.delay ?? 0,
+				kind: STREAM_BODY
+			},
+			headers: init?.headers
+		};
+	},
+	/** Response: a server-sent event stream, served as `text/event-stream`. */
+	sse(events, init) {
+		return {
+			status: init?.status ?? 200,
+			body: {
+				chunks: events.map(frameEvent),
+				contentType: SSE_CONTENT_TYPE,
+				delayBetweenChunks: init?.delay ?? 0,
+				kind: STREAM_BODY
+			},
+			headers: {
+				"cache-control": "no-cache",
+				...init?.headers
+			}
+		};
+	},
+	/** Response: a text body, served as `text/plain` (200 by default). */
+	text(body, init) {
+		return {
+			status: init?.status ?? 200,
+			body,
+			delay: init?.delay,
+			headers: {
+				"content-type": TEXT_CONTENT_TYPE,
+				...init?.headers
+			}
+		};
+	}
+};
+//#endregion
+//#region src/stubs/kinds/text-filter.ts
+function matchesText(filter, actual) {
+	if (filter === void 0) return true;
+	if (typeof filter === "string") return actual === filter;
+	if (filter instanceof RegExp) return filter.test(actual);
+	return structuralEquals(filter, actual, new CaptureScope());
+}
+/** A field of a request body read as JSON: absent wherever the body is not an object holding it. */
+function fieldOf(value, key) {
+	return isRecord(value) ? value[key] : void 0;
+}
+const listOf = (value) => Array.isArray(value) ? value : [];
+const textOf = (value) => typeof value === "string" ? value : "";
+/** The content of the first message of `role`, as text: a structured content is its JSON. */
+function messageText(messages, role) {
+	const content = fieldOf(listOf(messages).find((message) => fieldOf(message, "role") === role), "content");
+	return content === void 0 || typeof content === "string" ? textOf(content) : JSON.stringify(content);
+}
+const namesOf = (tools, read) => listOf(tools).map((tool) => textOf(read(tool))).filter((name) => name !== "");
+//#endregion
+//#region src/stubs/kinds/anthropic.ts
+const ANTHROPIC_MESSAGES_URL = "https://api.anthropic.com/v1/messages";
+function matchesFilter(body, filter) {
+	const names = namesOf(fieldOf(body, "tools"), (tool) => fieldOf(tool, "name"));
+	return matchesText(filter.model, textOf(fieldOf(body, "model"))) && matchesText(filter.system, textOf(fieldOf(body, "system"))) && matchesText(filter.user, messageText(fieldOf(body, "messages"), "user")) && (filter.tools?.every((tool) => names.includes(tool)) ?? true);
+}
+function buildReply(data) {
+	return {
+		status: 200,
+		body: {
+			id: "msg-test",
+			type: "message",
+			role: "assistant",
+			content: [{
+				type: "text",
+				text: typeof data === "string" ? data : JSON.stringify(data)
+			}],
+			model: "claude-sonnet-4-20250514",
+			stop_reason: "end_turn",
+			usage: {
+				input_tokens: 10,
+				output_tokens: 10
+			}
+		}
+	};
+}
+function streamEvents(pieces) {
+	return [
+		{
+			type: "message_start",
+			message: {
+				id: "msg-test",
+				type: "message",
+				role: "assistant",
+				content: [],
+				model: "claude-sonnet-4-20250514",
+				stop_reason: null,
+				stop_sequence: null,
+				usage: {
+					input_tokens: 10,
+					output_tokens: 1
+				}
+			}
+		},
+		{
+			type: "content_block_start",
+			index: 0,
+			content_block: {
+				type: "text",
+				text: ""
+			}
+		},
+		{ type: "ping" },
+		...pieces.map((text) => ({
+			type: "content_block_delta",
+			index: 0,
+			delta: {
+				type: "text_delta",
+				text
+			}
+		})),
+		{
+			type: "content_block_stop",
+			index: 0
+		},
+		{
+			type: "message_delta",
+			delta: {
+				stop_reason: "end_turn",
+				stop_sequence: null
+			},
+			usage: { output_tokens: 10 }
+		},
+		{ type: "message_stop" }
+	].map((data) => ({
+		data,
+		event: data.type
+	}));
+}
+/** Anthropic API stub helpers. */
+const anthropic = {
+	/** Match Messages API calls, optionally through a gateway URL; a string filter is exact equality. */
+	messages(filter, url) {
+		return {
+			adapter: "anthropic",
+			method: "POST",
+			url: url ?? ANTHROPIC_MESSAGES_URL,
+			match: filter ? ({ body }) => matchesFilter(body, filter) : void 0,
+			wrap(data) {
+				if (isRecord(data)) return {
+					status: 200,
+					body: data
+				};
+				return buildReply(data);
+			}
+		};
+	},
+	/** A stub the chain fails on if the subject reaches this endpoint: `http.never()`. */
+	never(request) {
+		return http.never(request);
+	},
+	/** Response: data wrapped in the Messages format. */
+	reply(data) {
+		return buildReply(data);
+	},
+	/** Response: the text streamed as server-sent events, one `text_delta` per piece. */
+	stream(pieces, init) {
+		return http.sse(streamEvents(pieces), { delay: init?.delay ?? 0 });
+	},
+	/** Response: return an Anthropic error. */
+	error(status, message) {
+		return {
+			status,
+			body: {
+				type: "error",
+				error: {
+					type: status === 429 ? "rate_limit_error" : "api_error",
+					message: message ?? `Anthropic error (${status})`
+				}
+			}
+		};
+	},
+	/** Response: simulate a timeout. */
+	timeout() {
+		return {
+			status: 200,
+			body: {},
+			delay: 3e4
+		};
+	}
+};
+//#endregion
+//#region src/stubs/kinds/openai.ts
+const OPENAI_CHAT_URL = "https://api.openai.com/v1/chat/completions";
+const OPENAI_RESPONSES_URL = "https://api.openai.com/v1/responses";
+function matchesChatFilter(body, filter) {
+	const messages = fieldOf(body, "messages");
+	const names = namesOf(fieldOf(body, "tools"), (tool) => fieldOf(fieldOf(tool, "function"), "name"));
+	return matchesText(filter.model, textOf(fieldOf(body, "model"))) && matchesText(filter.system, messageText(messages, "system")) && matchesText(filter.user, messageText(messages, "user")) && (filter.tools?.every((tool) => names.includes(tool)) ?? true) && (filter.temperature === void 0 || fieldOf(body, "temperature") === filter.temperature);
+}
+function matchesResponsesFilter(body, filter) {
+	const input = fieldOf(body, "input");
+	const instructions = textOf(fieldOf(body, "instructions"));
+	const userText = listOf(input).filter((message) => fieldOf(message, "role") === "user").map((message) => {
+		const content = fieldOf(message, "content");
+		return typeof content === "string" ? content : JSON.stringify(content);
+	}).join(" ");
+	const names = namesOf(fieldOf(body, "tools"), (tool) => fieldOf(tool, "name") ?? fieldOf(fieldOf(tool, "function"), "name"));
+	return matchesText(filter.model, textOf(fieldOf(body, "model"))) && matchesText(filter.system, instructions === "" ? messageText(input, "system") : instructions) && matchesText(filter.user, userText) && (filter.tools?.every((tool) => names.includes(tool)) ?? true);
+}
+function buildChatReply(data) {
+	const content = typeof data === "string" ? data : JSON.stringify(data);
+	return {
+		status: 200,
+		body: {
+			id: "chatcmpl-test",
+			object: "chat.completion",
+			created: Math.floor(Date.now() / 1e3),
+			model: "gpt-4o-test",
+			choices: [{
+				index: 0,
+				message: {
+					role: "assistant",
+					content
+				},
+				finish_reason: "stop"
+			}],
+			usage: {
+				prompt_tokens: 10,
+				completion_tokens: 10,
+				total_tokens: 20
+			}
+		}
+	};
+}
+function responsesEnvelope(text, usage = DEFAULT_USAGE) {
+	return {
+		id: "resp-test",
+		object: "response",
+		created_at: Math.floor(Date.now() / 1e3),
+		model: "gpt-4o-test",
+		output: [{
+			type: "message",
+			id: "msg-test",
+			role: "assistant",
+			content: [{
+				type: "output_text",
+				text,
+				annotations: []
+			}]
+		}],
+		usage: {
+			input_tokens: usage.promptTokens,
+			output_tokens: usage.completionTokens,
+			total_tokens: usage.promptTokens + usage.completionTokens
+		}
+	};
+}
+function buildResponsesReply(data) {
+	return {
+		status: 200,
+		body: responsesEnvelope(typeof data === "string" ? data : JSON.stringify(data))
+	};
+}
+const DEFAULT_USAGE = {
+	completionTokens: 10,
+	promptTokens: 10
+};
+function chatStreamEvents(pieces, usage) {
+	const created = Math.floor(Date.now() / 1e3);
+	const chunk = (delta, finishReason) => ({ data: {
+		id: "chatcmpl-test",
+		object: "chat.completion.chunk",
+		created,
+		model: "gpt-4o-test",
+		choices: [{
+			index: 0,
+			delta,
+			logprobs: null,
+			finish_reason: finishReason
+		}]
+	} });
+	return [
+		chunk({
+			role: "assistant",
+			content: ""
+		}, null),
+		...pieces.map((piece) => chunk({ content: piece }, null)),
+		chunk({}, "stop"),
+		...usage === void 0 ? [] : [{ data: {
+			id: "chatcmpl-test",
+			object: "chat.completion.chunk",
+			created,
+			model: "gpt-4o-test",
+			choices: [],
+			usage: {
+				prompt_tokens: usage.promptTokens,
+				completion_tokens: usage.completionTokens,
+				total_tokens: usage.promptTokens + usage.completionTokens
+			}
+		} }],
+		{ data: "[DONE]" }
+	];
+}
+function responsesStreamEvents(pieces, usage) {
+	const text = pieces.join("");
+	const part = {
+		type: "output_text",
+		text,
+		annotations: []
+	};
+	const item = {
+		id: "msg-test",
+		type: "message",
+		role: "assistant"
+	};
+	const done = {
+		...item,
+		status: "completed",
+		content: [part]
+	};
+	const completed = {
+		...responsesEnvelope(text, usage),
+		status: "completed"
+	};
+	const at = {
+		item_id: "msg-test",
+		output_index: 0,
+		content_index: 0
+	};
+	return [
+		{
+			type: "response.created",
+			response: {
+				...completed,
+				status: "in_progress",
+				output: [],
+				usage: null
+			}
+		},
+		{
+			type: "response.output_item.added",
+			output_index: 0,
+			item: {
+				...item,
+				status: "in_progress",
+				content: []
+			}
+		},
+		{
+			type: "response.content_part.added",
+			...at,
+			part: {
+				...part,
+				text: ""
+			}
+		},
+		...pieces.map((delta) => ({
+			type: "response.output_text.delta",
+			...at,
+			delta
+		})),
+		{
+			type: "response.output_text.done",
+			...at,
+			text
+		},
+		{
+			type: "response.content_part.done",
+			...at,
+			part
+		},
+		{
+			type: "response.output_item.done",
+			output_index: 0,
+			item: done
+		},
+		{
+			type: "response.completed",
+			response: {
+				...completed,
+				output: [done]
+			}
+		}
+	].map((body, index) => ({
+		data: {
+			...body,
+			sequence_number: index
+		},
+		event: body.type
+	}));
+}
+/** OpenAI API stub helpers. */
+const openai = {
+	/** Match Chat Completions calls, at `url` where the client reaches another host; a string filter is exact equality, a RegExp or `match.includes` loosens it. */
+	chat(filter, url) {
+		return {
+			adapter: "openai",
+			method: "POST",
+			url: url ?? OPENAI_CHAT_URL,
+			match: filter ? ({ body }) => matchesChatFilter(body, filter) : void 0,
+			wrap: buildChatReply
+		};
+	},
+	/** Match Responses API calls; a JSON file is wrapped in the Responses envelope. */
+	responses(filter, url) {
+		return {
+			adapter: "openai",
+			method: "POST",
+			url: url ?? OPENAI_RESPONSES_URL,
+			match: filter ? ({ body }) => matchesResponsesFilter(body, filter) : void 0,
+			wrap: buildResponsesReply
+		};
+	},
+	/** A stub the chain fails on if the subject reaches this endpoint: `http.never()`. */
+	never(request) {
+		return http.never(request);
+	},
+	/** Response: data wrapped in the Chat Completions format. */
+	reply(data) {
+		return buildChatReply(data);
+	},
+	/** Response: the text streamed as server-sent events; `api` picks Chat Completions (default) or Responses. */
+	stream(pieces, init) {
+		const events = init?.api === "responses" ? responsesStreamEvents(pieces, init.usage) : chatStreamEvents(pieces, init?.usage);
+		return http.sse(events, { delay: init?.delay ?? 0 });
+	},
+	/** Response: return an OpenAI error. */
+	error(status, message) {
+		return {
+			status,
+			body: { error: {
+				message: message ?? `OpenAI error (${status})`,
+				type: status === 429 ? "rate_limit_error" : "api_error",
+				code: status === 429 ? "rate_limit_exceeded" : null
+			} }
+		};
+	},
+	/** Response: return malformed content. */
+	malformed(content) {
+		return buildChatReply(content);
+	},
+	/** Response: simulate a timeout. */
+	timeout() {
+		return {
+			status: 200,
+			body: {},
+			delay: 3e4
+		};
+	}
+};
+//#endregion
+//#region src/stubs/intercept/intercept.ts
+function isOptions(value) {
+	return isRecord(value) && "origin" in value;
+}
+function resolveRelativeAgainst(origin) {
+	let base;
+	try {
+		base = new URL(origin);
+	} catch {
+		throw new Error(refusal({
+			fix: "state an absolute URL: intercept(stubs, { origin: 'http://console.test' })",
+			found: `intercept(): \`origin\` is \`${origin}\`, not an absolute URL`,
+			read: "docs/reference/stubs.md#intercept-the-same-double-with-no-chain",
+			why: "`origin` states where a relative request resolves, so it is an absolute URL."
+		}));
+	}
+	return () => {
+		const underlying = globalThis.fetch;
+		globalThis.fetch = async (input, init) => typeof input === "string" ? await underlying(new URL(input, base).toString(), init) : await underlying(input, init);
+		return () => {
+			globalThis.fetch = underlying;
+		};
+	};
+}
+function interceptThrough(register) {
+	async function intercept(requestOrStubs, maybeResponseOrOptions, maybeOptions) {
+		const options = isOptions(maybeOptions) ? maybeOptions : isOptions(maybeResponseOrOptions) ? maybeResponseOrOptions : void 0;
+		const stubs = declared("intercept", requestOrStubs, isOptions(maybeResponseOrOptions) ? void 0 : maybeResponseOrOptions);
+		if (stubs.length === 0) throw new Error(refusal({
+			fix: "declare at least one stub, or drop the intercept: a subject with no network needs none",
+			found: "intercept(), and the list of stubs is empty",
+			read: "docs/reference/stubs.md#intercept-the-same-double-with-no-chain",
+			why: "An empty list guards nothing."
+		}));
+		const installOrigin = options?.origin === void 0 ? void 0 : resolveRelativeAgainst(options.origin);
+		const registration = await register(stubs);
+		const restoreOrigin = installOrigin?.();
+		return { [Symbol.asyncDispose]: async () => {
+			restoreOrigin?.();
+			const violation = registration.violation();
+			registration.cleanup();
+			if (violation) throw violation;
+		} };
+	}
+	return intercept;
+}
+//#endregion
+//#region src/stubs/delivery/same-process/intercept.ts
+/** The module-scope network double, on msw's node server. */
+const intercept = interceptThrough(async (stubs) => {
+	const { registerStubs } = await import("./shared-stub-server.js");
+	return await registerStubs(stubs);
+});
+//#endregion
+export { anthropic, defineStub, defineStubs, http, intercept, openai };
+
+//# sourceMappingURL=stubs.js.map

package/dist/temp-root.global-setup.d.ts

@@ -0,0 +1,7 @@
+//#region src/chain/paths/temp-root.global-setup.d.ts
+/** Named by uid: a temp directory users share never holds a folder one of them cannot sweep. */
+export declare const TEMP_ROOTS_PARENT: string;
+export declare function tempRootSetup(): string;
+export default function setup(): () => void;
+//#endregion
+//# sourceMappingURL=temp-root.global-setup.d.ts.map

package/dist/temp-root.global-setup.js

@@ -0,0 +1 @@
+export { t as TEMP_ROOTS_PARENT, n as default, r as tempRootSetup } from "./shared-temp-root.global-setup.js";