@yolk-sdk/emulators 0.1.0-canary.96

package/dist/gateway.mjs

@@ -0,0 +1,400 @@
+import { emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { composeFetch } from "./emulator-compose.mjs";
+import { FixtureRouteFault, makeFixtureRouteEmulator } from "./fixture-route.mjs";
+import { ChatFault, ChatFaultMatch, ChatScriptedError, ChatScriptedReasoningCompletion, ChatScriptedReasoningTurn, ChatScriptedToolCall, ChatScriptedUsage, makeChatCompletionsEmulator } from "./chat-completions.mjs";
+import { gatewayEvaluateRecordings } from "./gateway-evaluate-recordings.mjs";
+import { Data } from "effect";
+//#region src/gateway.ts
+/**
+* Vercel AI Gateway emulator: a plain fetch handler for the OpenAI-compatible
+* `POST /v1/chat/completions` endpoint, with scripted turns, wire faults, a
+* request ledger, and an `/_emulate/*` control plane.
+*
+* It never imports SDK code: its wire shapes follow the verified live Gateway
+* conformance recordings (2026-09-30), copied as data: `chat.completion.chunk`
+* SSE with several events per network chunk, `delta.reasoning` plus
+* `reasoning_details` for DeepSeek reasoning, a finish event carrying
+* `provider_metadata`, `usage`, `system_fingerprint`, `service_tier`, and
+* `generationId`, then `data: [DONE]`, and the 404 `model_not_found`
+* envelope `{ error: { message, type, param: { modelId } } }` for unknown
+* models. Ids, costs, and routing metadata are synthetic stand-ins. The route
+* is linked to those conformance case ids in `gatewayEmulatorRoutes`
+* (`verified`). The Chat Completions machinery is shared with the OpenAI
+* emulator (`chat-completions.ts`); this module supplies the Gateway's paths,
+* models, envelope, reasoning, and wire profile.
+*
+* Not covered by a recording (synthetic): the 401 error, default fault
+* bodies, the non-streamed `chat.completion` body, and the answer to a request
+* without a `model` (404 `Model '' not found` with `param.modelId: null`).
+*
+* The same fetch handler also answers the classifier route `POST /v1/evaluate`
+* (AI Gateway calls classification "evaluation"; `emulator.evaluate`) with its
+* own manifest (`gatewayEvaluateEmulatorRoutes`, unverified), ledger, faults,
+* and turns. It is fixture-only: a request matching one of the four synthetic
+* classifier conformance recordings (boolean, choice, score, unknown-model
+* error envelope; `gateway-evaluate-recordings.ts`, copied as data) within the
+* shared request-shape latitude gets that recording's response; anything else
+* answers 400 not-emulated.
+*
+* Runtime-portable Web APIs only (`Request`, `Response`, `ReadableStream`,
+* `TextEncoder`, `URL`); no Effect runtime is required to use it.
+*
+* @experimental
+*/
+const gatewayChatCompletionsPath = "/v1/chat/completions";
+/** The AI Gateway classifier ("evaluation") path. */
+const gatewayEvaluatePath = "/v1/evaluate";
+/** Synthetic-safe default model ids, including the Gateway conformance defaults. */
+const gatewayEmulatorDefaultModels = [
+	"openai/gpt-4.1-nano",
+	"openai/gpt-4.1-mini",
+	"deepseek/deepseek-v3.2",
+	"deepseek/deepseek-v4.1-flash"
+];
+/** Models that stream reasoning deltas when reasoning is requested. */
+const gatewayEmulatorDefaultReasoningModels = ["deepseek/deepseek-v3.2", "deepseek/deepseek-v4.1-flash"];
+/**
+* SSE events per network chunk by default. The live Gateway packs several
+* events into one network chunk (the recordings carry one to four, always
+* with the finish event and `data: [DONE]` together in the last chunk).
+*/
+const gatewayEmulatorDefaultEventsPerChunk = 2;
+/**
+* Route evidence manifest: every emulated Gateway route and the conformance
+* cases whose verified live recordings (2026-09-30) its wire shapes follow.
+*/
+const gatewayEmulatorRoutes = [{
+	method: "POST",
+	path: gatewayChatCompletionsPath,
+	kind: "provider",
+	write: false,
+	caseIds: [
+		"vercel-ai-gateway.stream.plain-text",
+		"vercel-ai-gateway.stream.deepseek-reasoning",
+		"vercel-ai-gateway.stream.tool-call-deltas",
+		"vercel-ai-gateway.stream.error-envelope"
+	],
+	evidence: "verified",
+	observedAt: "2026-09-30"
+}];
+/**
+* Route evidence manifest of the classifier route (served by the same fetch handler, with its own
+* ledger, faults, and coverage). Its recordings are synthetic placeholders, so it is unverified.
+*/
+const gatewayEvaluateEmulatorRoutes = [{
+	method: "POST",
+	path: gatewayEvaluatePath,
+	kind: "provider",
+	write: false,
+	caseIds: [
+		"vercel-ai-gateway.classify.boolean",
+		"vercel-ai-gateway.classify.choice",
+		"vercel-ai-gateway.classify.score",
+		"vercel-ai-gateway.classify.error-envelope"
+	],
+	evidence: "unverified",
+	observedAt: void 0
+}];
+/** Optional fault filter; an omitted field matches every request. `path` ending in `*` is a prefix. */
+const GatewayFaultMatch = ChatFaultMatch;
+/**
+* Wire faults for emulated routes:
+*
+* - `status`: answer with this status, headers, and body instead of a
+*   completion (for example 429 with `retry-after`). The body defaults to a
+*   Gateway error envelope. Statuses that cannot carry a body (1xx, 204, 205,
+*   304) and redirects (3xx) are rejected, as are invalid header names or
+*   values and a `location` header; scripted errors follow the same rules.
+* - `error-after-chunks`: send `chunks` body chunks, then error the body
+*   stream (a dropped connection).
+* - `truncate-after-chunks`: send `chunks` body chunks, then close the body
+*   cleanly (for example without `data: [DONE]`).
+*
+* Chunk faults count network chunks: a streamed chunk carries up to
+* `eventsPerChunk` SSE events (default 2), and a whole JSON body counts as one
+* chunk. A chunk fault that cannot take effect (`error-after-chunks` beyond
+* the chunk count, or `truncate-after-chunks` at or beyond it) answers 500
+* with an emulator error instead of silently doing nothing, and is not
+* consumed.
+*/
+const GatewayFault = ChatFault;
+/**
+* Usage for a scripted turn, sent as the Gateway `usage` object (token counts,
+* `completion_tokens_details.reasoning_tokens` defaulting to 0, and synthetic
+* zero costs).
+*/
+const GatewayScriptedUsage = ChatScriptedUsage;
+/** One scripted tool call; its JSON arguments stream as these fragments. */
+const GatewayScriptedToolCall = ChatScriptedToolCall;
+/**
+* A scripted completion. Every field is exact (nothing is filled in) except:
+* `usage` omitted is synthesized when the request asks for usage, and `null`
+* drops it; `finishReason` omitted is `tool_calls` with tool calls, else
+* `stop`. `order` defaults to `reasoning-first`; `reasoningField` defaults to
+* `reasoning` (streamed with `reasoning_details`, as recorded live); the
+* DeepSeek-native `reasoning_content` is sent alone.
+*/
+const GatewayScriptedCompletion = ChatScriptedReasoningCompletion;
+/** A scripted error response: status, body (a string is sent as is), and optional headers. */
+const GatewayScriptedError = ChatScriptedError;
+/** A turn queued for the next chat completion request. */
+const GatewayScriptedTurn = ChatScriptedReasoningTurn;
+/**
+* Thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input, and
+* by `makeGatewayEmulator` for invalid options; a programmer error.
+*/
+var GatewayEmulatorInputInvalid = class extends Data.TaggedError("GatewayEmulatorInputInvalid") {
+	get message() {
+		return `Invalid Gateway emulator ${this.input}: ${this.reason}`;
+	}
+};
+/** A classifier-route fault (`status` 400-599, `error-after-chunks`, `truncate-after-chunks`). */
+const GatewayEvaluateFault = FixtureRouteFault;
+const gatewayErrorEnvelope = (error) => ({ error: {
+	message: error.message,
+	type: error.type,
+	code: error.code
+} });
+const syntheticFingerprint = "fp_synthetic";
+const syntheticAttemptTime = 179e10;
+const syntheticCost = "0";
+const vendorOf = (model) => {
+	const [vendor] = model.split("/");
+	return vendor === void 0 || vendor.length === 0 || vendor === model ? void 0 : vendor;
+};
+const isOpenAiModel = (model) => vendorOf(model) === "openai";
+const syntheticResponseId = (identity) => `resp_synthetic_${identity.id}`;
+/**
+* The upstream provider the Gateway routes a model to, and its `provider_metadata` entry (keyed by
+* that provider), per model family as recorded: `openai/*` routes to `openai` with
+* `{ responseId, serviceTier }`; `deepseek/*` routes to `baseten` with
+* `{ acceptedPredictionTokens, rejectedPredictionTokens }` (synthetic zero counts). Other families
+* were not recorded: they route to their vendor prefix without an upstream entry.
+*/
+const upstreamOf = (identity) => {
+	const vendor = vendorOf(identity.model);
+	if (vendor === "openai") return {
+		provider: "openai",
+		entry: {
+			responseId: syntheticResponseId(identity),
+			serviceTier: "default"
+		}
+	};
+	if (vendor === "deepseek") return {
+		provider: "baseten",
+		entry: {
+			acceptedPredictionTokens: 0,
+			rejectedPredictionTokens: 0
+		}
+	};
+	return { provider: vendor ?? "synthetic" };
+};
+/** The `gateway` entry of `provider_metadata`: routing, costs, and the generation id. */
+const gatewayRoutingMetadata = (identity) => {
+	const { provider } = upstreamOf(identity);
+	const responseId = syntheticResponseId(identity);
+	return {
+		routing: {
+			originalModelId: identity.model,
+			resolvedProvider: provider,
+			fallbacksAvailable: ["synthetic-fallback"],
+			planningReasoning: "Synthetic: routing planned by the emulator.",
+			canonicalSlug: identity.model,
+			finalProvider: provider,
+			modelAttemptCount: 1,
+			modelAttempts: [{
+				canonicalSlug: identity.model,
+				success: true,
+				providerAttemptCount: 1,
+				providerAttempts: [{
+					provider,
+					credentialType: "system",
+					success: true,
+					startTime: syntheticAttemptTime,
+					endTime: syntheticAttemptTime + 1,
+					providerRequestId: `req_synthetic_${identity.id}`,
+					statusCode: 200,
+					providerResponseId: responseId
+				}]
+			}],
+			totalProviderAttemptCount: 1,
+			affinity: { outcome: "skipped_below_min_prefix" },
+			clientSessionId: "synthetic-client-session",
+			clientSessionIdSource: "fingerprint"
+		},
+		cost: syntheticCost,
+		marketCost: syntheticCost,
+		surchargeCost: syntheticCost,
+		gatewayCost: syntheticCost,
+		inferenceCost: syntheticCost,
+		inputInferenceCost: syntheticCost,
+		outputInferenceCost: syntheticCost,
+		generationId: identity.id
+	};
+};
+/** `provider_metadata`: the upstream provider's entry first (when its family has one), then `gateway`. */
+const gatewayProviderMetadata = (identity) => {
+	const metadata = {};
+	const upstream = upstreamOf(identity);
+	if (upstream.entry !== void 0) metadata[upstream.provider] = upstream.entry;
+	metadata.gateway = gatewayRoutingMetadata(identity);
+	return metadata;
+};
+const gatewayUsage = (counts) => ({
+	prompt_tokens: counts.promptTokens,
+	completion_tokens: counts.completionTokens,
+	total_tokens: counts.promptTokens + counts.completionTokens,
+	cost: 0,
+	is_byok: false,
+	prompt_tokens_details: {
+		cached_tokens: 0,
+		audio_tokens: 0,
+		video_tokens: 0
+	},
+	cost_details: {
+		upstream_inference_cost: null,
+		upstream_inference_prompt_cost: 0,
+		upstream_inference_completions_cost: 0
+	},
+	completion_tokens_details: {
+		reasoning_tokens: counts.reasoningTokens ?? 0,
+		image_tokens: 0
+	},
+	cache_creation_input_tokens: 0,
+	market_cost: 0,
+	gateway_cost: 0
+});
+const gatewayWireProfile = (eventsPerChunk) => ({
+	eventsPerChunk,
+	streamUsage: "finish-event",
+	openingDelta: { role: "assistant" },
+	choiceFields: { logprobs: null },
+	reasoningField: "reasoning",
+	reasoningDetails: true,
+	chunkFields: () => ({ system_fingerprint: syntheticFingerprint }),
+	finishFields: (identity) => {
+		const chunk = {};
+		if (isOpenAiModel(identity.model)) chunk.service_tier = "default";
+		chunk.generationId = identity.id;
+		return {
+			delta: { provider_metadata: gatewayProviderMetadata(identity) },
+			chunk
+		};
+	},
+	usage: gatewayUsage
+});
+const validEventsPerChunk = (eventsPerChunk) => {
+	const value = eventsPerChunk ?? 2;
+	if (!Number.isSafeInteger(value) || value < 1) throw new GatewayEmulatorInputInvalid({
+		input: "options",
+		reason: `eventsPerChunk must be a positive integer, got ${String(eventsPerChunk)}`
+	});
+	return value;
+};
+/**
+* Create a Vercel AI Gateway emulator. Each call has independent ledger,
+* fault, and script state. Throws `GatewayEmulatorInputInvalid` for an
+* invalid `eventsPerChunk`.
+*
+* Without a script, `POST /v1/chat/completions` answers a known model with
+* synthetic text deltas. `stream: true` sends `chat.completion.chunk` SSE in
+* the recorded Gateway shape: a `{ role: 'assistant' }` opening delta, content
+* deltas, and a finish event whose delta carries `provider_metadata` and which
+* carries `usage` (when `stream_options.include_usage` is set),
+* `system_fingerprint`, `service_tier` (for `openai/*` models), and
+* `generationId`, then `data: [DONE]`; every chunk carries
+* `system_fingerprint` and `logprobs: null`, and events are packed
+* `eventsPerChunk` per network chunk. `stream: false` answers one
+* `chat.completion` JSON body. Reasoning models asked for reasoning
+* (`reasoning_effort`, or `thinking.type: 'enabled'`) stream
+* `delta.reasoning` with `delta.reasoning_details` before the text. A request
+* with `tools` gets one tool call whose arguments are synthesized from the
+* tool's JSON Schema and streamed in fragments, finishing with `tool_calls`.
+* Unknown models get the recorded 404 envelope (`type: 'model_not_found'`,
+* `param: { modelId }`, no `code`); a missing bearer credential gets a 401
+* envelope; unknown routes get a 404 JSON error. The ledger records the
+* `max_tokens` limit as `maxCompletionTokens`.
+*
+* Precedence per chat request: authentication and JSON validation, then the
+* first matching fault if it is a `status` fault, then the next scripted
+* turn, then model validation and defaults; a first matching chunk fault then
+* shapes the body. Only the first matching fault (in insertion order) applies. Credential headers are never
+* recorded, and the bearer value is never checked or stored.
+*
+* `POST /v1/evaluate` is fixture-only: a request with a non-empty bearer credential (never checked
+* or stored), the recorded `accept` and `content-type`, no query, and a body matching one of the
+* four classifier recordings (the discriminators `model` and `type` exact; any other string; the
+* same keys, so the recorded question ids, option keys, and level count) gets the recorded
+* response; anything else (another model, `providerOptions`, other questions) answers 400
+* not-emulated. Its ledger, faults (statuses 400-599), scripted errors, and coverage are
+* `emulator.evaluate` (control plane `/_emulate/evaluate/*`); `emulator.faults` and the other
+* top-level APIs stay the chat route's. `reset()` and `POST /_emulate/reset` reset both.
+*/
+const makeGatewayEmulator = (options = {}) => {
+	const chat = makeChatCompletionsEmulator({
+		path: gatewayChatCompletionsPath,
+		routes: gatewayEmulatorRoutes,
+		knownModels: options.knownModels ?? gatewayEmulatorDefaultModels,
+		reasoningModels: options.reasoningModels ?? gatewayEmulatorDefaultReasoningModels,
+		errorEnvelope: gatewayErrorEnvelope,
+		unknownModel: {
+			status: 404,
+			body: (model) => ({ error: {
+				message: `Model '${model ?? ""}' not found`,
+				type: "model_not_found",
+				param: { modelId: model ?? null }
+			} })
+		},
+		auth: { unauthorized: {
+			message: "Synthetic: missing or invalid authorization.",
+			type: "authentication_error",
+			code: "unauthorized"
+		} },
+		completionTokenField: "max_tokens",
+		responseIdPrefix: "gen-synthetic",
+		defaultText: [
+			"Hello",
+			" from the",
+			" synthetic gateway."
+		],
+		turnSchema: GatewayScriptedTurn,
+		inputInvalid: (input, reason) => new GatewayEmulatorInputInvalid({
+			input,
+			reason
+		}),
+		wire: gatewayWireProfile(validEventsPerChunk(options.eventsPerChunk))
+	});
+	const evaluate = makeFixtureRouteEmulator({
+		method: "POST",
+		path: gatewayEvaluatePath,
+		routes: gatewayEvaluateEmulatorRoutes,
+		recordings: gatewayEvaluateRecordings,
+		credential: "bearer",
+		headers: [],
+		inputInvalid: (input, reason) => new GatewayEmulatorInputInvalid({
+			input,
+			reason
+		})
+	});
+	return {
+		...chat,
+		fetch: composeFetch({
+			routes: [{
+				name: "evaluate",
+				paths: [gatewayEvaluatePath],
+				part: evaluate
+			}],
+			fallback: chat,
+			control: (request) => chat.fetch(request)
+		}),
+		reset: () => {
+			chat.reset();
+			evaluate.reset();
+		},
+		evaluate
+	};
+};
+//#endregion
+export { GatewayEmulatorInputInvalid, GatewayEvaluateFault, GatewayFault, GatewayFaultMatch, GatewayScriptedCompletion, GatewayScriptedError, GatewayScriptedToolCall, GatewayScriptedTurn, GatewayScriptedUsage, emulatorEvidenceHeader, gatewayChatCompletionsPath, gatewayEmulatorDefaultEventsPerChunk, gatewayEmulatorDefaultModels, gatewayEmulatorDefaultReasoningModels, gatewayEmulatorRoutes, gatewayEvaluateEmulatorRoutes, gatewayEvaluatePath, makeGatewayEmulator };
+
+//# sourceMappingURL=gateway.mjs.map

package/dist/gateway.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.mjs","names":[],"sources":["../src/gateway.ts"],"sourcesContent":["/**\n * Vercel AI Gateway emulator: a plain fetch handler for the OpenAI-compatible\n * `POST /v1/chat/completions` endpoint, with scripted turns, wire faults, a\n * request ledger, and an `/_emulate/*` control plane.\n *\n * It never imports SDK code: its wire shapes follow the verified live Gateway\n * conformance recordings (2026-09-30), copied as data: `chat.completion.chunk`\n * SSE with several events per network chunk, `delta.reasoning` plus\n * `reasoning_details` for DeepSeek reasoning, a finish event carrying\n * `provider_metadata`, `usage`, `system_fingerprint`, `service_tier`, and\n * `generationId`, then `data: [DONE]`, and the 404 `model_not_found`\n * envelope `{ error: { message, type, param: { modelId } } }` for unknown\n * models. Ids, costs, and routing metadata are synthetic stand-ins. The route\n * is linked to those conformance case ids in `gatewayEmulatorRoutes`\n * (`verified`). The Chat Completions machinery is shared with the OpenAI\n * emulator (`chat-completions.ts`); this module supplies the Gateway's paths,\n * models, envelope, reasoning, and wire profile.\n *\n * Not covered by a recording (synthetic): the 401 error, default fault\n * bodies, the non-streamed `chat.completion` body, and the answer to a request\n * without a `model` (404 `Model '' not found` with `param.modelId: null`).\n *\n * The same fetch handler also answers the classifier route `POST /v1/evaluate`\n * (AI Gateway calls classification \"evaluation\"; `emulator.evaluate`) with its\n * own manifest (`gatewayEvaluateEmulatorRoutes`, unverified), ledger, faults,\n * and turns. It is fixture-only: a request matching one of the four synthetic\n * classifier conformance recordings (boolean, choice, score, unknown-model\n * error envelope; `gateway-evaluate-recordings.ts`, copied as data) within the\n * shared request-shape latitude gets that recording's response; anything else\n * answers 400 not-emulated.\n *\n * Runtime-portable Web APIs only (`Request`, `Response`, `ReadableStream`,\n * `TextEncoder`, `URL`); no Effect runtime is required to use it.\n *\n * @experimental\n */\nimport { Data } from 'effect'\nimport type * as Schema from 'effect/Schema'\nimport {\n  ChatFault,\n  ChatFaultMatch,\n  ChatScriptedReasoningCompletion,\n  ChatScriptedError,\n  ChatScriptedToolCall,\n  ChatScriptedReasoningTurn,\n  ChatScriptedUsage,\n  makeChatCompletionsEmulator,\n  type ChatCompletionsEmulator,\n  type ChatCoverage,\n  type ChatFaultKind,\n  type ChatFaultState,\n  type ChatLedgerEntry,\n  type ChatResponseIdentity,\n  type ChatRouteCoverage,\n  type ChatUsageCounts,\n  type ChatWireError,\n  type ChatWireProfile\n} from './chat-completions.ts'\nimport { composeFetch } from './emulator-compose.ts'\nimport {\n  FixtureRouteFault,\n  makeFixtureRouteEmulator,\n  type FixtureRouteEmulator,\n  type FixtureRouteFaultKind,\n  type FixtureRouteLedgerEntry,\n  type FixtureRouteScriptedTurn\n} from './fixture-route.ts'\nimport { gatewayEvaluateRecordings } from './gateway-evaluate-recordings.ts'\nimport type { EmulatorRouteEvidence } from './route-evidence.ts'\n\nexport type { EmulatorEvidence, EmulatorRouteEvidence } from './route-evidence.ts'\n\nexport { emulatorEvidenceHeader } from './route-evidence.ts'\n\nexport const gatewayChatCompletionsPath = '/v1/chat/completions'\n\n/** The AI Gateway classifier (\"evaluation\") path. */\nexport const gatewayEvaluatePath = '/v1/evaluate'\n\n/** Synthetic-safe default model ids, including the Gateway conformance defaults. */\nexport const gatewayEmulatorDefaultModels: ReadonlyArray<string> = [\n  'openai/gpt-4.1-nano',\n  'openai/gpt-4.1-mini',\n  'deepseek/deepseek-v3.2',\n  'deepseek/deepseek-v4.1-flash'\n]\n\n/** Models that stream reasoning deltas when reasoning is requested. */\nexport const gatewayEmulatorDefaultReasoningModels: ReadonlyArray<string> = [\n  'deepseek/deepseek-v3.2',\n  'deepseek/deepseek-v4.1-flash'\n]\n\n/**\n * SSE events per network chunk by default. The live Gateway packs several\n * events into one network chunk (the recordings carry one to four, always\n * with the finish event and `data: [DONE]` together in the last chunk).\n */\nexport const gatewayEmulatorDefaultEventsPerChunk = 2\n\n/**\n * Route evidence manifest: every emulated Gateway route and the conformance\n * cases whose verified live recordings (2026-09-30) its wire shapes follow.\n */\nexport const gatewayEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> = [\n  {\n    method: 'POST',\n    path: gatewayChatCompletionsPath,\n    kind: 'provider',\n    write: false,\n    caseIds: [\n      'vercel-ai-gateway.stream.plain-text',\n      'vercel-ai-gateway.stream.deepseek-reasoning',\n      'vercel-ai-gateway.stream.tool-call-deltas',\n      'vercel-ai-gateway.stream.error-envelope'\n    ],\n    evidence: 'verified',\n    observedAt: '2026-09-30'\n  }\n]\n\n/**\n * Route evidence manifest of the classifier route (served by the same fetch handler, with its own\n * ledger, faults, and coverage). Its recordings are synthetic placeholders, so it is unverified.\n */\nexport const gatewayEvaluateEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> = [\n  {\n    method: 'POST',\n    path: gatewayEvaluatePath,\n    kind: 'provider',\n    write: false,\n    caseIds: [\n      'vercel-ai-gateway.classify.boolean',\n      'vercel-ai-gateway.classify.choice',\n      'vercel-ai-gateway.classify.score',\n      'vercel-ai-gateway.classify.error-envelope'\n    ],\n    evidence: 'unverified',\n    observedAt: undefined\n  }\n]\n\n/** Optional fault filter; an omitted field matches every request. `path` ending in `*` is a prefix. */\nexport const GatewayFaultMatch = ChatFaultMatch\n\nexport type GatewayFaultMatch = ChatFaultMatch\n\n/**\n * Wire faults for emulated routes:\n *\n * - `status`: answer with this status, headers, and body instead of a\n *   completion (for example 429 with `retry-after`). The body defaults to a\n *   Gateway error envelope. Statuses that cannot carry a body (1xx, 204, 205,\n *   304) and redirects (3xx) are rejected, as are invalid header names or\n *   values and a `location` header; scripted errors follow the same rules.\n * - `error-after-chunks`: send `chunks` body chunks, then error the body\n *   stream (a dropped connection).\n * - `truncate-after-chunks`: send `chunks` body chunks, then close the body\n *   cleanly (for example without `data: [DONE]`).\n *\n * Chunk faults count network chunks: a streamed chunk carries up to\n * `eventsPerChunk` SSE events (default 2), and a whole JSON body counts as one\n * chunk. A chunk fault that cannot take effect (`error-after-chunks` beyond\n * the chunk count, or `truncate-after-chunks` at or beyond it) answers 500\n * with an emulator error instead of silently doing nothing, and is not\n * consumed.\n */\nexport const GatewayFault = ChatFault\n\nexport type GatewayFault = ChatFault\n\nexport type GatewayFaultKind = ChatFaultKind\n\n/**\n * Usage for a scripted turn, sent as the Gateway `usage` object (token counts,\n * `completion_tokens_details.reasoning_tokens` defaulting to 0, and synthetic\n * zero costs).\n */\nexport const GatewayScriptedUsage = ChatScriptedUsage\n\nexport type GatewayScriptedUsage = ChatScriptedUsage\n\n/** One scripted tool call; its JSON arguments stream as these fragments. */\nexport const GatewayScriptedToolCall = ChatScriptedToolCall\n\nexport type GatewayScriptedToolCall = ChatScriptedToolCall\n\n/**\n * A scripted completion. Every field is exact (nothing is filled in) except:\n * `usage` omitted is synthesized when the request asks for usage, and `null`\n * drops it; `finishReason` omitted is `tool_calls` with tool calls, else\n * `stop`. `order` defaults to `reasoning-first`; `reasoningField` defaults to\n * `reasoning` (streamed with `reasoning_details`, as recorded live); the\n * DeepSeek-native `reasoning_content` is sent alone.\n */\nexport const GatewayScriptedCompletion = ChatScriptedReasoningCompletion\n\nexport type GatewayScriptedCompletion = ChatScriptedReasoningCompletion\n\n/** A scripted error response: status, body (a string is sent as is), and optional headers. */\nexport const GatewayScriptedError = ChatScriptedError\n\nexport type GatewayScriptedError = ChatScriptedError\n\n/** A turn queued for the next chat completion request. */\nexport const GatewayScriptedTurn = ChatScriptedReasoningTurn\n\nexport type GatewayScriptedTurn = ChatScriptedReasoningTurn\n\n/**\n * Thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input, and\n * by `makeGatewayEmulator` for invalid options; a programmer error.\n */\nexport class GatewayEmulatorInputInvalid extends Data.TaggedError('GatewayEmulatorInputInvalid')<{\n  readonly input: 'fault' | 'turn' | 'options'\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid Gateway emulator ${this.input}: ${this.reason}`\n  }\n}\n\nexport type GatewayLedgerEntry = ChatLedgerEntry\n\nexport type GatewayFaultState = ChatFaultState\n\nexport type GatewayRouteCoverage = ChatRouteCoverage\n\nexport type GatewayCoverage = ChatCoverage\n\nexport type GatewayEmulatorOptions = {\n  /** Model ids that exist. Defaults to `gatewayEmulatorDefaultModels`. */\n  readonly knownModels?: ReadonlyArray<string>\n  /** Model ids that stream reasoning. Defaults to `gatewayEmulatorDefaultReasoningModels`. */\n  readonly reasoningModels?: ReadonlyArray<string>\n  /**\n   * SSE events per network chunk of a streamed body, a positive integer.\n   * Defaults to `gatewayEmulatorDefaultEventsPerChunk` (2); 1 sends one event\n   * per chunk. Events are packed counting from the end, so the last chunk\n   * holds the finish event and `data: [DONE]` together. Chunk faults count\n   * these network chunks.\n   */\n  readonly eventsPerChunk?: number\n}\n\n/** A classifier-route fault (`status` 400-599, `error-after-chunks`, `truncate-after-chunks`). */\nexport const GatewayEvaluateFault = FixtureRouteFault\n\nexport type GatewayEvaluateFault = FixtureRouteFault\n\nexport type GatewayEvaluateFaultKind = FixtureRouteFaultKind\n\n/** A classifier-route turn: a scripted error (status 400-599) only. */\nexport type GatewayEvaluateScriptedTurn = FixtureRouteScriptedTurn\n\nexport type GatewayEvaluateLedgerEntry = FixtureRouteLedgerEntry\n\nexport type GatewayEvaluateEmulator = FixtureRouteEmulator\n\n/** The chat emulator, plus `evaluate`: the classifier route's own emulator API. */\nexport type GatewayEmulator = ChatCompletionsEmulator<GatewayScriptedTurn> & {\n  readonly evaluate: GatewayEvaluateEmulator\n}\n\nconst gatewayErrorEnvelope = (error: ChatWireError): Schema.Json => ({\n  error: { message: error.message, type: error.type, code: error.code }\n})\n\n// Synthetic stand-ins for the metadata the live Gateway attaches to its chunks. Keys and value\n// types follow the recordings; every value is synthetic (no recorded id, fingerprint, or cost).\nconst syntheticFingerprint = 'fp_synthetic'\n\nconst syntheticAttemptTime = 1790000000000\n\nconst syntheticCost = '0'\n\nconst vendorOf = (model: string): string | undefined => {\n  const [vendor] = model.split('/')\n\n  return vendor === undefined || vendor.length === 0 || vendor === model ? undefined : vendor\n}\n\n// `service_tier` was recorded only for OpenAI models.\nconst isOpenAiModel = (model: string): boolean => vendorOf(model) === 'openai'\n\nconst syntheticResponseId = (identity: ChatResponseIdentity): string =>\n  `resp_synthetic_${identity.id}`\n\ntype GatewayUpstream = { readonly provider: string; readonly entry?: Schema.JsonObject }\n\n/**\n * The upstream provider the Gateway routes a model to, and its `provider_metadata` entry (keyed by\n * that provider), per model family as recorded: `openai/*` routes to `openai` with\n * `{ responseId, serviceTier }`; `deepseek/*` routes to `baseten` with\n * `{ acceptedPredictionTokens, rejectedPredictionTokens }` (synthetic zero counts). Other families\n * were not recorded: they route to their vendor prefix without an upstream entry.\n */\nconst upstreamOf = (identity: ChatResponseIdentity): GatewayUpstream => {\n  const vendor = vendorOf(identity.model)\n\n  if (vendor === 'openai') {\n    return {\n      provider: 'openai',\n      entry: { responseId: syntheticResponseId(identity), serviceTier: 'default' }\n    }\n  }\n\n  if (vendor === 'deepseek') {\n    return {\n      provider: 'baseten',\n      entry: { acceptedPredictionTokens: 0, rejectedPredictionTokens: 0 }\n    }\n  }\n\n  return { provider: vendor ?? 'synthetic' }\n}\n\n/** The `gateway` entry of `provider_metadata`: routing, costs, and the generation id. */\nconst gatewayRoutingMetadata = (identity: ChatResponseIdentity): Schema.JsonObject => {\n  const { provider } = upstreamOf(identity)\n  const responseId = syntheticResponseId(identity)\n\n  return {\n    routing: {\n      originalModelId: identity.model,\n      resolvedProvider: provider,\n      fallbacksAvailable: ['synthetic-fallback'],\n      planningReasoning: 'Synthetic: routing planned by the emulator.',\n      canonicalSlug: identity.model,\n      finalProvider: provider,\n      modelAttemptCount: 1,\n      modelAttempts: [\n        {\n          canonicalSlug: identity.model,\n          success: true,\n          providerAttemptCount: 1,\n          providerAttempts: [\n            {\n              provider,\n              credentialType: 'system',\n              success: true,\n              startTime: syntheticAttemptTime,\n              endTime: syntheticAttemptTime + 1,\n              providerRequestId: `req_synthetic_${identity.id}`,\n              statusCode: 200,\n              providerResponseId: responseId\n            }\n          ]\n        }\n      ],\n      totalProviderAttemptCount: 1,\n      affinity: { outcome: 'skipped_below_min_prefix' },\n      clientSessionId: 'synthetic-client-session',\n      clientSessionIdSource: 'fingerprint'\n    },\n    cost: syntheticCost,\n    marketCost: syntheticCost,\n    surchargeCost: syntheticCost,\n    gatewayCost: syntheticCost,\n    inferenceCost: syntheticCost,\n    inputInferenceCost: syntheticCost,\n    outputInferenceCost: syntheticCost,\n    generationId: identity.id\n  }\n}\n\n/** `provider_metadata`: the upstream provider's entry first (when its family has one), then `gateway`. */\nconst gatewayProviderMetadata = (identity: ChatResponseIdentity): Schema.JsonObject => {\n  const metadata: Record<string, Schema.Json> = {}\n  const upstream = upstreamOf(identity)\n\n  if (upstream.entry !== undefined) {\n    metadata[upstream.provider] = upstream.entry\n  }\n\n  metadata.gateway = gatewayRoutingMetadata(identity)\n\n  return metadata\n}\n\nconst gatewayUsage = (counts: ChatUsageCounts): Schema.JsonObject => ({\n  prompt_tokens: counts.promptTokens,\n  completion_tokens: counts.completionTokens,\n  total_tokens: counts.promptTokens + counts.completionTokens,\n  cost: 0,\n  is_byok: false,\n  prompt_tokens_details: { cached_tokens: 0, audio_tokens: 0, video_tokens: 0 },\n  cost_details: {\n    upstream_inference_cost: null,\n    upstream_inference_prompt_cost: 0,\n    upstream_inference_completions_cost: 0\n  },\n  completion_tokens_details: { reasoning_tokens: counts.reasoningTokens ?? 0, image_tokens: 0 },\n  cache_creation_input_tokens: 0,\n  market_cost: 0,\n  gateway_cost: 0\n})\n\nconst gatewayWireProfile = (eventsPerChunk: number): ChatWireProfile => ({\n  eventsPerChunk,\n  streamUsage: 'finish-event',\n  openingDelta: { role: 'assistant' },\n  choiceFields: { logprobs: null },\n  reasoningField: 'reasoning',\n  reasoningDetails: true,\n  chunkFields: () => ({ system_fingerprint: syntheticFingerprint }),\n  finishFields: identity => {\n    const chunk: Record<string, Schema.Json> = {}\n\n    if (isOpenAiModel(identity.model)) {\n      chunk.service_tier = 'default'\n    }\n\n    chunk.generationId = identity.id\n\n    return { delta: { provider_metadata: gatewayProviderMetadata(identity) }, chunk }\n  },\n  usage: gatewayUsage\n})\n\nconst validEventsPerChunk = (eventsPerChunk: number | undefined): number => {\n  const value = eventsPerChunk ?? gatewayEmulatorDefaultEventsPerChunk\n\n  if (!Number.isSafeInteger(value) || value < 1) {\n    throw new GatewayEmulatorInputInvalid({\n      input: 'options',\n      reason: `eventsPerChunk must be a positive integer, got ${String(eventsPerChunk)}`\n    })\n  }\n\n  return value\n}\n\n/**\n * Create a Vercel AI Gateway emulator. Each call has independent ledger,\n * fault, and script state. Throws `GatewayEmulatorInputInvalid` for an\n * invalid `eventsPerChunk`.\n *\n * Without a script, `POST /v1/chat/completions` answers a known model with\n * synthetic text deltas. `stream: true` sends `chat.completion.chunk` SSE in\n * the recorded Gateway shape: a `{ role: 'assistant' }` opening delta, content\n * deltas, and a finish event whose delta carries `provider_metadata` and which\n * carries `usage` (when `stream_options.include_usage` is set),\n * `system_fingerprint`, `service_tier` (for `openai/*` models), and\n * `generationId`, then `data: [DONE]`; every chunk carries\n * `system_fingerprint` and `logprobs: null`, and events are packed\n * `eventsPerChunk` per network chunk. `stream: false` answers one\n * `chat.completion` JSON body. Reasoning models asked for reasoning\n * (`reasoning_effort`, or `thinking.type: 'enabled'`) stream\n * `delta.reasoning` with `delta.reasoning_details` before the text. A request\n * with `tools` gets one tool call whose arguments are synthesized from the\n * tool's JSON Schema and streamed in fragments, finishing with `tool_calls`.\n * Unknown models get the recorded 404 envelope (`type: 'model_not_found'`,\n * `param: { modelId }`, no `code`); a missing bearer credential gets a 401\n * envelope; unknown routes get a 404 JSON error. The ledger records the\n * `max_tokens` limit as `maxCompletionTokens`.\n *\n * Precedence per chat request: authentication and JSON validation, then the\n * first matching fault if it is a `status` fault, then the next scripted\n * turn, then model validation and defaults; a first matching chunk fault then\n * shapes the body. Only the first matching fault (in insertion order) applies. Credential headers are never\n * recorded, and the bearer value is never checked or stored.\n *\n * `POST /v1/evaluate` is fixture-only: a request with a non-empty bearer credential (never checked\n * or stored), the recorded `accept` and `content-type`, no query, and a body matching one of the\n * four classifier recordings (the discriminators `model` and `type` exact; any other string; the\n * same keys, so the recorded question ids, option keys, and level count) gets the recorded\n * response; anything else (another model, `providerOptions`, other questions) answers 400\n * not-emulated. Its ledger, faults (statuses 400-599), scripted errors, and coverage are\n * `emulator.evaluate` (control plane `/_emulate/evaluate/*`); `emulator.faults` and the other\n * top-level APIs stay the chat route's. `reset()` and `POST /_emulate/reset` reset both.\n */\nexport const makeGatewayEmulator = (options: GatewayEmulatorOptions = {}): GatewayEmulator => {\n  const chat = makeChatCompletionsEmulator({\n    path: gatewayChatCompletionsPath,\n    routes: gatewayEmulatorRoutes,\n    knownModels: options.knownModels ?? gatewayEmulatorDefaultModels,\n    reasoningModels: options.reasoningModels ?? gatewayEmulatorDefaultReasoningModels,\n    errorEnvelope: gatewayErrorEnvelope,\n    // Copied data shape of the verified Gateway error-envelope recording (unknown model id): its\n    // own envelope, with `param.modelId` and no `code`.\n    unknownModel: {\n      status: 404,\n      body: model => ({\n        error: {\n          message: `Model '${model ?? ''}' not found`,\n          type: 'model_not_found',\n          param: { modelId: model ?? null }\n        }\n      })\n    },\n    auth: {\n      unauthorized: {\n        message: 'Synthetic: missing or invalid authorization.',\n        type: 'authentication_error',\n        code: 'unauthorized'\n      }\n    },\n    completionTokenField: 'max_tokens',\n    responseIdPrefix: 'gen-synthetic',\n    defaultText: ['Hello', ' from the', ' synthetic gateway.'],\n    turnSchema: GatewayScriptedTurn,\n    inputInvalid: (input, reason) => new GatewayEmulatorInputInvalid({ input, reason }),\n    wire: gatewayWireProfile(validEventsPerChunk(options.eventsPerChunk))\n  })\n\n  const evaluate = makeFixtureRouteEmulator({\n    method: 'POST',\n    path: gatewayEvaluatePath,\n    routes: gatewayEvaluateEmulatorRoutes,\n    recordings: gatewayEvaluateRecordings,\n    credential: 'bearer',\n    headers: [],\n    inputInvalid: (input, reason) => new GatewayEmulatorInputInvalid({ input, reason })\n  })\n\n  return {\n    ...chat,\n    fetch: composeFetch({\n      routes: [{ name: 'evaluate', paths: [gatewayEvaluatePath], part: evaluate }],\n      fallback: chat,\n      control: request => chat.fetch(request)\n    }),\n    reset: () => {\n      chat.reset()\n      evaluate.reset()\n    },\n    evaluate\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,MAAa,6BAA6B;;AAG1C,MAAa,sBAAsB;;AAGnC,MAAa,+BAAsD;CACjE;CACA;CACA;CACA;AACF;;AAGA,MAAa,wCAA+D,CAC1E,0BACA,8BACF;;;;;;AAOA,MAAa,uCAAuC;;;;;AAMpD,MAAa,wBAA8D,CACzE;CACE,QAAQ;CACR,MAAM;CACN,MAAM;CACN,OAAO;CACP,SAAS;EACP;EACA;EACA;EACA;CACF;CACA,UAAU;CACV,YAAY;AACd,CACF;;;;;AAMA,MAAa,gCAAsE,CACjF;CACE,QAAQ;CACR,MAAM;CACN,MAAM;CACN,OAAO;CACP,SAAS;EACP;EACA;EACA;EACA;CACF;CACA,UAAU;CACV,YAAY,KAAA;AACd,CACF;;AAGA,MAAa,oBAAoB;;;;;;;;;;;;;;;;;;;;;AAwBjC,MAAa,eAAe;;;;;;AAW5B,MAAa,uBAAuB;;AAKpC,MAAa,0BAA0B;;;;;;;;;AAYvC,MAAa,4BAA4B;;AAKzC,MAAa,uBAAuB;;AAKpC,MAAa,sBAAsB;;;;;AAQnC,IAAa,8BAAb,cAAiD,KAAK,YAAY,6BAA6B,EAG5F;CACD,IAAa,UAAkB;EAC7B,OAAO,4BAA4B,KAAK,MAAM,IAAI,KAAK;CACzD;AACF;;AA0BA,MAAa,uBAAuB;AAkBpC,MAAM,wBAAwB,WAAuC,EACnE,OAAO;CAAE,SAAS,MAAM;CAAS,MAAM,MAAM;CAAM,MAAM,MAAM;AAAK,EACtE;AAIA,MAAM,uBAAuB;AAE7B,MAAM,uBAAuB;AAE7B,MAAM,gBAAgB;AAEtB,MAAM,YAAY,UAAsC;CACtD,MAAM,CAAC,UAAU,MAAM,MAAM,GAAG;CAEhC,OAAO,WAAW,KAAA,KAAa,OAAO,WAAW,KAAK,WAAW,QAAQ,KAAA,IAAY;AACvF;AAGA,MAAM,iBAAiB,UAA2B,SAAS,KAAK,MAAM;AAEtE,MAAM,uBAAuB,aAC3B,kBAAkB,SAAS;;;;;;;;AAW7B,MAAM,cAAc,aAAoD;CACtE,MAAM,SAAS,SAAS,SAAS,KAAK;CAEtC,IAAI,WAAW,UACb,OAAO;EACL,UAAU;EACV,OAAO;GAAE,YAAY,oBAAoB,QAAQ;GAAG,aAAa;EAAU;CAC7E;CAGF,IAAI,WAAW,YACb,OAAO;EACL,UAAU;EACV,OAAO;GAAE,0BAA0B;GAAG,0BAA0B;EAAE;CACpE;CAGF,OAAO,EAAE,UAAU,UAAU,YAAY;AAC3C;;AAGA,MAAM,0BAA0B,aAAsD;CACpF,MAAM,EAAE,aAAa,WAAW,QAAQ;CACxC,MAAM,aAAa,oBAAoB,QAAQ;CAE/C,OAAO;EACL,SAAS;GACP,iBAAiB,SAAS;GAC1B,kBAAkB;GAClB,oBAAoB,CAAC,oBAAoB;GACzC,mBAAmB;GACnB,eAAe,SAAS;GACxB,eAAe;GACf,mBAAmB;GACnB,eAAe,CACb;IACE,eAAe,SAAS;IACxB,SAAS;IACT,sBAAsB;IACtB,kBAAkB,CAChB;KACE;KACA,gBAAgB;KAChB,SAAS;KACT,WAAW;KACX,SAAS,uBAAuB;KAChC,mBAAmB,iBAAiB,SAAS;KAC7C,YAAY;KACZ,oBAAoB;IACtB,CACF;GACF,CACF;GACA,2BAA2B;GAC3B,UAAU,EAAE,SAAS,2BAA2B;GAChD,iBAAiB;GACjB,uBAAuB;EACzB;EACA,MAAM;EACN,YAAY;EACZ,eAAe;EACf,aAAa;EACb,eAAe;EACf,oBAAoB;EACpB,qBAAqB;EACrB,cAAc,SAAS;CACzB;AACF;;AAGA,MAAM,2BAA2B,aAAsD;CACrF,MAAM,WAAwC,CAAC;CAC/C,MAAM,WAAW,WAAW,QAAQ;CAEpC,IAAI,SAAS,UAAU,KAAA,GACrB,SAAS,SAAS,YAAY,SAAS;CAGzC,SAAS,UAAU,uBAAuB,QAAQ;CAElD,OAAO;AACT;AAEA,MAAM,gBAAgB,YAAgD;CACpE,eAAe,OAAO;CACtB,mBAAmB,OAAO;CAC1B,cAAc,OAAO,eAAe,OAAO;CAC3C,MAAM;CACN,SAAS;CACT,uBAAuB;EAAE,eAAe;EAAG,cAAc;EAAG,cAAc;CAAE;CAC5E,cAAc;EACZ,yBAAyB;EACzB,gCAAgC;EAChC,qCAAqC;CACvC;CACA,2BAA2B;EAAE,kBAAkB,OAAO,mBAAmB;EAAG,cAAc;CAAE;CAC5F,6BAA6B;CAC7B,aAAa;CACb,cAAc;AAChB;AAEA,MAAM,sBAAsB,oBAA6C;CACvE;CACA,aAAa;CACb,cAAc,EAAE,MAAM,YAAY;CAClC,cAAc,EAAE,UAAU,KAAK;CAC/B,gBAAgB;CAChB,kBAAkB;CAClB,oBAAoB,EAAE,oBAAoB,qBAAqB;CAC/D,eAAc,aAAY;EACxB,MAAM,QAAqC,CAAC;EAE5C,IAAI,cAAc,SAAS,KAAK,GAC9B,MAAM,eAAe;EAGvB,MAAM,eAAe,SAAS;EAE9B,OAAO;GAAE,OAAO,EAAE,mBAAmB,wBAAwB,QAAQ,EAAE;GAAG;EAAM;CAClF;CACA,OAAO;AACT;AAEA,MAAM,uBAAuB,mBAA+C;CAC1E,MAAM,QAAQ,kBAAA;CAEd,IAAI,CAAC,OAAO,cAAc,KAAK,KAAK,QAAQ,GAC1C,MAAM,IAAI,4BAA4B;EACpC,OAAO;EACP,QAAQ,kDAAkD,OAAO,cAAc;CACjF,CAAC;CAGH,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,MAAa,uBAAuB,UAAkC,CAAC,MAAuB;CAC5F,MAAM,OAAO,4BAA4B;EACvC,MAAM;EACN,QAAQ;EACR,aAAa,QAAQ,eAAe;EACpC,iBAAiB,QAAQ,mBAAmB;EAC5C,eAAe;EAGf,cAAc;GACZ,QAAQ;GACR,OAAM,WAAU,EACd,OAAO;IACL,SAAS,UAAU,SAAS,GAAG;IAC/B,MAAM;IACN,OAAO,EAAE,SAAS,SAAS,KAAK;GAClC,EACF;EACF;EACA,MAAM,EACJ,cAAc;GACZ,SAAS;GACT,MAAM;GACN,MAAM;EACR,EACF;EACA,sBAAsB;EACtB,kBAAkB;EAClB,aAAa;GAAC;GAAS;GAAa;EAAqB;EACzD,YAAY;EACZ,eAAe,OAAO,WAAW,IAAI,4BAA4B;GAAE;GAAO;EAAO,CAAC;EAClF,MAAM,mBAAmB,oBAAoB,QAAQ,cAAc,CAAC;CACtE,CAAC;CAED,MAAM,WAAW,yBAAyB;EACxC,QAAQ;EACR,MAAM;EACN,QAAQ;EACR,YAAY;EACZ,YAAY;EACZ,SAAS,CAAC;EACV,eAAe,OAAO,WAAW,IAAI,4BAA4B;GAAE;GAAO;EAAO,CAAC;CACpF,CAAC;CAED,OAAO;EACL,GAAG;EACH,OAAO,aAAa;GAClB,QAAQ,CAAC;IAAE,MAAM;IAAY,OAAO,CAAC,mBAAmB;IAAG,MAAM;GAAS,CAAC;GAC3E,UAAU;GACV,UAAS,YAAW,KAAK,MAAM,OAAO;EACxC,CAAC;EACD,aAAa;GACX,KAAK,MAAM;GACX,SAAS,MAAM;EACjB;EACA;CACF;AACF"}

package/dist/github/api.d.mts

@@ -0,0 +1,63 @@
+import { StatefulRoute } from "../stateful-emulator.mjs";
+import { GithubEmulatorState } from "./state.mjs";
+
+//#region src/github/api.d.ts
+/** The origin every GitHub fixture records; another origin is not emulated. */
+declare const githubEmulatorOrigin = "https://api.github.com";
+/** The only `X-GitHub-Api-Version` the emulator answers (every fixture sends it). */
+declare const githubEmulatorApiVersion = "2026-03-10";
+/** The only `Accept` the emulator answers (every fixture sends it). */
+declare const githubEmulatorAccept = "application/vnd.github+json";
+/** Drill knobs (tests only): each makes the emulator disagree with one conformance claim. */
+type GithubEmulatorDrills = {
+  /** The first label page's `Link` lists no `rel="next"` while labels remain. */readonly linkOmitsNext?: boolean; /** The not-found body of an unreached issue number lacks `documentation_url`. */
+  readonly notFoundOmitsDocumentationUrl?: boolean; /** The overlong search's validation body carries an empty `errors` array. */
+  readonly validationWithoutErrors?: boolean; /** File contents answer base64 on one line (not folded). */
+  readonly contentUnfolded?: boolean; /** A comment listing `since` excludes a comment updated at exactly that instant. */
+  readonly sinceExcludesEqual?: boolean; /** The label add answers the issue labels without the added label. */
+  readonly addAnswerOmitsLabel?: boolean; /** Closing an issue answers `closed_at: null`. */
+  readonly closeWithoutClosedAt?: boolean;
+};
+declare const githubEmulatorDrillKnobs: ReadonlyArray<keyof GithubEmulatorDrills>;
+type GithubApiEnv = {
+  /** Clock in epoch milliseconds (created issue and comment timestamps, close times). */readonly now: () => number;
+  readonly drills: Readonly<Record<keyof GithubEmulatorDrills, boolean>>;
+};
+/**
+ * The fixtures' error bodies, byte for byte (`JSON.stringify` keeps this key order): the issue
+ * and comment 404s, the label-not-on-issue 404, and the overlong search's 422.
+ */
+declare const githubEmulatorErrorBodies: {
+  readonly issueNotFound: {
+    readonly message: "Not Found";
+    readonly documentation_url: "https://docs.github.com/rest/issues/issues#get-an-issue";
+    readonly status: "404";
+  };
+  readonly commentNotFound: {
+    readonly message: "Not Found";
+    readonly documentation_url: "https://docs.github.com/rest/issues/comments#delete-an-issue-comment";
+    readonly status: "404";
+  };
+  readonly labelNotOnIssue: {
+    readonly message: "Label does not exist";
+    readonly documentation_url: "https://docs.github.com/rest/issues/labels#remove-a-label-from-an-issue";
+    readonly status: "404";
+  };
+  readonly searchTooLong: {
+    readonly message: "Validation Failed";
+    readonly errors: readonly [{
+      readonly message: "The search is longer than 256 characters.";
+      readonly resource: "Search";
+      readonly field: "q";
+      readonly code: "invalid";
+    }];
+    readonly documentation_url: "https://docs.github.com/v3/search/";
+    readonly status: "422";
+  };
+};
+type Route = StatefulRoute<GithubEmulatorState, GithubApiEnv>;
+/** The route table: evidence plus handlers. `githubEmulatorRoutes` is its evidence part. */
+declare const githubApiRoutes: ReadonlyArray<Route>;
+//#endregion
+export { GithubApiEnv, GithubEmulatorDrills, githubApiRoutes, githubEmulatorAccept, githubEmulatorApiVersion, githubEmulatorDrillKnobs, githubEmulatorErrorBodies, githubEmulatorOrigin };
+//# sourceMappingURL=api.d.mts.map

package/dist/github/api.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.mts","names":[],"sources":["../../src/github/api.ts"],"mappings":";;;;;cAgDa,oBAAA;AAAb;AAAA,cAGa,wBAAA;;cAGA,oBAAA;AANoB;AAAA,KAerB,oBAAA;EAZyB,wFAc1B,aAAA,YAd0B;EAAA,SAgB1B,6BAAA,YAbE;EAAA,SAeF,uBAAA;WAEA,eAAA,YAjBsB;EAAA,SAmBtB,kBAAA,YAVqB;EAAA,SAYrB,mBAAA,YAZqB;EAAA,SAcrB,oBAAA;AAAA;AAAA,cAGE,wBAAA,EAA0B,aAAa,OAAO,oBAAA;AAAA,KAU/C,YAAA;EAjBD,gGAmBA,GAAA;EAAA,SACA,MAAA,EAAQ,QAAA,CAAS,MAAA,OAAa,oBAAA;AAAA;AAhBV;AAG/B;;;AAH+B,cAuBlB,yBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KA+BR,KAAA,GAAQ,aAAA,CAAc,mBAAA,EAAqB,YAAA;;cA00BnC,eAAA,EAAiB,aAAa,CAAC,KAAA"}