@yolk-sdk/emulators 0.1.0-canary.96

package/dist/emulator-kernel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"emulator-kernel.mjs","names":[],"sources":["../src/emulator-kernel.ts"],"sourcesContent":["/**\n * Shared emulator kernel (internal; not a package export).\n *\n * The wire-independent half of every fetch-handler emulator: fault and scripted-turn state, the\n * request ledger, pull-driven bodies with chunk faults, evidence tagging, route binding, and the\n * `/_emulate/*` control plane. Each wire core (`chat-completions.ts`, `messages.ts`) supplies its\n * route handlers, fault and turn schemas, ledger entry shape, and error bodies.\n *\n * Also holds small wire-independent helpers both cores use: JSON field access, synthetic values\n * for a tool's JSON Schema, fragment splitting, and a rough token estimate.\n *\n * Runtime-portable Web APIs only (`Request`, `Response`, `ReadableStream`, `TextEncoder`, `URL`);\n * no Node builtins and no SDK imports.\n */\nimport { Predicate, Result } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport { EmulatorHeaderRecord, EmulatorResponseStatus } from './emulator-http.ts'\nimport {\n  bindRouteHandlers,\n  emulatorEvidenceHeader,\n  type EmulatorEvidence,\n  type EmulatorRouteEvidence\n} from './route-evidence.ts'\n\nexport const ChunkCount = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))\n\nconst FaultCount = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))\n\n/** Optional fault filter; an omitted field matches every request. `path` ending in `*` is a prefix. */\nexport const EmulatorFaultMatch = Schema.Struct({\n  path: Schema.optionalKey(Schema.String),\n  model: Schema.optionalKey(Schema.String)\n})\n\nexport type EmulatorFaultMatch = typeof EmulatorFaultMatch.Type\n\n/** Fields every fault kind carries. */\nexport const emulatorFaultFields = {\n  match: Schema.optionalKey(EmulatorFaultMatch),\n  /** How many matching requests the fault answers. Omitted: every matching request. */\n  count: Schema.optionalKey(FaultCount)\n}\n\n/** Answer with this status, headers, and body instead of the planned response. */\nexport const EmulatorStatusFault = Schema.Struct({\n  kind: Schema.Literal('status'),\n  status: EmulatorResponseStatus,\n  headers: Schema.optionalKey(EmulatorHeaderRecord),\n  body: Schema.optionalKey(Schema.Json),\n  ...emulatorFaultFields\n})\n\n/** Send `chunks` body chunks, then error the body stream (a dropped connection). */\nexport const EmulatorErrorAfterChunksFault = Schema.Struct({\n  kind: Schema.Literal('error-after-chunks'),\n  chunks: ChunkCount,\n  ...emulatorFaultFields\n})\n\n/** Send `chunks` body chunks, then close the body cleanly (a truncated response). */\nexport const EmulatorTruncateAfterChunksFault = Schema.Struct({\n  kind: Schema.Literal('truncate-after-chunks'),\n  chunks: ChunkCount,\n  ...emulatorFaultFields\n})\n\n/** A scripted error response: status, body (a string is sent as is), and optional headers. */\nexport const EmulatorScriptedError = Schema.Struct({\n  error: Schema.Struct({\n    status: EmulatorResponseStatus,\n    body: Schema.Json,\n    headers: Schema.optionalKey(EmulatorHeaderRecord)\n  })\n})\n\nexport type EmulatorScriptedError = typeof EmulatorScriptedError.Type\n\n/** What the kernel needs from every fault: its kind and optional filter and count. */\nexport type KernelFault = {\n  readonly kind: string\n  readonly match?: EmulatorFaultMatch | undefined\n  readonly count?: number | undefined\n}\n\ntype BodyChunkFault =\n  | typeof EmulatorErrorAfterChunksFault.Type\n  | typeof EmulatorTruncateAfterChunksFault.Type\n\nexport type EmulatorFaultState<Fault> = {\n  readonly id: number\n  readonly fault: Fault\n  /** Remaining matching requests; `undefined` for an unlimited fault. */\n  readonly remaining: number | undefined\n  readonly applied: number\n}\n\ntype MutableFaultState<Fault> = {\n  readonly id: number\n  readonly fault: Fault\n  remaining: number | undefined\n  applied: number\n}\n\nexport type EmulatorRouteCoverage = EmulatorRouteEvidence & {\n  /** Ledger requests answered by this route since the last ledger clear or reset. */\n  readonly requests: number\n}\n\nexport type EmulatorCoverage = {\n  readonly routes: ReadonlyArray<EmulatorRouteCoverage>\n  /** Ledger requests to unknown routes (failed closed). */\n  readonly unknownRouteRequests: number\n}\n\n/** Fields an emulator lists first in `/_emulate/state`. */\nexport type EmulatorStateFields = {\n  readonly knownModels: ReadonlyArray<string>\n  /** Only for emulators that emulate streamed reasoning. */\n  readonly reasoningModels?: ReadonlyArray<string>\n}\n\n/** The ledger fields the kernel owns; each wire core extends it with its request fields. */\nexport type KernelLedgerEntry<FaultKind extends string> = {\n  seq: number\n  method: string\n  path: string\n  fault?: FaultKind\n  faultError?: string\n  responseError?: string\n  evidence: EmulatorEvidence | 'unknown-route'\n  status: number\n  bodyChunks: number\n}\n\n/** The public shape of every emulator built on the kernel. */\nexport type EmulatorApi<Turn, Fault, Entry> = {\n  /** The fetch handler (emulated API plus the `/_emulate/*` control plane). Never rejects. */\n  readonly fetch: (request: Request) => Promise<Response>\n  readonly ledger: {\n    readonly entries: () => ReadonlyArray<Entry>\n    readonly clear: () => void\n  }\n  /** Clear the ledger, faults, and scripted turns. */\n  readonly reset: () => void\n  readonly faults: {\n    /** Add a fault; throws the emulator's input-invalid error for an invalid fault. */\n    readonly add: (fault: Fault) => EmulatorFaultState<Fault>\n    readonly list: () => ReadonlyArray<EmulatorFaultState<Fault>>\n    readonly clear: () => void\n  }\n  readonly script: {\n    /** Queue a turn for the next emulated request; throws for an invalid turn. */\n    readonly enqueue: (turn: Turn) => void\n    readonly pending: () => number\n    readonly clear: () => void\n  }\n  readonly coverage: () => EmulatorCoverage\n}\n\nexport type EmulatorKernelConfig<\n  Fault extends KernelFault,\n  Turn,\n  Entry extends KernelLedgerEntry<Fault['kind']>,\n  Snapshot\n> = {\n  /** Route evidence manifest; `serve` needs exactly one handler per route. */\n  readonly routes: ReadonlyArray<EmulatorRouteEvidence>\n  /** Fault schema (decoded strictly). */\n  readonly faultSchema: Schema.Decoder<Fault>\n  /** Scripted-turn schema (decoded strictly). */\n  readonly turnSchema: Schema.Decoder<Turn>\n  /** Adds the wire core's own ledger fields to a fresh kernel entry. */\n  readonly newEntry: (base: KernelLedgerEntry<Fault['kind']>) => Entry\n  /** Copies an entry for the ledger API (never shares mutable state). */\n  readonly snapshotEntry: (entry: Entry) => Snapshot\n  /**\n   * Response for an unknown emulated route (fails closed, still written to the ledger with the\n   * status it answers); the core may add its own ledger fields to `entry`.\n   */\n  readonly unknownRoute: (entry: Entry) => Response\n  /** Fields listed first in `/_emulate/state`. */\n  readonly stateFields: () => EmulatorStateFields\n  /** Builds the error thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input. */\n  readonly inputInvalid: (input: 'fault' | 'turn', reason: string) => Error\n}\n\nexport type EmulatorRouteHandler<Entry> = (\n  request: Request,\n  entry: Entry,\n  path: string\n) => Promise<Response>\n\n// Control inputs are strict: an unknown key (a typo, or an `error` turn with a bad field) is\n// rejected instead of silently decoding as a different, all-optional shape.\nconst strict = { onExcessProperty: 'error' } as const\n\nconst decodeJsonText = Schema.decodeUnknownResult(Schema.fromJsonString(Schema.Json))\n\nconst issueMessage = (issue: Schema.SchemaError['issue']): string =>\n  new Schema.SchemaError(issue).message\n\nexport const isJsonObject = (value: Schema.Json | undefined): value is Schema.JsonObject =>\n  value !== null && value !== undefined && Predicate.isObject(value) && !Array.isArray(value)\n\nexport const jsonField = (value: Schema.Json | undefined, key: string): Schema.Json | undefined =>\n  isJsonObject(value) ? value[key] : undefined\n\nexport const stringField = (value: Schema.Json | undefined, key: string): string | undefined => {\n  const field = jsonField(value, key)\n\n  return Predicate.isString(field) ? field : undefined\n}\n\nconst textEncoder = new TextEncoder()\n\n/** A JSON response; `body` is any JSON-serializable value (ledger snapshots, fault states, envelopes). */\nexport const jsonResponse = (\n  status: number,\n  body: unknown,\n  headers: HeadersInit = {}\n): Response => {\n  const responseHeaders = new Headers(headers)\n\n  responseHeaders.set('content-type', 'application/json')\n\n  return new Response(JSON.stringify(body), { status, headers: responseHeaders })\n}\n\n/** An emulator (not emulated-service) error: control-plane problems and unbuildable responses. */\nexport const controlError = (\n  status: number,\n  message: string,\n  headers: HeadersInit = {}\n): Response => jsonResponse(status, { error: { message, type: 'emulator_error' } }, headers)\n\n/** A scripted or fault body: a string is sent as is, anything else as JSON. */\nexport const bodyText = (body: Schema.Json): string =>\n  Predicate.isString(body) ? body : JSON.stringify(body)\n\n/** Headers for a scripted or fault body, with a `content-type` matching the body when unset. */\nconst bodyHeaders = (headers: Readonly<Record<string, string>> | undefined, body: Schema.Json) => {\n  const result = new Headers(headers ?? {})\n\n  if (!result.has('content-type')) {\n    result.set('content-type', Predicate.isString(body) ? 'text/plain' : 'application/json')\n  }\n\n  return result\n}\n\nexport const readText = (request: Request): Promise<string | undefined> =>\n  request.text().then(\n    text => text,\n    () => undefined\n  )\n\nexport const parseJson = (text: string): Schema.Json | undefined => {\n  const result = decodeJsonText(text)\n\n  return Result.isSuccess(result) ? result.success : undefined\n}\n\nconst pathMatches = (pattern: string, path: string): boolean =>\n  pattern.endsWith('*') ? path.startsWith(pattern.slice(0, -1)) : pattern === path\n\nconst faultMatches = (fault: KernelFault, path: string, model: string | undefined): boolean =>\n  (fault.match?.path === undefined || pathMatches(fault.match.path, path)) &&\n  (fault.match?.model === undefined || fault.match.model === model)\n\nconst isBodyChunkFault = (fault: KernelFault): fault is BodyChunkFault =>\n  fault.kind === 'error-after-chunks' || fault.kind === 'truncate-after-chunks'\n\nconst chunkFaultProblem = (fault: BodyChunkFault, chunks: number): string | undefined => {\n  const applies =\n    fault.kind === 'error-after-chunks' ? fault.chunks <= chunks : fault.chunks < chunks\n\n  return applies\n    ? undefined\n    : `${fault.kind} after ${fault.chunks} chunk(s) cannot apply to a response with ${chunks} chunk(s)`\n}\n\n/**\n * Strictly pull-driven body: chunk `k` is produced only when the consumer\n * pulls it, and `entry.bodyChunks` counts the chunks handed over. The fault\n * (already validated against the chunk count) applies when the consumer pulls\n * past `fault.chunks` chunks.\n */\nconst chunkedBody = (\n  chunks: ReadonlyArray<string>,\n  fault: BodyChunkFault | undefined,\n  entry: { bodyChunks: number }\n): ReadableStream<Uint8Array> => {\n  let next = 0\n\n  return new ReadableStream<Uint8Array>(\n    {\n      pull: controller => {\n        if (fault !== undefined && next === fault.chunks) {\n          if (fault.kind === 'error-after-chunks') {\n            controller.error(new Error(`synthetic mid-stream failure after ${next} chunk(s)`))\n          } else {\n            controller.close()\n          }\n\n          return\n        }\n\n        const chunk = chunks[next]\n\n        if (chunk === undefined) {\n          controller.close()\n\n          return\n        }\n\n        next += 1\n        entry.bodyChunks += 1\n        controller.enqueue(textEncoder.encode(chunk))\n      }\n    },\n    { highWaterMark: 0 }\n  )\n}\n\nconst withEvidence = (response: Response, evidence: EmulatorEvidence): Response => {\n  if (evidence === 'unverified') {\n    response.headers.set(emulatorEvidenceHeader, 'unverified')\n  }\n\n  return response\n}\n\nconst maxSchemaDepth = 8\n\n/**\n * A synthetic value for a JSON Schema: required object properties only,\n * non-empty strings (or the first `enum` / `const` value), the minimum for\n * numbers, `true` for booleans, and `minItems` synthetic items for arrays.\n */\nexport const synthesizeValue = (\n  schema: Schema.Json | undefined,\n  name: string,\n  depth: number\n): Schema.Json => {\n  const constant = jsonField(schema, 'const')\n\n  if (constant !== undefined) {\n    return constant\n  }\n\n  const choices = jsonField(schema, 'enum')\n\n  if (Array.isArray(choices) && choices.length > 0) {\n    return choices[0] ?? null\n  }\n\n  for (const key of ['anyOf', 'oneOf', 'allOf']) {\n    const options = jsonField(schema, key)\n\n    if (Array.isArray(options) && options.length > 0) {\n      const preferred = options.find(option => stringField(option, 'type') !== 'null')\n\n      return synthesizeValue(preferred ?? options[0], name, depth + 1)\n    }\n  }\n\n  const declared = jsonField(schema, 'type')\n\n  const type = Array.isArray(declared)\n    ? declared.find(entry => Predicate.isString(entry) && entry !== 'null')\n    : declared\n\n  if (depth > maxSchemaDepth) {\n    return null\n  }\n\n  switch (type) {\n    case 'object': {\n      const properties = jsonField(schema, 'properties')\n      const required = jsonField(schema, 'required')\n      const value: Record<string, Schema.Json> = {}\n\n      for (const key of Array.isArray(required) ? required : []) {\n        if (Predicate.isString(key)) {\n          value[key] = synthesizeValue(jsonField(properties, key), key, depth + 1)\n        }\n      }\n\n      return value\n    }\n\n    case 'array': {\n      const minItems = jsonField(schema, 'minItems')\n      const count = Predicate.isNumber(minItems) && minItems > 0 ? Math.min(minItems, 3) : 0\n\n      return Array.from({ length: count }, () =>\n        synthesizeValue(jsonField(schema, 'items'), name, depth + 1)\n      )\n    }\n\n    case 'integer':\n    case 'number': {\n      const minimum = jsonField(schema, 'minimum')\n\n      return Predicate.isNumber(minimum) ? minimum : 1\n    }\n\n    case 'boolean':\n      return true\n    case 'null':\n      return null\n    default:\n      return `synthetic ${name}`\n  }\n}\n\n/** Split text into up to `parts` non-empty fragments (at least one). */\nexport const splitFragments = (text: string, parts: number): ReadonlyArray<string> => {\n  if (text.length <= 1) {\n    return [text]\n  }\n\n  const size = Math.ceil(text.length / Math.min(parts, text.length))\n  const fragments: Array<string> = []\n\n  for (let index = 0; index < text.length; index += size) {\n    fragments.push(text.slice(index, index + size))\n  }\n\n  return fragments\n}\n\n/** A rough synthetic token count (about four characters per token, at least one). */\nexport const approximateTokens = (text: string): number => Math.max(1, Math.ceil(text.length / 4))\n\n/**\n * Create the kernel of an emulator. Each call has independent ledger, fault,\n * and script state. Handlers use the returned helpers, then `serve` binds\n * them to the manifest (throwing `EmulatorRouteUnmapped` on a mismatch) and\n * returns the emulator API.\n */\nexport const makeEmulatorKernel = <\n  Fault extends KernelFault,\n  Turn,\n  Entry extends KernelLedgerEntry<Fault['kind']>,\n  Snapshot\n>(\n  config: EmulatorKernelConfig<Fault, Turn, Entry, Snapshot>\n) => {\n  const decodeFault = Schema.decodeUnknownResult(config.faultSchema, strict)\n\n  const decodeFaultList = Schema.decodeUnknownResult(\n    Schema.Union([config.faultSchema, Schema.Struct({ faults: Schema.Array(config.faultSchema) })]),\n    strict\n  )\n\n  const decodeTurn = Schema.decodeUnknownResult(config.turnSchema, strict)\n\n  const decodeTurnList = Schema.decodeUnknownResult(\n    Schema.Union([Schema.Struct({ turns: Schema.Array(config.turnSchema) }), config.turnSchema]),\n    strict\n  )\n\n  let entries: Array<Entry> = []\n  let faultStates: Array<MutableFaultState<Fault>> = []\n  let turns: Array<Turn> = []\n  let nextSeq = 1\n  let nextFaultId = 1\n\n  const snapshotFault = (state: MutableFaultState<Fault>): EmulatorFaultState<Fault> => ({\n    ...state\n  })\n\n  const clearLedger = () => {\n    entries = []\n    nextSeq = 1\n  }\n\n  const addFault = (input: unknown): EmulatorFaultState<Fault> | string => {\n    const decoded = decodeFault(input)\n\n    if (Result.isFailure(decoded)) {\n      return issueMessage(decoded.failure.issue)\n    }\n\n    const state: MutableFaultState<Fault> = {\n      id: nextFaultId++,\n      fault: decoded.success,\n      remaining: decoded.success.count,\n      applied: 0\n    }\n\n    faultStates.push(state)\n\n    return snapshotFault(state)\n  }\n\n  const enqueueTurn = (input: unknown): string | undefined => {\n    const decoded = decodeTurn(input)\n\n    if (Result.isFailure(decoded)) {\n      return issueMessage(decoded.failure.issue)\n    }\n\n    turns.push(decoded.success)\n\n    return undefined\n  }\n\n  /** The first matching fault with uses left, in insertion order (not yet consumed). */\n  const takeFault = (\n    path: string,\n    model: string | undefined\n  ): MutableFaultState<Fault> | undefined =>\n    faultStates.find(\n      state =>\n        (state.remaining === undefined || state.remaining > 0) &&\n        faultMatches(state.fault, path, model)\n    )\n\n  /** Use up one application of a fault and record its kind in the ledger entry. */\n  const consumeFault = (state: MutableFaultState<Fault>, entry: Entry) => {\n    state.applied += 1\n    entry.fault = state.fault.kind\n\n    if (state.remaining !== undefined) {\n      state.remaining -= 1\n    }\n  }\n\n  /** The next scripted turn, used up when its request arrives. */\n  const nextTurn = (): Turn | undefined => turns.shift()\n\n  const coverage = (): EmulatorCoverage => ({\n    routes: config.routes.map(route => ({\n      ...route,\n      requests: entries.filter(\n        entry =>\n          entry.evidence !== 'unknown-route' &&\n          entry.method === route.method &&\n          entry.path === route.path\n      ).length\n    })),\n    unknownRouteRequests: entries.filter(entry => entry.evidence === 'unknown-route').length\n  })\n\n  /**\n   * Answer with a pull-driven body. A matching `error-after-chunks` or\n   * `truncate-after-chunks` fault shapes it; one that cannot take effect\n   * answers 500 and is not consumed. Other fault kinds are left to the caller.\n   */\n  const respondWithBody = (\n    entry: Entry,\n    status: number,\n    headers: HeadersInit,\n    chunks: ReadonlyArray<string>,\n    fault: MutableFaultState<Fault> | undefined\n  ): Response => {\n    const chunkFault =\n      fault === undefined || !isBodyChunkFault(fault.fault) ? undefined : fault.fault\n\n    if (chunkFault !== undefined) {\n      const problem = chunkFaultProblem(chunkFault, chunks.length)\n\n      if (problem !== undefined) {\n        entry.faultError = problem\n        entry.status = 500\n\n        return controlError(500, `emulator fault cannot apply: ${problem}`)\n      }\n    }\n\n    // Build the response before using up the fault: a response that cannot be built must not\n    // consume it.\n    const response = new Response(chunkedBody(chunks, chunkFault, entry), { status, headers })\n\n    if (chunkFault !== undefined && fault !== undefined) {\n      consumeFault(fault, entry)\n    }\n\n    entry.status = response.status\n\n    return response\n  }\n\n  /** Answer a `status` fault with its status, headers, and body (or `defaultBody`). */\n  const respondWithStatusFault = (\n    entry: Entry,\n    state: MutableFaultState<Fault>,\n    fault: typeof EmulatorStatusFault.Type,\n    defaultBody: (status: number) => Schema.Json\n  ): Response => {\n    const faultBody = fault.body ?? defaultBody(fault.status)\n\n    // Built first: a status fault whose response cannot be built is not used up.\n    const response = new Response(bodyText(faultBody), {\n      status: fault.status,\n      headers: bodyHeaders(fault.headers, faultBody)\n    })\n\n    consumeFault(state, entry)\n    entry.status = response.status\n\n    return response\n  }\n\n  /** Answer a scripted error turn; a matching chunk fault still shapes its body. */\n  const respondWithScriptedError = (\n    entry: Entry,\n    error: EmulatorScriptedError['error'],\n    fault: MutableFaultState<Fault> | undefined\n  ): Response =>\n    respondWithBody(\n      entry,\n      error.status,\n      bodyHeaders(error.headers, error.body),\n      [bodyText(error.body)],\n      fault\n    )\n\n  const reset = () => {\n    clearLedger()\n    faultStates = []\n    turns = []\n  }\n\n  const state = () => ({\n    ...config.stateFields(),\n    pendingTurns: turns.length,\n    faults: faultStates.map(snapshotFault),\n    ledgerEntries: entries.length\n  })\n\n  const controlPlane = async (request: Request, path: string): Promise<Response> => {\n    const method = request.method\n    const allow = (methods: string) => controlError(405, 'method not allowed', { allow: methods })\n\n    const jsonBody = async (): Promise<Schema.Json | undefined> => {\n      const text = await readText(request)\n\n      return text === undefined ? undefined : parseJson(text)\n    }\n\n    switch (path) {\n      case '/_emulate/ledger':\n        if (method === 'GET') {\n          return jsonResponse(200, { entries: entries.map(config.snapshotEntry) })\n        }\n\n        if (method === 'DELETE') {\n          const cleared = entries.length\n\n          clearLedger()\n\n          return jsonResponse(200, { cleared })\n        }\n\n        return allow('GET, DELETE')\n\n      case '/_emulate/faults': {\n        if (method === 'GET') {\n          return jsonResponse(200, { faults: faultStates.map(snapshotFault) })\n        }\n\n        if (method === 'DELETE') {\n          const cleared = faultStates.length\n\n          faultStates = []\n\n          return jsonResponse(200, { cleared })\n        }\n\n        if (method !== 'POST') {\n          return allow('GET, POST, DELETE')\n        }\n\n        const decoded = decodeFaultList(await jsonBody())\n\n        if (Result.isFailure(decoded)) {\n          return controlError(400, `invalid fault: ${issueMessage(decoded.failure.issue)}`)\n        }\n\n        const added = (\n          'faults' in decoded.success ? decoded.success.faults : [decoded.success]\n        ).map(fault => addFault(fault))\n\n        return jsonResponse(201, { faults: added })\n      }\n\n      case '/_emulate/script': {\n        if (method !== 'POST') {\n          return allow('POST')\n        }\n\n        const decoded = decodeTurnList(await jsonBody())\n\n        if (Result.isFailure(decoded)) {\n          return controlError(400, `invalid turn: ${issueMessage(decoded.failure.issue)}`)\n        }\n\n        const queued =\n          Predicate.isObject(decoded.success) && 'turns' in decoded.success\n            ? decoded.success.turns\n            : [decoded.success]\n\n        for (const turn of queued) {\n          enqueueTurn(turn)\n        }\n\n        return jsonResponse(201, { pending: turns.length })\n      }\n\n      case '/_emulate/reset':\n        if (method !== 'POST') {\n          return allow('POST')\n        }\n\n        reset()\n\n        return jsonResponse(200, { reset: true })\n\n      case '/_emulate/state':\n        if (method !== 'GET') {\n          return allow('GET')\n        }\n\n        return jsonResponse(200, state())\n\n      case '/_emulate/coverage':\n        if (method !== 'GET') {\n          return allow('GET')\n        }\n\n        return jsonResponse(200, coverage())\n\n      default:\n        return controlError(404, 'unknown control-plane route')\n    }\n  }\n\n  /**\n   * Bind one handler per manifest route (keyed by `emulatorRouteKey`) and\n   * return the emulator API. Throws `EmulatorRouteUnmapped` when a manifest\n   * route has no handler or a handler has no manifest route.\n   */\n  const serve = (\n    handlers: ReadonlyMap<string, EmulatorRouteHandler<Entry>>\n  ): EmulatorApi<Turn, Fault, Snapshot> => {\n    const routes = bindRouteHandlers(config.routes, handlers)\n\n    const emulatedApi = async (request: Request, path: string): Promise<Response> => {\n      const bound = routes.find(\n        candidate => candidate.route.method === request.method && candidate.route.path === path\n      )\n\n      const entry = config.newEntry({\n        seq: nextSeq++,\n        method: request.method,\n        path,\n        evidence: bound?.route.evidence ?? 'unknown-route',\n        status: 0,\n        bodyChunks: 0\n      })\n\n      entries.push(entry)\n\n      if (bound === undefined) {\n        const response = config.unknownRoute(entry)\n\n        entry.status = response.status\n\n        return response\n      }\n\n      // Error recovery still answers through the route: the fallback 500 is evidence-tagged and\n      // the ledger records the status actually sent.\n      const response = await bound.handler(request, entry, path).catch(() => {\n        entry.status = 500\n        entry.responseError = 'the emulator could not build the planned response'\n\n        return controlError(500, 'emulator could not build the response')\n      })\n\n      return withEvidence(response, bound.route.evidence)\n    }\n\n    const handle = (request: Request): Promise<Response> => {\n      const path = URL.canParse(request.url) ? new URL(request.url).pathname : '/'\n\n      return path === '/_emulate' || path.startsWith('/_emulate/')\n        ? controlPlane(request, path)\n        : emulatedApi(request, path)\n    }\n\n    return {\n      fetch: request =>\n        handle(request).catch(() => controlError(500, 'emulator failed to handle the request')),\n      ledger: {\n        entries: () => entries.map(config.snapshotEntry),\n        clear: clearLedger\n      },\n      reset,\n      faults: {\n        add: fault => {\n          const added = addFault(fault)\n\n          if (Predicate.isString(added)) {\n            throw config.inputInvalid('fault', added)\n          }\n\n          return added\n        },\n        list: () => faultStates.map(snapshotFault),\n        clear: () => {\n          faultStates = []\n        }\n      },\n      script: {\n        enqueue: turn => {\n          const problem = enqueueTurn(turn)\n\n          if (problem !== undefined) {\n            throw config.inputInvalid('turn', problem)\n          }\n        },\n        pending: () => turns.length,\n        clear: () => {\n          turns = []\n        }\n      },\n      coverage\n    }\n  }\n\n  return {\n    takeFault,\n    consumeFault,\n    nextTurn,\n    respondWithBody,\n    respondWithStatusFault,\n    respondWithScriptedError,\n    serve\n  }\n}\n"],"mappings":"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"}

package/dist/fixture-route.d.mts

@@ -0,0 +1,129 @@
+import { EmulatorEvidence, EmulatorRouteEvidence } from "./route-evidence.mjs";
+import { EmulatorApi, EmulatorScriptedError } from "./emulator-kernel.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/fixture-route.d.ts
+/** One committed fixture exchange, copied as data. */
+type FixtureRecording = {
+  readonly fixtureId: string;
+  readonly caseId: string;
+  readonly request: {
+    readonly method: string;
+    readonly path: string; /** The recorded query string (with `?`), or empty. */
+    readonly query: string; /** The recorded (non-credential) request headers, lower-case. */
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body?: Schema.Json;
+  };
+  readonly response: {
+    readonly status: number;
+    readonly headers: Readonly<Record<string, string>>; /** Whether the fixture recorded network chunks (a stream) or one body. */
+    readonly streamed: boolean; /** Network chunks as recorded; a body is one chunk. */
+    readonly chunks: ReadonlyArray<string>;
+  };
+};
+/**
+ * Faults: the shared kernel kinds only, with `status` limited to 400-599. `status` without a
+ * `body` answers an emulator-fault body (`{ error: { type: 'emulator_fault', message } }`), never
+ * a guessed provider envelope.
+ */
+declare const FixtureRouteFault: Schema.Union<readonly [Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+  readonly kind: Schema.Literal<"status">;
+  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  readonly body: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>, Schema.Struct<{
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+  readonly kind: Schema.Literal<"error-after-chunks">;
+  readonly chunks: Schema.Int;
+}>, Schema.Struct<{
+  readonly match: Schema.optionalKey<Schema.Struct<{
+    readonly path: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly count: Schema.optionalKey<Schema.Int>;
+  readonly kind: Schema.Literal<"truncate-after-chunks">;
+  readonly chunks: Schema.Int;
+}>]>;
+type FixtureRouteFault = typeof FixtureRouteFault.Type;
+type FixtureRouteFaultKind = FixtureRouteFault['kind'];
+/** A scripted replacement body (replaceable-body routes only), shape-checked against the recording. */
+type FixtureRouteScriptedBody = {
+  readonly usage: Schema.Json;
+};
+/** A scripted turn: an error response, or (replaceable-body routes only) a replacement body. */
+type FixtureRouteScriptedTurn = EmulatorScriptedError | FixtureRouteScriptedBody;
+type FixtureRouteLedgerEntry = {
+  /** 1-based arrival order since the last ledger clear or reset. */readonly seq: number;
+  readonly method: string;
+  readonly path: string; /** The request's query string (with `?`), when it has one. */
+  readonly query?: string; /** Parsed JSON request body, when it was valid JSON. */
+  readonly body?: Schema.Json;
+  readonly model?: string; /** Which credential header carried a non-empty value (the value is never recorded). */
+  readonly credentialHeader?: 'authorization' | 'x-api-key'; /** Values of the non-credential headers the route records (lower-case names). */
+  readonly headers: Readonly<Record<string, string>>; /** The fixture id whose recorded response answered the request. */
+  readonly recording?: string; /** Why the request was answered 400 not-emulated. */
+  readonly notEmulated?: string; /** Kind of the fault that shaped the response. */
+  readonly fault?: FixtureRouteFaultKind; /** Why a matching fault could not take effect (the response was a 500 emulator error). */
+  readonly faultError?: string; /** Set when the emulator could not build the planned response (answered 500). */
+  readonly responseError?: string; /** Set when a scripted turn answered the request. */
+  readonly scripted?: 'usage' | 'error'; /** Evidence of the matched route; `unknown-route` for requests on no route. */
+  readonly evidence: EmulatorEvidence | 'unknown-route';
+  readonly status: number; /** Body chunks handed to the transport so far (each produced when pulled). */
+  readonly bodyChunks: number;
+};
+type FixtureRouteEmulator = EmulatorApi<FixtureRouteScriptedTurn, FixtureRouteFault, FixtureRouteLedgerEntry>;
+/** A header every request must carry (non-empty and, when set, accepted by `accepts`). */
+type FixtureRouteHeaderRule = {
+  /** Lower-case header name. */readonly name: string; /** Keep the value in the ledger (never for credential or account headers). */
+  readonly record: boolean;
+  readonly accepts?: (value: string) => boolean;
+};
+type FixtureRouteConfig = {
+  readonly method: 'GET' | 'POST';
+  readonly path: string; /** Route evidence manifest; must list exactly this route. */
+  readonly routes: ReadonlyArray<EmulatorRouteEvidence>; /** The recordings this route answers from (at least one), tried in order. */
+  readonly recordings: ReadonlyArray<FixtureRecording>; /** The credential header the SDK sends: a non-empty Bearer, or a non-empty `x-api-key`. */
+  readonly credential: 'bearer' | 'x-api-key'; /** Headers the SDK sends besides the credential and the recorded ones, required in order. */
+  readonly headers: ReadonlyArray<FixtureRouteHeaderRule>;
+  /**
+   * Replaceable JSON body (usage routes): enables the scripted `{ usage }` turn, and
+   * `defaultBody` replaces the recorded body; both must have the recorded body's JSON shape.
+   */
+  readonly replaceableBody?: {
+    readonly defaultBody: Schema.Json | undefined;
+  }; /** Builds the error thrown by the JS API (and at construction) for invalid input. */
+  readonly inputInvalid: (input: 'fault' | 'turn', reason: string) => Error;
+};
+/** The one answer for everything no fixture records. */
+declare const notEmulatedResponse: (reason: string) => Response;
+/**
+ * Where `actual` leaves the recorded request shape (the documented latitude applied), or
+ * undefined when it matches.
+ */
+declare const recordedRequestMismatch: (actual: Schema.Json | undefined, recorded: Schema.Json, path?: string, key?: string) => string | undefined;
+/** Where `actual` leaves the recorded JSON shape (object keys and value kinds), or undefined. */
+declare const recordedBodyMismatch: (actual: Schema.Json, recorded: Schema.Json, path?: string) => string | undefined;
+/**
+ * Create a fixture-only route. Each call has independent ledger, fault, and script state. Throws
+ * `inputInvalid('turn', ...)` when a replaceable body's `defaultBody` does not have the recorded
+ * shape.
+ *
+ * Precedence per request: the credential, the header rules in order, the recorded headers and
+ * query, the recorded request shape (one of `recordings`); a request failing any of these answers
+ * 400 not-emulated and uses up no fault or turn. Then the first matching fault if it is a `status`
+ * fault, then the next scripted turn, then the recorded response; a first matching body fault then
+ * shapes the body.
+ */
+declare const makeFixtureRouteEmulator: (config: FixtureRouteConfig) => FixtureRouteEmulator;
+//#endregion
+export { FixtureRecording, FixtureRouteConfig, FixtureRouteEmulator, FixtureRouteFault, FixtureRouteFaultKind, FixtureRouteHeaderRule, FixtureRouteLedgerEntry, FixtureRouteScriptedBody, FixtureRouteScriptedTurn, makeFixtureRouteEmulator, notEmulatedResponse, recordedBodyMismatch, recordedRequestMismatch };
+//# sourceMappingURL=fixture-route.d.mts.map

package/dist/fixture-route.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture-route.d.mts","names":[],"sources":["../src/fixture-route.ts"],"mappings":";;;;;;KAsDY,gBAAA;EAAA,SACD,SAAA;EAAA,SACA,MAAA;EAAA,SACA,OAAA;IAAA,SACE,MAAA;IAAA,SACA,IAAA,UAKO;IAAA,SAHP,KAAA,UAOS;IAAA,SALT,OAAA,EAAS,QAAA,CAAS,MAAA;IAAA,SAClB,IAAA,GAAO,MAAA,CAAO,IAAA;EAAA;EAAA,SAEhB,QAAA;IAAA,SACE,MAAA;IAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,mBAVlB;IAAA,SAYA,QAAA,WATA;IAAA,SAWA,MAAA,EAAQ,aAAA;EAAA;AAAA;;;;;;cA0BR,iBAAA,EAAiB,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;KAMlB,iBAAA,UAA2B,iBAAA,CAAkB,IAAI;AAAA,KAEjD,qBAAA,GAAwB,iBAAiB;;KAGzC,wBAAA;EAAA,SAAsC,KAAA,EAAO,MAAA,CAAO,IAAI;AAAA;;KAGxD,wBAAA,GAA2B,qBAAA,GAAwB,wBAAwB;AAAA,KAE3E,uBAAA;6EAED,GAAA;EAAA,SACA,MAAA;EAAA,SACA,IAAA;WAEA,KAAA;WAEA,IAAA,GAAO,MAAA,CAAO,IAAA;EAAA,SACd,KAAA;WAEA,gBAAA;WAEA,OAAA,EAAS,QAAA,CAAS,MAAA;WAElB,SAAA;WAEA,WAAA,WAjCmB;EAAA,SAmCnB,KAAA,GAAQ,qBAAA,EAnCW;EAAA,SAqCnB,UAAA,WArCmB;EAAA,SAuCnB,aAAA;WAEA,QAAA;WAEA,QAAA,EAAU,gBAAA;EAAA,SACV,MAAA;WAEA,UAAA;AAAA;AAAA,KAGC,oBAAA,GAAuB,WAAA,CACjC,wBAAA,EACA,iBAAA,EACA,uBAAA;;KAIU,sBAAA;yCAED,IAAA;WAEA,MAAA;EAAA,SACA,OAAA,IAAW,KAAA;AAAA;AAAA,KAGV,kBAAA;EAAA,SACD,MAAA;EAAA,SACA,IAAA;WAEA,MAAA,EAAQ,aAAA,CAAc,qBAAA;WAEtB,UAAA,EAAY,aAAA,CAAc,gBAAA;WAE1B,UAAA;WAEA,OAAA,EAAS,aAAA,CAAc,sBAAA;;;;;WAKvB,eAAA;IAAA,SAA6B,WAAA,EAAa,MAAA,CAAO,IAAA;EAAA;WAEjD,YAAA,GAAe,KAAA,oBAAyB,MAAA,aAAmB,KAAA;AAAA;;cAIzD,mBAAA,GAAuB,MAAA,aAAiB,QACuC;;;;;cAwB/E,uBAAA,GACX,MAAA,EAAQ,MAAA,CAAO,IAAA,cACf,QAAA,EAAU,MAAA,CAAO,IAAI,EACrB,IAAA,WACA,GAAA;;cAgEW,oBAAA,GACX,MAAA,EAAQ,MAAA,CAAO,IAAA,EACf,QAAA,EAAU,MAAA,CAAO,IAAI,EACrB,IAAA;;;;;;;;;;;;cA0EW,wBAAA,GAA4B,MAAA,EAAQ,kBAAA,KAAqB,oBA+MrE"}

package/dist/fixture-route.mjs

@@ -0,0 +1,257 @@
+import { emulatorRouteKey } from "./route-evidence.mjs";
+import { EmulatorErrorAfterChunksFault, EmulatorScriptedError, EmulatorStatusFault, EmulatorTruncateAfterChunksFault, isJsonObject, jsonResponse, makeEmulatorKernel, parseJson, readText, stringField } from "./emulator-kernel.mjs";
+import { Predicate } from "effect";
+import * as Schema from "effect/Schema";
+//#region src/fixture-route.ts
+/**
+* Fixture-only route core (internal; not a package export).
+*
+* The owner rule for every route added after the model-route emulators (the four OpenCode Go
+* routes and the Claude, Codex, and Grok subscription-usage routes): response behaviour comes only
+* from the committed conformance fixtures.
+*
+* - A request that matches a recorded request's shape (within the documented request-shape
+*   latitude below) gets that recording's response, copied as data (`*-recordings.ts`; never an
+*   SDK import).
+* - Everything else answers one ledgered 400 not-emulated: unknown routes, other methods, missing
+*   or invalid credentials, missing or other headers and query parameters, unknown models, other
+*   request shapes (non-streamed modes, tools, reasoning, other message kinds, extra fields).
+* - Test controls, as far as the other emulators allow them: the shared kernel faults (`status`,
+*   `error-after-chunks`, `truncate-after-chunks`) and scripted error turns; a route with a
+*   replaceable JSON body (the usage routes) also takes a scripted `{ usage }` body (or a default
+*   override) whose JSON shape (object keys and value kinds) equals the recording's. Fault and
+*   scripted-error statuses must be 400-599, so no control can produce a success status or
+*   a body other than the recorded one (or a prefix of it cut by the truncation faults).
+*
+* Request-shape latitude (accepted, harmless): any credential value (never checked or stored);
+* extra request headers; key order; every string value except the discriminators `model`, `role`,
+* `type`, and `phase` (which must equal the recording); any positive integer where the recording
+* has a number (the output-token limit). Array lengths, object keys, booleans (`stream`, `store`,
+* `include_usage`, `parallel_tool_calls`, `additionalProperties`), the recorded `accept` value,
+* the `content-type` media type, and the query string (exactly, byte for byte; a bare `?` counts as no query) must equal the
+* recording. Route-specific header values (for example Grok's `x-grok-client-version`) are
+* documented by the route that declares them.
+*
+* Runtime-portable Web APIs only; no Node builtins and no SDK imports.
+*/
+const FixtureRouteErrorStatus = Schema.Int.check(Schema.isBetween({
+	minimum: 400,
+	maximum: 599
+}));
+const FixtureRouteStatusFault = Schema.Struct({
+	...EmulatorStatusFault.fields,
+	status: FixtureRouteErrorStatus
+});
+const FixtureRouteScriptedError = Schema.Struct({ error: Schema.Struct({
+	...EmulatorScriptedError.fields.error.fields,
+	status: FixtureRouteErrorStatus
+}) });
+/**
+* Faults: the shared kernel kinds only, with `status` limited to 400-599. `status` without a
+* `body` answers an emulator-fault body (`{ error: { type: 'emulator_fault', message } }`), never
+* a guessed provider envelope.
+*/
+const FixtureRouteFault = Schema.Union([
+	FixtureRouteStatusFault,
+	EmulatorErrorAfterChunksFault,
+	EmulatorTruncateAfterChunksFault
+]);
+/** The one answer for everything no fixture records. */
+const notEmulatedResponse = (reason) => jsonResponse(400, { error: {
+	type: "not_emulated",
+	message: `Not emulated: ${reason}`
+} });
+const faultBody = (status) => ({ error: {
+	type: "emulator_fault",
+	message: `Emulator fault: status ${status}.`
+} });
+const discriminators = [
+	"model",
+	"role",
+	"type",
+	"phase"
+];
+const kindOf = (value) => {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	if (Predicate.isString(value)) return "string";
+	if (Predicate.isNumber(value)) return "number";
+	return Predicate.isBoolean(value) ? "boolean" : "object";
+};
+/**
+* Where `actual` leaves the recorded request shape (the documented latitude applied), or
+* undefined when it matches.
+*/
+const recordedRequestMismatch = (actual, recorded, path = "$", key = "") => {
+	if (actual === void 0) return `${path} is missing`;
+	if (isJsonObject(recorded)) {
+		if (!isJsonObject(actual)) return `${path} is not an object`;
+		const recordedKeys = Object.keys(recorded).sort();
+		const actualKeys = Object.keys(actual).sort();
+		const extra = actualKeys.filter((name) => !recordedKeys.includes(name));
+		const missing = recordedKeys.filter((name) => !actualKeys.includes(name));
+		if (extra.length > 0) return `${path} has unrecorded field(s) ${extra.join(", ")}`;
+		if (missing.length > 0) return `${path} lacks recorded field(s) ${missing.join(", ")}`;
+		for (const name of recordedKeys) {
+			const field = recorded[name];
+			if (field === void 0) continue;
+			const mismatch = recordedRequestMismatch(actual[name], field, `${path}.${name}`, name);
+			if (mismatch !== void 0) return mismatch;
+		}
+		return;
+	}
+	if (Array.isArray(recorded)) {
+		if (!Array.isArray(actual)) return `${path} is not an array`;
+		if (actual.length !== recorded.length) return `${path} has ${actual.length} item(s), the recording ${recorded.length}`;
+		for (const [index, item] of recorded.entries()) {
+			const mismatch = recordedRequestMismatch(actual[index], item, `${path}[${index}]`, key);
+			if (mismatch !== void 0) return mismatch;
+		}
+		return;
+	}
+	if (kindOf(actual) !== kindOf(recorded)) return `${path} is not a ${kindOf(recorded)}`;
+	if (Predicate.isString(recorded)) return discriminators.includes(key) && actual !== recorded ? `${path} is not the recorded ${key}` : void 0;
+	if (Predicate.isNumber(recorded)) return Predicate.isNumber(actual) && Number.isSafeInteger(actual) && actual > 0 ? void 0 : `${path} is not a positive integer`;
+	return actual === recorded ? void 0 : `${path} is not the recorded value`;
+};
+/** Where `actual` leaves the recorded JSON shape (object keys and value kinds), or undefined. */
+const recordedBodyMismatch = (actual, recorded, path = "$") => {
+	if (isJsonObject(recorded)) {
+		if (!isJsonObject(actual)) return `${path} is not an object`;
+		const recordedKeys = Object.keys(recorded).sort();
+		if (JSON.stringify(Object.keys(actual).sort()) !== JSON.stringify(recordedKeys)) return `${path} does not have the recorded fields ${recordedKeys.join(", ")}`;
+		for (const name of recordedKeys) {
+			const actualField = actual[name];
+			const recordedField = recorded[name];
+			if (actualField === void 0 || recordedField === void 0) continue;
+			const mismatch = recordedBodyMismatch(actualField, recordedField, `${path}.${name}`);
+			if (mismatch !== void 0) return mismatch;
+		}
+		return;
+	}
+	if (Array.isArray(recorded)) {
+		if (!Array.isArray(actual) || actual.length !== recorded.length) return `${path} is not a ${recorded.length}-item array`;
+		for (const [index, item] of recorded.entries()) {
+			const actualItem = actual[index];
+			if (actualItem === void 0) return `${path}[${index}] is missing`;
+			const mismatch = recordedBodyMismatch(actualItem, item, `${path}[${index}]`);
+			if (mismatch !== void 0) return mismatch;
+		}
+		return;
+	}
+	return kindOf(actual) === kindOf(recorded) ? void 0 : `${path} is not a ${kindOf(recorded)}`;
+};
+const bearerPattern = /^bearer\s+\S+/i;
+const mediaType = (value) => value?.split(";")[0]?.trim().toLowerCase();
+/**
+* Create a fixture-only route. Each call has independent ledger, fault, and script state. Throws
+* `inputInvalid('turn', ...)` when a replaceable body's `defaultBody` does not have the recorded
+* shape.
+*
+* Precedence per request: the credential, the header rules in order, the recorded headers and
+* query, the recorded request shape (one of `recordings`); a request failing any of these answers
+* 400 not-emulated and uses up no fault or turn. Then the first matching fault if it is a `status`
+* fault, then the next scripted turn, then the recorded response; a first matching body fault then
+* shapes the body.
+*/
+const makeFixtureRouteEmulator = (config) => {
+	const [primary] = config.recordings;
+	if (primary === void 0) throw config.inputInvalid("turn", "a fixture route needs at least one recording");
+	const recordedBody = config.replaceableBody === void 0 ? void 0 : parseJson(primary.response.chunks.join(""));
+	const bodyMismatch = (value) => recordedBody === void 0 ? "this route has no replaceable body" : recordedBodyMismatch(value, recordedBody);
+	const defaultBody = config.replaceableBody?.defaultBody;
+	if (defaultBody !== void 0) {
+		const mismatch = bodyMismatch(defaultBody);
+		if (mismatch !== void 0) throw config.inputInvalid("turn", `the default body must have the recorded shape: ${mismatch}`);
+	}
+	const ScriptedBody = Schema.Struct({ usage: Schema.Json.check(Schema.makeFilter((value) => {
+		const mismatch = bodyMismatch(value);
+		return mismatch === void 0 ? true : `must have the recorded shape: ${mismatch}`;
+	})) });
+	const turnSchema = config.replaceableBody === void 0 ? FixtureRouteScriptedError : Schema.Union([FixtureRouteScriptedError, ScriptedBody]);
+	const models = config.recordings.flatMap((recording) => {
+		const model = stringField(recording.request.body, "model");
+		return model === void 0 ? [] : [model];
+	});
+	const kernel = makeEmulatorKernel({
+		routes: config.routes,
+		faultSchema: FixtureRouteFault,
+		turnSchema,
+		newEntry: (base) => ({
+			...base,
+			headers: {}
+		}),
+		snapshotEntry: (entry) => ({
+			...entry,
+			headers: { ...entry.headers }
+		}),
+		unknownRoute: (entry) => {
+			entry.notEmulated = "no recorded route for this method and path";
+			return notEmulatedResponse(entry.notEmulated);
+		},
+		stateFields: () => ({ knownModels: [...new Set(models)] }),
+		inputInvalid: config.inputInvalid
+	});
+	const recordingMismatch = (recording, request, url, text, json) => {
+		for (const [name, value] of Object.entries(recording.request.headers)) {
+			const actual = request.headers.get(name);
+			if (!(name === "content-type" ? mediaType(actual) === mediaType(value) : actual === value)) return `the ${name} header is not the recorded ${value}`;
+		}
+		if (url.search !== recording.request.query) return recording.request.query.length === 0 ? "the recording has no query parameters" : `the query is not the recorded ${recording.request.query}`;
+		if (recording.request.body === void 0) return text.length === 0 ? void 0 : "the recording has no request body";
+		if (json === void 0) return "the request body is not JSON";
+		return recordedRequestMismatch(json, recording.request.body);
+	};
+	const admit = async (request, entry) => {
+		if (!(config.credential === "bearer" ? bearerPattern.test(request.headers.get("authorization") ?? "") : (request.headers.get("x-api-key") ?? "").trim().length > 0)) return { reason: config.credential === "bearer" ? "a non-empty Authorization: Bearer credential is required" : "a non-empty x-api-key credential is required" };
+		entry.credentialHeader = config.credential === "bearer" ? "authorization" : "x-api-key";
+		for (const rule of config.headers) {
+			const value = (request.headers.get(rule.name) ?? "").trim();
+			if (value.length === 0 || rule.accepts !== void 0 && !rule.accepts(value)) return { reason: `the ${rule.name} header is missing or not the one the SDK sends` };
+		}
+		const url = new URL(request.url);
+		const text = await readText(request) ?? "";
+		const json = config.method === "POST" ? parseJson(text) : void 0;
+		if (json !== void 0) entry.body = json;
+		const model = stringField(json, "model");
+		if (model !== void 0) entry.model = model;
+		const reasons = [];
+		for (const recording of config.recordings) {
+			const reason = recordingMismatch(recording, request, url, text, json);
+			if (reason === void 0) return { recording };
+			reasons.push(config.recordings.length === 1 ? reason : `${recording.caseId}: ${reason}`);
+		}
+		return { reason: reasons.join("; ") };
+	};
+	const handle = async (request, entry, path) => {
+		for (const rule of config.headers) {
+			const value = request.headers.get(rule.name);
+			if (rule.record && value !== null) entry.headers[rule.name] = value;
+		}
+		const search = new URL(request.url).search;
+		if (search.length > 0) entry.query = search;
+		const admitted = await admit(request, entry);
+		if ("reason" in admitted) {
+			entry.notEmulated = admitted.reason;
+			entry.status = 400;
+			return notEmulatedResponse(admitted.reason);
+		}
+		const recording = admitted.recording;
+		const fault = kernel.takeFault(path, entry.model);
+		if (fault !== void 0 && fault.fault.kind === "status") return kernel.respondWithStatusFault(entry, fault, fault.fault, faultBody);
+		const turn = kernel.nextTurn();
+		if (turn !== void 0 && "error" in turn) {
+			entry.scripted = "error";
+			return kernel.respondWithScriptedError(entry, turn.error, fault);
+		}
+		const body = turn === void 0 ? defaultBody : turn.usage;
+		if (turn !== void 0) entry.scripted = "usage";
+		entry.recording = recording.fixtureId;
+		return kernel.respondWithBody(entry, recording.response.status, { ...recording.response.headers }, body === void 0 ? recording.response.chunks : [JSON.stringify(body)], fault);
+	};
+	return kernel.serve(new Map([[emulatorRouteKey(config.method, config.path), handle]]));
+};
+//#endregion
+export { FixtureRouteFault, makeFixtureRouteEmulator, notEmulatedResponse, recordedBodyMismatch, recordedRequestMismatch };
+
+//# sourceMappingURL=fixture-route.mjs.map

package/dist/fixture-route.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixture-route.mjs","names":[],"sources":["../src/fixture-route.ts"],"sourcesContent":["/**\n * Fixture-only route core (internal; not a package export).\n *\n * The owner rule for every route added after the model-route emulators (the four OpenCode Go\n * routes and the Claude, Codex, and Grok subscription-usage routes): response behaviour comes only\n * from the committed conformance fixtures.\n *\n * - A request that matches a recorded request's shape (within the documented request-shape\n *   latitude below) gets that recording's response, copied as data (`*-recordings.ts`; never an\n *   SDK import).\n * - Everything else answers one ledgered 400 not-emulated: unknown routes, other methods, missing\n *   or invalid credentials, missing or other headers and query parameters, unknown models, other\n *   request shapes (non-streamed modes, tools, reasoning, other message kinds, extra fields).\n * - Test controls, as far as the other emulators allow them: the shared kernel faults (`status`,\n *   `error-after-chunks`, `truncate-after-chunks`) and scripted error turns; a route with a\n *   replaceable JSON body (the usage routes) also takes a scripted `{ usage }` body (or a default\n *   override) whose JSON shape (object keys and value kinds) equals the recording's. Fault and\n *   scripted-error statuses must be 400-599, so no control can produce a success status or\n *   a body other than the recorded one (or a prefix of it cut by the truncation faults).\n *\n * Request-shape latitude (accepted, harmless): any credential value (never checked or stored);\n * extra request headers; key order; every string value except the discriminators `model`, `role`,\n * `type`, and `phase` (which must equal the recording); any positive integer where the recording\n * has a number (the output-token limit). Array lengths, object keys, booleans (`stream`, `store`,\n * `include_usage`, `parallel_tool_calls`, `additionalProperties`), the recorded `accept` value,\n * the `content-type` media type, and the query string (exactly, byte for byte; a bare `?` counts as no query) must equal the\n * recording. Route-specific header values (for example Grok's `x-grok-client-version`) are\n * documented by the route that declares them.\n *\n * Runtime-portable Web APIs only; no Node builtins and no SDK imports.\n */\nimport { Predicate } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport {\n  EmulatorErrorAfterChunksFault,\n  EmulatorScriptedError,\n  EmulatorStatusFault,\n  EmulatorTruncateAfterChunksFault,\n  isJsonObject,\n  jsonResponse,\n  makeEmulatorKernel,\n  parseJson,\n  readText,\n  stringField,\n  type EmulatorApi,\n  type KernelLedgerEntry\n} from './emulator-kernel.ts'\nimport {\n  emulatorRouteKey,\n  type EmulatorEvidence,\n  type EmulatorRouteEvidence\n} from './route-evidence.ts'\n\n/** One committed fixture exchange, copied as data. */\nexport type FixtureRecording = {\n  readonly fixtureId: string\n  readonly caseId: string\n  readonly request: {\n    readonly method: string\n    readonly path: string\n    /** The recorded query string (with `?`), or empty. */\n    readonly query: string\n    /** The recorded (non-credential) request headers, lower-case. */\n    readonly headers: Readonly<Record<string, string>>\n    readonly body?: Schema.Json\n  }\n  readonly response: {\n    readonly status: number\n    readonly headers: Readonly<Record<string, string>>\n    /** Whether the fixture recorded network chunks (a stream) or one body. */\n    readonly streamed: boolean\n    /** Network chunks as recorded; a body is one chunk. */\n    readonly chunks: ReadonlyArray<string>\n  }\n}\n\n// Fault and scripted-error statuses on fixture-only routes: errors only (400-599), so no control\n// answers a success that no fixture records. One range check, so a rejection names the range\n// actually accepted (400-599 holds no 204, 205, or 3xx, which the shared schema excludes).\nconst FixtureRouteErrorStatus = Schema.Int.check(Schema.isBetween({ minimum: 400, maximum: 599 }))\n\nconst FixtureRouteStatusFault = Schema.Struct({\n  ...EmulatorStatusFault.fields,\n  status: FixtureRouteErrorStatus\n})\n\nconst FixtureRouteScriptedError = Schema.Struct({\n  error: Schema.Struct({\n    ...EmulatorScriptedError.fields.error.fields,\n    status: FixtureRouteErrorStatus\n  })\n})\n\n/**\n * Faults: the shared kernel kinds only, with `status` limited to 400-599. `status` without a\n * `body` answers an emulator-fault body (`{ error: { type: 'emulator_fault', message } }`), never\n * a guessed provider envelope.\n */\nexport const FixtureRouteFault = Schema.Union([\n  FixtureRouteStatusFault,\n  EmulatorErrorAfterChunksFault,\n  EmulatorTruncateAfterChunksFault\n])\n\nexport type FixtureRouteFault = typeof FixtureRouteFault.Type\n\nexport type FixtureRouteFaultKind = FixtureRouteFault['kind']\n\n/** A scripted replacement body (replaceable-body routes only), shape-checked against the recording. */\nexport type FixtureRouteScriptedBody = { readonly usage: Schema.Json }\n\n/** A scripted turn: an error response, or (replaceable-body routes only) a replacement body. */\nexport type FixtureRouteScriptedTurn = EmulatorScriptedError | FixtureRouteScriptedBody\n\nexport type FixtureRouteLedgerEntry = {\n  /** 1-based arrival order since the last ledger clear or reset. */\n  readonly seq: number\n  readonly method: string\n  readonly path: string\n  /** The request's query string (with `?`), when it has one. */\n  readonly query?: string\n  /** Parsed JSON request body, when it was valid JSON. */\n  readonly body?: Schema.Json\n  readonly model?: string\n  /** Which credential header carried a non-empty value (the value is never recorded). */\n  readonly credentialHeader?: 'authorization' | 'x-api-key'\n  /** Values of the non-credential headers the route records (lower-case names). */\n  readonly headers: Readonly<Record<string, string>>\n  /** The fixture id whose recorded response answered the request. */\n  readonly recording?: string\n  /** Why the request was answered 400 not-emulated. */\n  readonly notEmulated?: string\n  /** Kind of the fault that shaped the response. */\n  readonly fault?: FixtureRouteFaultKind\n  /** Why a matching fault could not take effect (the response was a 500 emulator error). */\n  readonly faultError?: string\n  /** Set when the emulator could not build the planned response (answered 500). */\n  readonly responseError?: string\n  /** Set when a scripted turn answered the request. */\n  readonly scripted?: 'usage' | 'error'\n  /** Evidence of the matched route; `unknown-route` for requests on no route. */\n  readonly evidence: EmulatorEvidence | 'unknown-route'\n  readonly status: number\n  /** Body chunks handed to the transport so far (each produced when pulled). */\n  readonly bodyChunks: number\n}\n\nexport type FixtureRouteEmulator = EmulatorApi<\n  FixtureRouteScriptedTurn,\n  FixtureRouteFault,\n  FixtureRouteLedgerEntry\n>\n\n/** A header every request must carry (non-empty and, when set, accepted by `accepts`). */\nexport type FixtureRouteHeaderRule = {\n  /** Lower-case header name. */\n  readonly name: string\n  /** Keep the value in the ledger (never for credential or account headers). */\n  readonly record: boolean\n  readonly accepts?: (value: string) => boolean\n}\n\nexport type FixtureRouteConfig = {\n  readonly method: 'GET' | 'POST'\n  readonly path: string\n  /** Route evidence manifest; must list exactly this route. */\n  readonly routes: ReadonlyArray<EmulatorRouteEvidence>\n  /** The recordings this route answers from (at least one), tried in order. */\n  readonly recordings: ReadonlyArray<FixtureRecording>\n  /** The credential header the SDK sends: a non-empty Bearer, or a non-empty `x-api-key`. */\n  readonly credential: 'bearer' | 'x-api-key'\n  /** Headers the SDK sends besides the credential and the recorded ones, required in order. */\n  readonly headers: ReadonlyArray<FixtureRouteHeaderRule>\n  /**\n   * Replaceable JSON body (usage routes): enables the scripted `{ usage }` turn, and\n   * `defaultBody` replaces the recorded body; both must have the recorded body's JSON shape.\n   */\n  readonly replaceableBody?: { readonly defaultBody: Schema.Json | undefined }\n  /** Builds the error thrown by the JS API (and at construction) for invalid input. */\n  readonly inputInvalid: (input: 'fault' | 'turn', reason: string) => Error\n}\n\n/** The one answer for everything no fixture records. */\nexport const notEmulatedResponse = (reason: string): Response =>\n  jsonResponse(400, { error: { type: 'not_emulated', message: `Not emulated: ${reason}` } })\n\nconst faultBody = (status: number): Schema.Json => ({\n  error: { type: 'emulator_fault', message: `Emulator fault: status ${status}.` }\n})\n\nconst discriminators: ReadonlyArray<string> = ['model', 'role', 'type', 'phase']\n\nconst kindOf = (value: Schema.Json): string => {\n  if (value === null) return 'null'\n\n  if (Array.isArray(value)) return 'array'\n\n  if (Predicate.isString(value)) return 'string'\n\n  if (Predicate.isNumber(value)) return 'number'\n\n  return Predicate.isBoolean(value) ? 'boolean' : 'object'\n}\n\n/**\n * Where `actual` leaves the recorded request shape (the documented latitude applied), or\n * undefined when it matches.\n */\nexport const recordedRequestMismatch = (\n  actual: Schema.Json | undefined,\n  recorded: Schema.Json,\n  path = '$',\n  key = ''\n): string | undefined => {\n  if (actual === undefined) return `${path} is missing`\n\n  if (isJsonObject(recorded)) {\n    if (!isJsonObject(actual)) return `${path} is not an object`\n\n    const recordedKeys = Object.keys(recorded).sort()\n    const actualKeys = Object.keys(actual).sort()\n\n    const extra = actualKeys.filter(name => !recordedKeys.includes(name))\n    const missing = recordedKeys.filter(name => !actualKeys.includes(name))\n\n    if (extra.length > 0) return `${path} has unrecorded field(s) ${extra.join(', ')}`\n\n    if (missing.length > 0) return `${path} lacks recorded field(s) ${missing.join(', ')}`\n\n    for (const name of recordedKeys) {\n      const field = recorded[name]\n\n      if (field === undefined) continue\n\n      const mismatch = recordedRequestMismatch(actual[name], field, `${path}.${name}`, name)\n\n      if (mismatch !== undefined) return mismatch\n    }\n\n    return undefined\n  }\n\n  if (Array.isArray(recorded)) {\n    if (!Array.isArray(actual)) return `${path} is not an array`\n\n    if (actual.length !== recorded.length) {\n      return `${path} has ${actual.length} item(s), the recording ${recorded.length}`\n    }\n\n    for (const [index, item] of recorded.entries()) {\n      const mismatch = recordedRequestMismatch(actual[index], item, `${path}[${index}]`, key)\n\n      if (mismatch !== undefined) return mismatch\n    }\n\n    return undefined\n  }\n\n  if (kindOf(actual) !== kindOf(recorded)) return `${path} is not a ${kindOf(recorded)}`\n\n  if (Predicate.isString(recorded)) {\n    return discriminators.includes(key) && actual !== recorded\n      ? `${path} is not the recorded ${key}`\n      : undefined\n  }\n\n  if (Predicate.isNumber(recorded)) {\n    return Predicate.isNumber(actual) && Number.isSafeInteger(actual) && actual > 0\n      ? undefined\n      : `${path} is not a positive integer`\n  }\n\n  return actual === recorded ? undefined : `${path} is not the recorded value`\n}\n\n/** Where `actual` leaves the recorded JSON shape (object keys and value kinds), or undefined. */\nexport const recordedBodyMismatch = (\n  actual: Schema.Json,\n  recorded: Schema.Json,\n  path = '$'\n): string | undefined => {\n  if (isJsonObject(recorded)) {\n    if (!isJsonObject(actual)) return `${path} is not an object`\n\n    const recordedKeys = Object.keys(recorded).sort()\n\n    if (JSON.stringify(Object.keys(actual).sort()) !== JSON.stringify(recordedKeys)) {\n      return `${path} does not have the recorded fields ${recordedKeys.join(', ')}`\n    }\n\n    for (const name of recordedKeys) {\n      const actualField = actual[name]\n      const recordedField = recorded[name]\n\n      if (actualField === undefined || recordedField === undefined) continue\n\n      const mismatch = recordedBodyMismatch(actualField, recordedField, `${path}.${name}`)\n\n      if (mismatch !== undefined) return mismatch\n    }\n\n    return undefined\n  }\n\n  if (Array.isArray(recorded)) {\n    if (!Array.isArray(actual) || actual.length !== recorded.length) {\n      return `${path} is not a ${recorded.length}-item array`\n    }\n\n    for (const [index, item] of recorded.entries()) {\n      const actualItem = actual[index]\n\n      if (actualItem === undefined) return `${path}[${index}] is missing`\n\n      const mismatch = recordedBodyMismatch(actualItem, item, `${path}[${index}]`)\n\n      if (mismatch !== undefined) return mismatch\n    }\n\n    return undefined\n  }\n\n  return kindOf(actual) === kindOf(recorded) ? undefined : `${path} is not a ${kindOf(recorded)}`\n}\n\n// A non-empty bearer credential. The value is never checked or stored.\nconst bearerPattern = /^bearer\\s+\\S+/i\n\nconst mediaType = (value: string | null): string | undefined =>\n  value?.split(';')[0]?.trim().toLowerCase()\n\ntype MutableLedgerEntry = KernelLedgerEntry<FixtureRouteFaultKind> & {\n  query?: string\n  body?: Schema.Json\n  model?: string\n  credentialHeader?: 'authorization' | 'x-api-key'\n  headers: Record<string, string>\n  recording?: string\n  notEmulated?: string\n  scripted?: 'usage' | 'error'\n}\n\n/**\n * Create a fixture-only route. Each call has independent ledger, fault, and script state. Throws\n * `inputInvalid('turn', ...)` when a replaceable body's `defaultBody` does not have the recorded\n * shape.\n *\n * Precedence per request: the credential, the header rules in order, the recorded headers and\n * query, the recorded request shape (one of `recordings`); a request failing any of these answers\n * 400 not-emulated and uses up no fault or turn. Then the first matching fault if it is a `status`\n * fault, then the next scripted turn, then the recorded response; a first matching body fault then\n * shapes the body.\n */\nexport const makeFixtureRouteEmulator = (config: FixtureRouteConfig): FixtureRouteEmulator => {\n  const [primary] = config.recordings\n\n  if (primary === undefined) {\n    throw config.inputInvalid('turn', 'a fixture route needs at least one recording')\n  }\n\n  const recordedBody =\n    config.replaceableBody === undefined ? undefined : parseJson(primary.response.chunks.join(''))\n\n  const bodyMismatch = (value: Schema.Json): string | undefined =>\n    recordedBody === undefined\n      ? 'this route has no replaceable body'\n      : recordedBodyMismatch(value, recordedBody)\n\n  const defaultBody = config.replaceableBody?.defaultBody\n\n  if (defaultBody !== undefined) {\n    const mismatch = bodyMismatch(defaultBody)\n\n    if (mismatch !== undefined) {\n      throw config.inputInvalid(\n        'turn',\n        `the default body must have the recorded shape: ${mismatch}`\n      )\n    }\n  }\n\n  const ScriptedBody = Schema.Struct({\n    usage: Schema.Json.check(\n      Schema.makeFilter(value => {\n        const mismatch = bodyMismatch(value)\n\n        return mismatch === undefined ? true : `must have the recorded shape: ${mismatch}`\n      })\n    )\n  })\n\n  const turnSchema: Schema.Decoder<FixtureRouteScriptedTurn> =\n    config.replaceableBody === undefined\n      ? FixtureRouteScriptedError\n      : Schema.Union([FixtureRouteScriptedError, ScriptedBody])\n\n  const models = config.recordings.flatMap(recording => {\n    const model = stringField(recording.request.body, 'model')\n\n    return model === undefined ? [] : [model]\n  })\n\n  const kernel = makeEmulatorKernel({\n    routes: config.routes,\n    faultSchema: FixtureRouteFault,\n    turnSchema,\n    newEntry: (base): MutableLedgerEntry => ({ ...base, headers: {} }),\n    snapshotEntry: (entry): FixtureRouteLedgerEntry => ({\n      ...entry,\n      headers: { ...entry.headers }\n    }),\n    unknownRoute: entry => {\n      entry.notEmulated = 'no recorded route for this method and path'\n\n      return notEmulatedResponse(entry.notEmulated)\n    },\n    stateFields: () => ({ knownModels: [...new Set(models)] }),\n    inputInvalid: config.inputInvalid\n  })\n\n  const recordingMismatch = (\n    recording: FixtureRecording,\n    request: Request,\n    url: URL,\n    text: string,\n    json: Schema.Json | undefined\n  ): string | undefined => {\n    for (const [name, value] of Object.entries(recording.request.headers)) {\n      const actual = request.headers.get(name)\n\n      const matches =\n        name === 'content-type' ? mediaType(actual) === mediaType(value) : actual === value\n\n      if (!matches) return `the ${name} header is not the recorded ${value}`\n    }\n\n    if (url.search !== recording.request.query) {\n      return recording.request.query.length === 0\n        ? 'the recording has no query parameters'\n        : `the query is not the recorded ${recording.request.query}`\n    }\n\n    if (recording.request.body === undefined) {\n      return text.length === 0 ? undefined : 'the recording has no request body'\n    }\n\n    if (json === undefined) return 'the request body is not JSON'\n\n    return recordedRequestMismatch(json, recording.request.body)\n  }\n\n  const admit = async (\n    request: Request,\n    entry: MutableLedgerEntry\n  ): Promise<{ readonly recording: FixtureRecording } | { readonly reason: string }> => {\n    const credential =\n      config.credential === 'bearer'\n        ? bearerPattern.test(request.headers.get('authorization') ?? '')\n        : (request.headers.get('x-api-key') ?? '').trim().length > 0\n\n    if (!credential) {\n      return {\n        reason:\n          config.credential === 'bearer'\n            ? 'a non-empty Authorization: Bearer credential is required'\n            : 'a non-empty x-api-key credential is required'\n      }\n    }\n\n    entry.credentialHeader = config.credential === 'bearer' ? 'authorization' : 'x-api-key'\n\n    for (const rule of config.headers) {\n      const value = (request.headers.get(rule.name) ?? '').trim()\n\n      if (value.length === 0 || (rule.accepts !== undefined && !rule.accepts(value))) {\n        return { reason: `the ${rule.name} header is missing or not the one the SDK sends` }\n      }\n    }\n\n    const url = new URL(request.url)\n    const text = (await readText(request)) ?? ''\n\n    const json = config.method === 'POST' ? parseJson(text) : undefined\n\n    if (json !== undefined) entry.body = json\n\n    const model = stringField(json, 'model')\n\n    if (model !== undefined) entry.model = model\n\n    const reasons: Array<string> = []\n\n    for (const recording of config.recordings) {\n      const reason = recordingMismatch(recording, request, url, text, json)\n\n      if (reason === undefined) return { recording }\n\n      reasons.push(config.recordings.length === 1 ? reason : `${recording.caseId}: ${reason}`)\n    }\n\n    return { reason: reasons.join('; ') }\n  }\n\n  const handle = async (\n    request: Request,\n    entry: MutableLedgerEntry,\n    path: string\n  ): Promise<Response> => {\n    for (const rule of config.headers) {\n      const value = request.headers.get(rule.name)\n\n      if (rule.record && value !== null) entry.headers[rule.name] = value\n    }\n\n    const search = new URL(request.url).search\n\n    if (search.length > 0) entry.query = search\n\n    const admitted = await admit(request, entry)\n\n    if ('reason' in admitted) {\n      entry.notEmulated = admitted.reason\n      entry.status = 400\n\n      return notEmulatedResponse(admitted.reason)\n    }\n\n    const recording = admitted.recording\n    const fault = kernel.takeFault(path, entry.model)\n\n    if (fault !== undefined && fault.fault.kind === 'status') {\n      return kernel.respondWithStatusFault(entry, fault, fault.fault, faultBody)\n    }\n\n    const turn = kernel.nextTurn()\n\n    if (turn !== undefined && 'error' in turn) {\n      entry.scripted = 'error'\n\n      return kernel.respondWithScriptedError(entry, turn.error, fault)\n    }\n\n    const body = turn === undefined ? defaultBody : turn.usage\n\n    if (turn !== undefined) entry.scripted = 'usage'\n\n    entry.recording = recording.fixtureId\n\n    return kernel.respondWithBody(\n      entry,\n      recording.response.status,\n      { ...recording.response.headers },\n      body === undefined ? recording.response.chunks : [JSON.stringify(body)],\n      fault\n    )\n  }\n\n  // Every manifest route maps to its own handler; construction throws `EmulatorRouteUnmapped`\n  // when a manifest route has no handler (or a handler has no manifest route).\n  return kernel.serve(new Map([[emulatorRouteKey(config.method, config.path), handle]]))\n}\n"],"mappings":"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"}

package/dist/fortnox/api.d.mts

@@ -0,0 +1,92 @@
+import { EmulatorRouteEvidence } from "../route-evidence.mjs";
+import { FortnoxEmulatorState } from "./state.mjs";
+import * as Schema from "effect/Schema";
+import { Hono } from "@emulators/core";
+
+//#region src/fortnox/api.d.ts
+/**
+ * Drill knobs: each flips one observed quirk to the documented-but-wrong behavior, ONLY to prove
+ * that the conformance cases catch a disagreement. Defaults follow the observed behavior.
+ */
+type FortnoxEmulatorQuirks = {
+  /** `false`: a positionally matched row that omits `Discount`/`DiscountType` resets them. */readonly stickyRowDiscount?: boolean; /** `true`: a customer update with `""` clears the stored string instead of keeping it. */
+  readonly emptyStringClears?: boolean; /** `true`: `unpaid`/`unpaidoverdue`/`fullypaid` also match unbooked invoices. */
+  readonly paymentFiltersIncludeUnbooked?: boolean;
+};
+type FortnoxApiEnv = {
+  /** Clock in epoch milliseconds (the `unpaidoverdue` "today", new invoice dates, the outbox). */readonly now: () => number; /** Origin used in `@url` links, for example `https://api.fortnox.se`. */
+  readonly linkOrigin: string;
+  readonly quirks: Required<FortnoxEmulatorQuirks>;
+};
+/**
+ * `ErrorInformation` codes the emulator answers with. The two customer-not-found codes are copied
+ * from the rejection fixture; the `2999xxx` codes are synthetic emulator codes.
+ */
+declare const fortnoxEmulatorErrorCodes: {
+  readonly customerNotFound: 2000204;
+  readonly invoiceCustomerNotFound: 2000433;
+  readonly unauthorized: 2999001;
+  readonly invalidBody: 2999002;
+  readonly invalidField: 2999003;
+  readonly readOnlyField: 2999004;
+  readonly notEditable: 2999005;
+  readonly invoiceNotFound: 2999006;
+  readonly unknownRoute: 2999007;
+  readonly unsupportedQuery: 2999008;
+  readonly rateLimited: 2999009;
+  readonly upstreamError: 2999010;
+};
+/** Fortnox API base path. */
+declare const fortnoxEmulatorBasePath = "/3";
+/** A Fortnox `ErrorInformation` response with the lowercase fields of the rejection fixture. */
+declare const errorInformation: (status: number, code: number, message: string) => Response;
+type RouteRequest = {
+  readonly params: Readonly<Record<string, string>>;
+  readonly query: URLSearchParams; /** Parsed JSON body; `undefined` when absent or not JSON. */
+  readonly body: Schema.Json | undefined;
+};
+type RouteHandler = (state: FortnoxEmulatorState, request: RouteRequest, env: FortnoxApiEnv) => Response;
+type FortnoxApiRoute = EmulatorRouteEvidence & {
+  /**
+   * Query parameters the route emulates; any other key answers 400 before the handler runs, so
+   * a rejected request never writes. Empty by default.
+   */
+  readonly queryKeys: ReadonlyArray<string>;
+  readonly handler: RouteHandler;
+};
+/** The route table: evidence plus handler. `fortnoxEmulatorRoutes` is its evidence part. */
+declare const fortnoxApiRoutes: ReadonlyArray<FortnoxApiRoute>;
+/** One observed Fortnox quirk the emulator implements, and the case that claims it. */
+type FortnoxEmulatorQuirk = {
+  readonly id: string; /** `METHOD path` of the route that implements it. */
+  readonly route: string; /** The conformance case whose claim it follows; `undefined` when no case covers it yet. */
+  readonly caseId: string | undefined; /** The drill knob that flips it, if any. */
+  readonly knob: keyof FortnoxEmulatorQuirks | undefined;
+  readonly summary: string;
+};
+/** The observed quirks, each tied to its conformance case id. */
+declare const fortnoxEmulatorQuirks: ReadonlyArray<FortnoxEmulatorQuirk>;
+/** The route answering `method` + concrete `path`, or `undefined` (fail closed). */
+declare const matchFortnoxRoute: (method: string, path: string) => FortnoxApiRoute | undefined;
+/** Parsed JSON, or `undefined` for invalid JSON. */
+declare const parseJsonText: (text: string) => Schema.Json | undefined;
+/**
+ * The wrapper's fault decision for the core request of job `jobId` (its `emulatorJobHeader`),
+ * asked only once the route would answer successfully: `true` when a fault answers instead (it is
+ * used up, and the wrapper sends its answer), `false` when none applies.
+ */
+type FortnoxFaultDecision = (jobId: string | undefined) => boolean;
+/**
+ * Register every route of the table on the core app, over the generation's state. Each request is
+ * planned, then faulted, then committed: the handler runs on a draft of the state (handlers replace
+ * whole lists and counters, never edit them in place, so a shallow copy keeps every write off the
+ * state); a refusal (any answer that is not 2xx) is sent as is and uses up no fault; a successful
+ * answer asks `decideFault`, and only an unfaulted one commits the draft. The three steps run
+ * synchronously together, so no other request interleaves. A handler that throws answers
+ * `handlerFailedResponse()` (nothing written), which the wrapper turns into its `ErrorInformation`
+ * 500 with `responseError` in the ledger.
+ */
+declare const registerFortnoxApi: (app: Hono, state: FortnoxEmulatorState, env: FortnoxApiEnv, decideFault: FortnoxFaultDecision) => void;
+//#endregion
+export { FortnoxApiEnv, FortnoxEmulatorQuirk, FortnoxEmulatorQuirks, FortnoxFaultDecision, errorInformation, fortnoxApiRoutes, fortnoxEmulatorBasePath, fortnoxEmulatorErrorCodes, fortnoxEmulatorQuirks, matchFortnoxRoute, parseJsonText, registerFortnoxApi };
+//# sourceMappingURL=api.d.mts.map