@yolk-sdk/emulators 0.1.0-canary.96

package/dist/codex.d.mts

@@ -0,0 +1,265 @@
+import { EmulatorEvidence, EmulatorRouteEvidence, emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { EmulatorCoverage, EmulatorFaultMatch, EmulatorFaultState, EmulatorRouteCoverage, EmulatorScriptedError } from "./emulator-kernel.mjs";
+import { SubscriptionUsageEmulator, SubscriptionUsageFault, SubscriptionUsageLedgerEntry, SubscriptionUsageScriptedTurn } from "./subscription-usage.mjs";
+import { ResponsesEmulator, ResponsesErrorEventFault, ResponsesFault, ResponsesFaultKind, ResponsesLedgerEntry, ResponsesScriptedFunctionCall, ResponsesScriptedResponse, ResponsesScriptedTurn, ResponsesScriptedUsage, ResponsesStreamError } from "./responses.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/codex.d.ts
+declare const codexResponsesPath = "/backend-api/codex/responses";
+/** The Codex subscription-usage path (`openAiCodexSubscriptionUsageUrl` in the SDK). */
+declare const codexSubscriptionUsagePath = "/backend-api/wham/usage";
+/**
+ * Route evidence manifest of the Codex subscription-usage route (served by the same fetch handler
+ * as the Responses route, with its own ledger and coverage). Synthetic, unverified.
+ */
+declare const codexSubscriptionUsageEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence>;
+/**
+ * The recorded Codex usage body (the synthetic `openai.codex.usage.snapshot` fixture, copied as
+ * data): `rate_limit.primary_window` and `secondary_window` as
+ * `{ used_percent, limit_window_seconds, reset_after_seconds, reset_at }`.
+ */
+declare const codexSubscriptionUsageDefault: Schema.Json;
+/** Synthetic-safe default model ids, including the Codex conformance defaults. */
+declare const codexEmulatorDefaultModels: ReadonlyArray<string>;
+/**
+ * Route evidence manifest: every emulated Codex route and the conformance cases whose (currently
+ * synthetic, unverified) wire shapes it follows.
+ */
+declare const codexEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence>;
+/** Optional fault filter; an omitted field matches every request. `path` ending in `*` is a prefix. */
+declare const CodexFaultMatch: Schema.Struct<{
+  readonly path: Schema.optionalKey<Schema.String>;
+  readonly model: Schema.optionalKey<Schema.String>;
+}>;
+type CodexFaultMatch = typeof EmulatorFaultMatch.Type;
+/** A mid-stream Responses error (`{ code, message }`). */
+declare const CodexStreamError: Schema.Struct<{
+  readonly code: Schema.NonEmptyString;
+  readonly message: Schema.String;
+}>;
+type CodexStreamError = ResponsesStreamError;
+/** A mid-stream `error` or `response.failed` event fault, streamed responses only. */
+declare const CodexErrorEventFault: 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-event-after-chunks">;
+  readonly chunks: Schema.Int;
+  readonly event: Schema.optionalKey<Schema.Literals<readonly ["error", "response.failed"]>>;
+  readonly error: Schema.optionalKey<Schema.Struct<{
+    readonly code: Schema.NonEmptyString;
+    readonly message: Schema.String;
+  }>>;
+}>;
+type CodexErrorEventFault = typeof ResponsesErrorEventFault.Type;
+/**
+ * Wire faults:
+ *
+ * - `status`: answer with this status, headers, and body (for example 429 with `retry-after`).
+ *   The body defaults to the OpenAI error envelope for the status.
+ * - `error-after-chunks`: send N body chunks, then error the body stream (a dropped connection).
+ * - `truncate-after-chunks`: send N body chunks, then close cleanly (no `response.completed`).
+ * - `error-event-after-chunks`: send N SSE events, then one `error` (default) or
+ *   `response.failed` event and close.
+ *
+ * Statuses that cannot carry a body and redirects are rejected, as are invalid headers and
+ * `location`. A fault that cannot take effect answers 500 and is not consumed.
+ */
+declare const CodexFault: Schema.Union<readonly [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<"status">;
+  readonly status: Schema.Int;
+  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;
+}>, 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-event-after-chunks">;
+  readonly chunks: Schema.Int;
+  readonly event: Schema.optionalKey<Schema.Literals<readonly ["error", "response.failed"]>>;
+  readonly error: Schema.optionalKey<Schema.Struct<{
+    readonly code: Schema.NonEmptyString;
+    readonly message: Schema.String;
+  }>>;
+}>]>;
+type CodexFault = ResponsesFault;
+type CodexFaultKind = ResponsesFaultKind;
+/** Usage for a scripted turn (sent in `response.completed` or the JSON body). */
+declare const CodexScriptedUsage: Schema.Struct<{
+  readonly inputTokens: Schema.Int;
+  readonly outputTokens: Schema.Int;
+  readonly reasoningTokens: Schema.optionalKey<Schema.Int>;
+}>;
+type CodexScriptedUsage = ResponsesScriptedUsage;
+/** One scripted `function_call` item; its arguments stream as these fragments. */
+declare const CodexScriptedFunctionCall: Schema.Struct<{
+  readonly name: Schema.NonEmptyString;
+  readonly argumentFragments: Schema.$Array<Schema.String>;
+  readonly callId: Schema.optionalKey<Schema.NonEmptyString>;
+}>;
+type CodexScriptedFunctionCall = ResponsesScriptedFunctionCall;
+/**
+ * A scripted response: `reasoning` (summary fragments), `text`, `functionCalls`, `order`,
+ * `usage` (`null` drops it), and `format` (`sse` or `json`, default: the request's `stream`).
+ */
+declare const CodexScriptedResponse: Schema.Struct<{
+  readonly reasoning: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly text: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly functionCalls: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly argumentFragments: Schema.$Array<Schema.String>;
+    readonly callId: Schema.optionalKey<Schema.NonEmptyString>;
+  }>>>;
+  readonly order: Schema.optionalKey<Schema.Literals<readonly ["reasoning-first", "text-first"]>>;
+  readonly usage: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+    readonly inputTokens: Schema.Int;
+    readonly outputTokens: Schema.Int;
+    readonly reasoningTokens: Schema.optionalKey<Schema.Int>;
+  }>>>;
+  readonly format: Schema.optionalKey<Schema.Literals<readonly ["sse", "json"]>>;
+}>;
+type CodexScriptedResponse = ResponsesScriptedResponse;
+/** A scripted error response: status, body (a string is sent as is), and optional headers. */
+declare const CodexScriptedError: Schema.Struct<{
+  readonly error: Schema.Struct<{
+    readonly status: Schema.Int;
+    readonly body: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+}>;
+type CodexScriptedError = typeof EmulatorScriptedError.Type;
+/** A turn queued for the next Codex request. */
+declare const CodexScriptedTurn: Schema.Union<readonly [Schema.Struct<{
+  readonly error: Schema.Struct<{
+    readonly status: Schema.Int;
+    readonly body: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+  }>;
+}>, Schema.Struct<{
+  readonly reasoning: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly text: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly functionCalls: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly argumentFragments: Schema.$Array<Schema.String>;
+    readonly callId: Schema.optionalKey<Schema.NonEmptyString>;
+  }>>>;
+  readonly order: Schema.optionalKey<Schema.Literals<readonly ["reasoning-first", "text-first"]>>;
+  readonly usage: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+    readonly inputTokens: Schema.Int;
+    readonly outputTokens: Schema.Int;
+    readonly reasoningTokens: Schema.optionalKey<Schema.Int>;
+  }>>>;
+  readonly format: Schema.optionalKey<Schema.Literals<readonly ["sse", "json"]>>;
+}>]>;
+type CodexScriptedTurn = ResponsesScriptedTurn;
+declare const CodexEmulatorInputInvalid_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "CodexEmulatorInputInvalid";
+} & Readonly<A>;
+/** Thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input; a programmer error. */
+declare class CodexEmulatorInputInvalid extends CodexEmulatorInputInvalid_base<{
+  readonly input: 'fault' | 'turn';
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+type CodexLedgerEntry = ResponsesLedgerEntry;
+type CodexFaultState = EmulatorFaultState<CodexFault>;
+type CodexRouteCoverage = EmulatorRouteCoverage;
+type CodexCoverage = EmulatorCoverage;
+/** A usage-route fault (`status`, `error-after-chunks`, `truncate-after-chunks`). */
+declare const CodexUsageFault: 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 CodexUsageFault = SubscriptionUsageFault;
+/** A usage turn: `{ usage }` (a body with the recorded JSON shape) or `{ error }`. */
+type CodexUsageScriptedTurn = SubscriptionUsageScriptedTurn;
+type CodexUsageLedgerEntry = SubscriptionUsageLedgerEntry;
+type CodexUsageEmulator = SubscriptionUsageEmulator;
+type CodexEmulatorOptions = {
+  /** Model ids that exist. Defaults to `codexEmulatorDefaultModels`. */readonly knownModels?: ReadonlyArray<string>;
+  /**
+   * Replacement usage-route body; must have the recorded JSON shape (same keys and value kinds).
+   * Defaults to the recorded body (`codexSubscriptionUsageDefault`).
+   */
+  readonly subscriptionUsage?: Schema.Json;
+};
+/** The Responses emulator, plus `usage`: the subscription-usage route's own emulator API. */
+type CodexEmulator = ResponsesEmulator & {
+  readonly usage: CodexUsageEmulator;
+};
+/**
+ * Create a Codex Responses emulator. Each call has independent ledger, fault, and script state.
+ *
+ * Without a script, `POST /backend-api/codex/responses` answers a known model with synthetic
+ * output: `stream: true` streams `response.created`, `response.in_progress`, the output items
+ * (`response.output_item.added`, their parts and deltas, `response.output_item.done`), and
+ * `response.completed` with usage; `stream: false` returns one `response` JSON body. A request
+ * whose `reasoning` asks for a `summary` (the Codex provider always does) gets a reasoning item
+ * first. A request with function `tools` gets one `function_call` item whose arguments are
+ * synthesized from the tool's JSON Schema and streamed as `response.function_call_arguments.delta`
+ * fragments; `tool_choice: { type: 'function', name }` picks that tool (otherwise the first) and
+ * `tool_choice: 'none'` answers with text. Unknown models get 400 `model_not_found`; a request
+ * without a bearer credential gets 401 `invalid_api_key`; `max_output_tokens` gets 400
+ * `unsupported_parameter`; unknown routes get a 404 envelope. Not enforced: `store: false`,
+ * `stream: true`, `instructions`, `originator`, and `ChatGPT-Account-Id`.
+ *
+ * `GET /backend-api/wham/usage` is fixture-only: a request with a non-empty bearer credential and
+ * a non-empty `ChatGPT-Account-Id` (neither checked or recorded), `accept: application/json`, and
+ * no query gets the recorded body (`codexSubscriptionUsageDefault`, or a same-shaped
+ * `options.subscriptionUsage` / scripted `{ usage }`); anything else answers 400 not-emulated.
+ * Its ledger, faults, turns, and coverage are `emulator.usage` (control plane
+ * `/_emulate/usage/*`); `reset()` and `POST /_emulate/reset` reset both routes.
+ */
+declare const makeCodexEmulator: (options?: CodexEmulatorOptions) => CodexEmulator;
+//#endregion
+export { CodexCoverage, CodexEmulator, CodexEmulatorInputInvalid, CodexEmulatorOptions, CodexErrorEventFault, CodexFault, CodexFaultKind, CodexFaultMatch, CodexFaultState, CodexLedgerEntry, CodexRouteCoverage, CodexScriptedError, CodexScriptedFunctionCall, CodexScriptedResponse, CodexScriptedTurn, CodexScriptedUsage, CodexStreamError, CodexUsageEmulator, CodexUsageFault, CodexUsageLedgerEntry, CodexUsageScriptedTurn, type EmulatorEvidence, type EmulatorRouteEvidence, codexEmulatorDefaultModels, codexEmulatorRoutes, codexResponsesPath, codexSubscriptionUsageDefault, codexSubscriptionUsageEmulatorRoutes, codexSubscriptionUsagePath, emulatorEvidenceHeader, makeCodexEmulator };
+//# sourceMappingURL=codex.d.mts.map

package/dist/codex.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.d.mts","names":[],"sources":["../src/codex.ts"],"mappings":";;;;;;;cAgEa,kBAAA;;cAGA,0BAAA;AAHkB;AAG/B;;;AAH+B,cASlB,oCAAA,EAAsC,aAAa,CAAC,qBAAA;AAN1B;AAMvC;;;;AANuC,cAuB1B,6BAAA,EAA+B,MAAA,CAAO,IAA6C;AAAhG;AAAA,cAGa,0BAAA,EAA4B,aAAa;;;AAH0C;AAGhG;cAMa,mBAAA,EAAqB,aAAa,CAAC,qBAAA;;cAkBnC,eAAA,EAAe,MAAA,CAAA,MAAA;EAAA;;;KAEhB,eAAA,UAAyB,kBAAA,CAAmB,IAAI;;cAG/C,gBAAA,EAAgB,MAAA,CAAA,MAAA;EAAA;;;KAEjB,gBAAA,GAAmB,oBAAoB;;cAGtC,oBAAA,EAAoB,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;KAErB,oBAAA,UAA8B,wBAAA,CAAyB,IAAI;;;;;AAVvE;;;;AAA4D;AAG5D;;;;cAsBa,UAAA,EAAU,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEX,UAAA,GAAa,cAAc;AAAA,KAE3B,cAAA,GAAiB,kBAAkB;;cAGlC,kBAAA,EAAkB,MAAA,CAAA,MAAA;EAAA;;;;KAEnB,kBAAA,GAAqB,sBAAsB;;cAG1C,yBAAA,EAAyB,MAAA,CAAA,MAAA;EAAA;;;;KAE1B,yBAAA,GAA4B,6BAA6B;;;;;cAMxD,qBAAA,EAAqB,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;KAEtB,qBAAA,GAAwB,yBAAyB;;cAGhD,kBAAA,EAAkB,MAAA,CAAA,MAAA;EAAA;;;;;;KAEnB,kBAAA,UAA4B,qBAAA,CAAsB,IAAI;;cAGrD,iBAAA,EAAiB,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;KAElB,iBAAA,GAAoB,qBAAqB;AAAA,cAAA,8BAAA;;;;cAGxC,yBAAA,SAAkC,8BAAA;EAAA,SACpC,KAAA;EAAA,SACA,MAAA;AAAA;EAAA,IAEI,OAAA,CAAA;AAAA;AAAA,KAKH,gBAAA,GAAmB,oBAAoB;AAAA,KAEvC,eAAA,GAAkB,kBAAkB,CAAC,UAAA;AAAA,KAErC,kBAAA,GAAqB,qBAAqB;AAAA,KAE1C,aAAA,GAAgB,gBAAgB;;cAG/B,eAAA,EAAe,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;KAEhB,eAAA,GAAkB,sBAAsB;;KAGxC,sBAAA,GAAyB,6BAA6B;AAAA,KAEtD,qBAAA,GAAwB,4BAA4B;AAAA,KAEpD,kBAAA,GAAqB,yBAAyB;AAAA,KAE9C,oBAAA;EAhEW,+EAkEZ,WAAA,GAAc,aAAA;;;;;WAKd,iBAAA,GAAoB,MAAA,CAAO,IAAI;AAAA;;KAI9B,aAAA,GAAgB,iBAAA;EAAA,SAA+B,KAAA,EAAO,kBAAkB;AAAA;;;;;;;;;;;;;;;;;;;;;;;;cAkCvE,iBAAA,GAAqB,OAAA,GAAS,oBAAA,KAA4B,aAKpE"}

package/dist/codex.mjs

@@ -0,0 +1,199 @@
+import { emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { EmulatorFaultMatch, EmulatorScriptedError } from "./emulator-kernel.mjs";
+import { withSubscriptionUsage } from "./emulator-compose.mjs";
+import { SubscriptionUsageFault, makeSubscriptionUsageEmulator, recordedUsageBody } from "./subscription-usage.mjs";
+import { codexUsageRecording } from "./subscription-usage-recordings.mjs";
+import { ResponsesErrorEventFault, ResponsesFault, ResponsesScriptedFunctionCall, ResponsesScriptedResponse, ResponsesScriptedTurn, ResponsesScriptedUsage, ResponsesStreamError, makeResponsesEmulator } from "./responses.mjs";
+import { Data } from "effect";
+//#region src/codex.ts
+/**
+* OpenAI Codex (ChatGPT subscription) Responses emulator: a plain fetch handler for
+* `POST /backend-api/codex/responses` (origin `https://chatgpt.com`), with scripted turns, wire
+* faults, a request ledger, and an `/_emulate/*` control plane.
+*
+* It never imports SDK code: its wire shapes follow the synthetic Codex Responses conformance
+* fixtures (Responses SSE with typed `event:` names, the `response` JSON body, and the
+* `{ error: { message, type, param, code } }` envelope) and are linked to those conformance case
+* ids in `codexEmulatorRoutes`. The Responses machinery lives in the internal `responses.ts` core
+* and is shared with the xAI Grok emulator.
+*
+* Requests authenticate with a non-empty `Authorization: Bearer` credential (a ChatGPT OAuth
+* access token), never checked or stored. The ChatGPT Codex endpoint does not take an output
+* limit, so a request with `max_output_tokens` answers 400 `unsupported_parameter`. The
+* `originator` header is recorded in the ledger; `ChatGPT-Account-Id` is neither required nor
+* recorded.
+*
+* The same fetch handler also answers the Codex subscription-usage route
+* (`GET /backend-api/wham/usage`, `emulator.usage`) with its own manifest
+* (`codexSubscriptionUsageEmulatorRoutes`), ledger, faults, and turns; see `makeCodexEmulator`.
+*
+* Runtime-portable Web APIs only (`Request`, `Response`, `ReadableStream`, `TextEncoder`, `URL`);
+* no Effect runtime is required to use it.
+*
+* @experimental
+*/
+const codexResponsesPath = "/backend-api/codex/responses";
+/** The Codex subscription-usage path (`openAiCodexSubscriptionUsageUrl` in the SDK). */
+const codexSubscriptionUsagePath = "/backend-api/wham/usage";
+/**
+* Route evidence manifest of the Codex subscription-usage route (served by the same fetch handler
+* as the Responses route, with its own ledger and coverage). Synthetic, unverified.
+*/
+const codexSubscriptionUsageEmulatorRoutes = [{
+	method: "GET",
+	path: codexSubscriptionUsagePath,
+	kind: "provider",
+	write: false,
+	caseIds: ["openai.codex.usage.snapshot"],
+	evidence: "unverified",
+	observedAt: void 0
+}];
+/**
+* The recorded Codex usage body (the synthetic `openai.codex.usage.snapshot` fixture, copied as
+* data): `rate_limit.primary_window` and `secondary_window` as
+* `{ used_percent, limit_window_seconds, reset_after_seconds, reset_at }`.
+*/
+const codexSubscriptionUsageDefault = recordedUsageBody(codexUsageRecording);
+/** Synthetic-safe default model ids, including the Codex conformance defaults. */
+const codexEmulatorDefaultModels = ["gpt-5.4", "gpt-5.5"];
+/**
+* Route evidence manifest: every emulated Codex route and the conformance cases whose (currently
+* synthetic, unverified) wire shapes it follows.
+*/
+const codexEmulatorRoutes = [{
+	method: "POST",
+	path: codexResponsesPath,
+	kind: "provider",
+	write: false,
+	caseIds: [
+		"openai.codex.stream.plain-text",
+		"openai.codex.stream.function-call-arguments",
+		"openai.codex.stream.error-envelope",
+		"openai.codex.stream.terminal-event"
+	],
+	evidence: "unverified",
+	observedAt: void 0
+}];
+/** Optional fault filter; an omitted field matches every request. `path` ending in `*` is a prefix. */
+const CodexFaultMatch = EmulatorFaultMatch;
+/** A mid-stream Responses error (`{ code, message }`). */
+const CodexStreamError = ResponsesStreamError;
+/** A mid-stream `error` or `response.failed` event fault, streamed responses only. */
+const CodexErrorEventFault = ResponsesErrorEventFault;
+/**
+* Wire faults:
+*
+* - `status`: answer with this status, headers, and body (for example 429 with `retry-after`).
+*   The body defaults to the OpenAI error envelope for the status.
+* - `error-after-chunks`: send N body chunks, then error the body stream (a dropped connection).
+* - `truncate-after-chunks`: send N body chunks, then close cleanly (no `response.completed`).
+* - `error-event-after-chunks`: send N SSE events, then one `error` (default) or
+*   `response.failed` event and close.
+*
+* Statuses that cannot carry a body and redirects are rejected, as are invalid headers and
+* `location`. A fault that cannot take effect answers 500 and is not consumed.
+*/
+const CodexFault = ResponsesFault;
+/** Usage for a scripted turn (sent in `response.completed` or the JSON body). */
+const CodexScriptedUsage = ResponsesScriptedUsage;
+/** One scripted `function_call` item; its arguments stream as these fragments. */
+const CodexScriptedFunctionCall = ResponsesScriptedFunctionCall;
+/**
+* A scripted response: `reasoning` (summary fragments), `text`, `functionCalls`, `order`,
+* `usage` (`null` drops it), and `format` (`sse` or `json`, default: the request's `stream`).
+*/
+const CodexScriptedResponse = ResponsesScriptedResponse;
+/** A scripted error response: status, body (a string is sent as is), and optional headers. */
+const CodexScriptedError = EmulatorScriptedError;
+/** A turn queued for the next Codex request. */
+const CodexScriptedTurn = ResponsesScriptedTurn;
+/** Thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input; a programmer error. */
+var CodexEmulatorInputInvalid = class extends Data.TaggedError("CodexEmulatorInputInvalid") {
+	get message() {
+		return `Invalid Codex emulator ${this.input}: ${this.reason}`;
+	}
+};
+/** A usage-route fault (`status`, `error-after-chunks`, `truncate-after-chunks`). */
+const CodexUsageFault = SubscriptionUsageFault;
+const openAiErrorEnvelope = (error) => ({ error: {
+	message: error.message,
+	type: error.type,
+	param: error.param ?? null,
+	code: error.code
+} });
+/**
+* Create a Codex Responses emulator. Each call has independent ledger, fault, and script state.
+*
+* Without a script, `POST /backend-api/codex/responses` answers a known model with synthetic
+* output: `stream: true` streams `response.created`, `response.in_progress`, the output items
+* (`response.output_item.added`, their parts and deltas, `response.output_item.done`), and
+* `response.completed` with usage; `stream: false` returns one `response` JSON body. A request
+* whose `reasoning` asks for a `summary` (the Codex provider always does) gets a reasoning item
+* first. A request with function `tools` gets one `function_call` item whose arguments are
+* synthesized from the tool's JSON Schema and streamed as `response.function_call_arguments.delta`
+* fragments; `tool_choice: { type: 'function', name }` picks that tool (otherwise the first) and
+* `tool_choice: 'none'` answers with text. Unknown models get 400 `model_not_found`; a request
+* without a bearer credential gets 401 `invalid_api_key`; `max_output_tokens` gets 400
+* `unsupported_parameter`; unknown routes get a 404 envelope. Not enforced: `store: false`,
+* `stream: true`, `instructions`, `originator`, and `ChatGPT-Account-Id`.
+*
+* `GET /backend-api/wham/usage` is fixture-only: a request with a non-empty bearer credential and
+* a non-empty `ChatGPT-Account-Id` (neither checked or recorded), `accept: application/json`, and
+* no query gets the recorded body (`codexSubscriptionUsageDefault`, or a same-shaped
+* `options.subscriptionUsage` / scripted `{ usage }`); anything else answers 400 not-emulated.
+* Its ledger, faults, turns, and coverage are `emulator.usage` (control plane
+* `/_emulate/usage/*`); `reset()` and `POST /_emulate/reset` reset both routes.
+*/
+const makeCodexEmulator = (options = {}) => withSubscriptionUsage(makeCodexResponsesEmulator(options), makeCodexUsageEmulator(options), codexSubscriptionUsagePath);
+const makeCodexUsageEmulator = (options) => makeSubscriptionUsageEmulator({
+	path: codexSubscriptionUsagePath,
+	routes: codexSubscriptionUsageEmulatorRoutes,
+	recording: codexUsageRecording,
+	headers: [{
+		name: "chatgpt-account-id",
+		record: false
+	}],
+	subscriptionUsage: options.subscriptionUsage,
+	inputInvalid: (input, reason) => new CodexEmulatorInputInvalid({
+		input,
+		reason
+	})
+});
+const makeCodexResponsesEmulator = (options) => makeResponsesEmulator({
+	path: codexResponsesPath,
+	routes: codexEmulatorRoutes,
+	knownModels: options.knownModels ?? codexEmulatorDefaultModels,
+	errorEnvelope: openAiErrorEnvelope,
+	unknownModel: {
+		status: 400,
+		error: {
+			message: "Synthetic placeholder: the requested model is not supported.",
+			type: "invalid_request_error",
+			code: "model_not_found",
+			param: "model"
+		}
+	},
+	unauthorized: {
+		message: "Synthetic: missing or invalid bearer credential.",
+		type: "invalid_request_error",
+		code: "invalid_api_key"
+	},
+	headers: [{
+		name: "originator",
+		record: true
+	}],
+	outputTokenLimit: "rejected",
+	defaultText: [
+		"Hello",
+		" from the",
+		" synthetic Codex emulator."
+	],
+	inputInvalid: (input, reason) => new CodexEmulatorInputInvalid({
+		input,
+		reason
+	})
+});
+//#endregion
+export { CodexEmulatorInputInvalid, CodexErrorEventFault, CodexFault, CodexFaultMatch, CodexScriptedError, CodexScriptedFunctionCall, CodexScriptedResponse, CodexScriptedTurn, CodexScriptedUsage, CodexStreamError, CodexUsageFault, codexEmulatorDefaultModels, codexEmulatorRoutes, codexResponsesPath, codexSubscriptionUsageDefault, codexSubscriptionUsageEmulatorRoutes, codexSubscriptionUsagePath, emulatorEvidenceHeader, makeCodexEmulator };
+
+//# sourceMappingURL=codex.mjs.map

package/dist/codex.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.mjs","names":[],"sources":["../src/codex.ts"],"sourcesContent":["/**\n * OpenAI Codex (ChatGPT subscription) Responses emulator: a plain fetch handler for\n * `POST /backend-api/codex/responses` (origin `https://chatgpt.com`), with scripted turns, wire\n * faults, a request ledger, and an `/_emulate/*` control plane.\n *\n * It never imports SDK code: its wire shapes follow the synthetic Codex Responses conformance\n * fixtures (Responses SSE with typed `event:` names, the `response` JSON body, and the\n * `{ error: { message, type, param, code } }` envelope) and are linked to those conformance case\n * ids in `codexEmulatorRoutes`. The Responses machinery lives in the internal `responses.ts` core\n * and is shared with the xAI Grok emulator.\n *\n * Requests authenticate with a non-empty `Authorization: Bearer` credential (a ChatGPT OAuth\n * access token), never checked or stored. The ChatGPT Codex endpoint does not take an output\n * limit, so a request with `max_output_tokens` answers 400 `unsupported_parameter`. The\n * `originator` header is recorded in the ledger; `ChatGPT-Account-Id` is neither required nor\n * recorded.\n *\n * The same fetch handler also answers the Codex subscription-usage route\n * (`GET /backend-api/wham/usage`, `emulator.usage`) with its own manifest\n * (`codexSubscriptionUsageEmulatorRoutes`), ledger, faults, and turns; see `makeCodexEmulator`.\n *\n * Runtime-portable Web APIs only (`Request`, `Response`, `ReadableStream`, `TextEncoder`, `URL`);\n * no Effect runtime is required to use it.\n *\n * @experimental\n */\nimport { Data } from 'effect'\nimport type * as Schema from 'effect/Schema'\nimport { withSubscriptionUsage } from './emulator-compose.ts'\nimport type {\n  EmulatorCoverage,\n  EmulatorFaultState,\n  EmulatorRouteCoverage\n} from './emulator-kernel.ts'\nimport { EmulatorFaultMatch, EmulatorScriptedError } from './emulator-kernel.ts'\nimport {\n  makeResponsesEmulator,\n  ResponsesErrorEventFault,\n  ResponsesFault,\n  ResponsesScriptedFunctionCall,\n  ResponsesScriptedResponse,\n  ResponsesScriptedTurn,\n  ResponsesScriptedUsage,\n  ResponsesStreamError,\n  type ResponsesEmulator,\n  type ResponsesFaultKind,\n  type ResponsesLedgerEntry,\n  type ResponsesWireError\n} from './responses.ts'\nimport type { EmulatorRouteEvidence } from './route-evidence.ts'\nimport {\n  makeSubscriptionUsageEmulator,\n  recordedUsageBody,\n  SubscriptionUsageFault,\n  type SubscriptionUsageEmulator,\n  type SubscriptionUsageLedgerEntry,\n  type SubscriptionUsageScriptedTurn\n} from './subscription-usage.ts'\nimport { codexUsageRecording } from './subscription-usage-recordings.ts'\n\nexport type { EmulatorEvidence, EmulatorRouteEvidence } from './route-evidence.ts'\n\nexport { emulatorEvidenceHeader } from './route-evidence.ts'\n\nexport const codexResponsesPath = '/backend-api/codex/responses'\n\n/** The Codex subscription-usage path (`openAiCodexSubscriptionUsageUrl` in the SDK). */\nexport const codexSubscriptionUsagePath = '/backend-api/wham/usage'\n\n/**\n * Route evidence manifest of the Codex subscription-usage route (served by the same fetch handler\n * as the Responses route, with its own ledger and coverage). Synthetic, unverified.\n */\nexport const codexSubscriptionUsageEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> = [\n  {\n    method: 'GET',\n    path: codexSubscriptionUsagePath,\n    kind: 'provider',\n    write: false,\n    caseIds: ['openai.codex.usage.snapshot'],\n    evidence: 'unverified',\n    observedAt: undefined\n  }\n]\n\n/**\n * The recorded Codex usage body (the synthetic `openai.codex.usage.snapshot` fixture, copied as\n * data): `rate_limit.primary_window` and `secondary_window` as\n * `{ used_percent, limit_window_seconds, reset_after_seconds, reset_at }`.\n */\nexport const codexSubscriptionUsageDefault: Schema.Json = recordedUsageBody(codexUsageRecording)\n\n/** Synthetic-safe default model ids, including the Codex conformance defaults. */\nexport const codexEmulatorDefaultModels: ReadonlyArray<string> = ['gpt-5.4', 'gpt-5.5']\n\n/**\n * Route evidence manifest: every emulated Codex route and the conformance cases whose (currently\n * synthetic, unverified) wire shapes it follows.\n */\nexport const codexEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> = [\n  {\n    method: 'POST',\n    path: codexResponsesPath,\n    kind: 'provider',\n    write: false,\n    caseIds: [\n      'openai.codex.stream.plain-text',\n      'openai.codex.stream.function-call-arguments',\n      'openai.codex.stream.error-envelope',\n      'openai.codex.stream.terminal-event'\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 CodexFaultMatch = EmulatorFaultMatch\n\nexport type CodexFaultMatch = typeof EmulatorFaultMatch.Type\n\n/** A mid-stream Responses error (`{ code, message }`). */\nexport const CodexStreamError = ResponsesStreamError\n\nexport type CodexStreamError = ResponsesStreamError\n\n/** A mid-stream `error` or `response.failed` event fault, streamed responses only. */\nexport const CodexErrorEventFault = ResponsesErrorEventFault\n\nexport type CodexErrorEventFault = typeof ResponsesErrorEventFault.Type\n\n/**\n * Wire faults:\n *\n * - `status`: answer with this status, headers, and body (for example 429 with `retry-after`).\n *   The body defaults to the OpenAI error envelope for the status.\n * - `error-after-chunks`: send N body chunks, then error the body stream (a dropped connection).\n * - `truncate-after-chunks`: send N body chunks, then close cleanly (no `response.completed`).\n * - `error-event-after-chunks`: send N SSE events, then one `error` (default) or\n *   `response.failed` event and close.\n *\n * Statuses that cannot carry a body and redirects are rejected, as are invalid headers and\n * `location`. A fault that cannot take effect answers 500 and is not consumed.\n */\nexport const CodexFault = ResponsesFault\n\nexport type CodexFault = ResponsesFault\n\nexport type CodexFaultKind = ResponsesFaultKind\n\n/** Usage for a scripted turn (sent in `response.completed` or the JSON body). */\nexport const CodexScriptedUsage = ResponsesScriptedUsage\n\nexport type CodexScriptedUsage = ResponsesScriptedUsage\n\n/** One scripted `function_call` item; its arguments stream as these fragments. */\nexport const CodexScriptedFunctionCall = ResponsesScriptedFunctionCall\n\nexport type CodexScriptedFunctionCall = ResponsesScriptedFunctionCall\n\n/**\n * A scripted response: `reasoning` (summary fragments), `text`, `functionCalls`, `order`,\n * `usage` (`null` drops it), and `format` (`sse` or `json`, default: the request's `stream`).\n */\nexport const CodexScriptedResponse = ResponsesScriptedResponse\n\nexport type CodexScriptedResponse = ResponsesScriptedResponse\n\n/** A scripted error response: status, body (a string is sent as is), and optional headers. */\nexport const CodexScriptedError = EmulatorScriptedError\n\nexport type CodexScriptedError = typeof EmulatorScriptedError.Type\n\n/** A turn queued for the next Codex request. */\nexport const CodexScriptedTurn = ResponsesScriptedTurn\n\nexport type CodexScriptedTurn = ResponsesScriptedTurn\n\n/** Thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input; a programmer error. */\nexport class CodexEmulatorInputInvalid extends Data.TaggedError('CodexEmulatorInputInvalid')<{\n  readonly input: 'fault' | 'turn'\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid Codex emulator ${this.input}: ${this.reason}`\n  }\n}\n\nexport type CodexLedgerEntry = ResponsesLedgerEntry\n\nexport type CodexFaultState = EmulatorFaultState<CodexFault>\n\nexport type CodexRouteCoverage = EmulatorRouteCoverage\n\nexport type CodexCoverage = EmulatorCoverage\n\n/** A usage-route fault (`status`, `error-after-chunks`, `truncate-after-chunks`). */\nexport const CodexUsageFault = SubscriptionUsageFault\n\nexport type CodexUsageFault = SubscriptionUsageFault\n\n/** A usage turn: `{ usage }` (a body with the recorded JSON shape) or `{ error }`. */\nexport type CodexUsageScriptedTurn = SubscriptionUsageScriptedTurn\n\nexport type CodexUsageLedgerEntry = SubscriptionUsageLedgerEntry\n\nexport type CodexUsageEmulator = SubscriptionUsageEmulator\n\nexport type CodexEmulatorOptions = {\n  /** Model ids that exist. Defaults to `codexEmulatorDefaultModels`. */\n  readonly knownModels?: ReadonlyArray<string>\n  /**\n   * Replacement usage-route body; must have the recorded JSON shape (same keys and value kinds).\n   * Defaults to the recorded body (`codexSubscriptionUsageDefault`).\n   */\n  readonly subscriptionUsage?: Schema.Json\n}\n\n/** The Responses emulator, plus `usage`: the subscription-usage route's own emulator API. */\nexport type CodexEmulator = ResponsesEmulator & { readonly usage: CodexUsageEmulator }\n\nconst openAiErrorEnvelope = (error: ResponsesWireError): Schema.Json => ({\n  error: {\n    message: error.message,\n    type: error.type,\n    param: error.param ?? null,\n    code: error.code\n  }\n})\n\n/**\n * Create a Codex Responses emulator. Each call has independent ledger, fault, and script state.\n *\n * Without a script, `POST /backend-api/codex/responses` answers a known model with synthetic\n * output: `stream: true` streams `response.created`, `response.in_progress`, the output items\n * (`response.output_item.added`, their parts and deltas, `response.output_item.done`), and\n * `response.completed` with usage; `stream: false` returns one `response` JSON body. A request\n * whose `reasoning` asks for a `summary` (the Codex provider always does) gets a reasoning item\n * first. A request with function `tools` gets one `function_call` item whose arguments are\n * synthesized from the tool's JSON Schema and streamed as `response.function_call_arguments.delta`\n * fragments; `tool_choice: { type: 'function', name }` picks that tool (otherwise the first) and\n * `tool_choice: 'none'` answers with text. Unknown models get 400 `model_not_found`; a request\n * without a bearer credential gets 401 `invalid_api_key`; `max_output_tokens` gets 400\n * `unsupported_parameter`; unknown routes get a 404 envelope. Not enforced: `store: false`,\n * `stream: true`, `instructions`, `originator`, and `ChatGPT-Account-Id`.\n *\n * `GET /backend-api/wham/usage` is fixture-only: a request with a non-empty bearer credential and\n * a non-empty `ChatGPT-Account-Id` (neither checked or recorded), `accept: application/json`, and\n * no query gets the recorded body (`codexSubscriptionUsageDefault`, or a same-shaped\n * `options.subscriptionUsage` / scripted `{ usage }`); anything else answers 400 not-emulated.\n * Its ledger, faults, turns, and coverage are `emulator.usage` (control plane\n * `/_emulate/usage/*`); `reset()` and `POST /_emulate/reset` reset both routes.\n */\nexport const makeCodexEmulator = (options: CodexEmulatorOptions = {}): CodexEmulator =>\n  withSubscriptionUsage(\n    makeCodexResponsesEmulator(options),\n    makeCodexUsageEmulator(options),\n    codexSubscriptionUsagePath\n  )\n\nconst makeCodexUsageEmulator = (options: CodexEmulatorOptions): CodexUsageEmulator =>\n  makeSubscriptionUsageEmulator({\n    path: codexSubscriptionUsagePath,\n    routes: codexSubscriptionUsageEmulatorRoutes,\n    recording: codexUsageRecording,\n    headers: [{ name: 'chatgpt-account-id', record: false }],\n    subscriptionUsage: options.subscriptionUsage,\n    inputInvalid: (input, reason) => new CodexEmulatorInputInvalid({ input, reason })\n  })\n\nconst makeCodexResponsesEmulator = (options: CodexEmulatorOptions): ResponsesEmulator =>\n  makeResponsesEmulator({\n    path: codexResponsesPath,\n    routes: codexEmulatorRoutes,\n    knownModels: options.knownModels ?? codexEmulatorDefaultModels,\n    errorEnvelope: openAiErrorEnvelope,\n    // Copied data shape of the synthetic Codex error-envelope fixture (unknown model id).\n    unknownModel: {\n      status: 400,\n      error: {\n        message: 'Synthetic placeholder: the requested model is not supported.',\n        type: 'invalid_request_error',\n        code: 'model_not_found',\n        param: 'model'\n      }\n    },\n    unauthorized: {\n      message: 'Synthetic: missing or invalid bearer credential.',\n      type: 'invalid_request_error',\n      code: 'invalid_api_key'\n    },\n    headers: [{ name: 'originator', record: true }],\n    outputTokenLimit: 'rejected',\n    defaultText: ['Hello', ' from the', ' synthetic Codex emulator.'],\n    inputInvalid: (input, reason) => new CodexEmulatorInputInvalid({ input, reason })\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,MAAa,qBAAqB;;AAGlC,MAAa,6BAA6B;;;;;AAM1C,MAAa,uCAA6E,CACxF;CACE,QAAQ;CACR,MAAM;CACN,MAAM;CACN,OAAO;CACP,SAAS,CAAC,6BAA6B;CACvC,UAAU;CACV,YAAY,KAAA;AACd,CACF;;;;;;AAOA,MAAa,gCAA6C,kBAAkB,mBAAmB;;AAG/F,MAAa,6BAAoD,CAAC,WAAW,SAAS;;;;;AAMtF,MAAa,sBAA4D,CACvE;CACE,QAAQ;CACR,MAAM;CACN,MAAM;CACN,OAAO;CACP,SAAS;EACP;EACA;EACA;EACA;CACF;CACA,UAAU;CACV,YAAY,KAAA;AACd,CACF;;AAGA,MAAa,kBAAkB;;AAK/B,MAAa,mBAAmB;;AAKhC,MAAa,uBAAuB;;;;;;;;;;;;;;AAiBpC,MAAa,aAAa;;AAO1B,MAAa,qBAAqB;;AAKlC,MAAa,4BAA4B;;;;;AAQzC,MAAa,wBAAwB;;AAKrC,MAAa,qBAAqB;;AAKlC,MAAa,oBAAoB;;AAKjC,IAAa,4BAAb,cAA+C,KAAK,YAAY,2BAA2B,EAGxF;CACD,IAAa,UAAkB;EAC7B,OAAO,0BAA0B,KAAK,MAAM,IAAI,KAAK;CACvD;AACF;;AAWA,MAAa,kBAAkB;AAwB/B,MAAM,uBAAuB,WAA4C,EACvE,OAAO;CACL,SAAS,MAAM;CACf,MAAM,MAAM;CACZ,OAAO,MAAM,SAAS;CACtB,MAAM,MAAM;AACd,EACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,qBAAqB,UAAgC,CAAC,MACjE,sBACE,2BAA2B,OAAO,GAClC,uBAAuB,OAAO,GAC9B,0BACF;AAEF,MAAM,0BAA0B,YAC9B,8BAA8B;CAC5B,MAAM;CACN,QAAQ;CACR,WAAW;CACX,SAAS,CAAC;EAAE,MAAM;EAAsB,QAAQ;CAAM,CAAC;CACvD,mBAAmB,QAAQ;CAC3B,eAAe,OAAO,WAAW,IAAI,0BAA0B;EAAE;EAAO;CAAO,CAAC;AAClF,CAAC;AAEH,MAAM,8BAA8B,YAClC,sBAAsB;CACpB,MAAM;CACN,QAAQ;CACR,aAAa,QAAQ,eAAe;CACpC,eAAe;CAEf,cAAc;EACZ,QAAQ;EACR,OAAO;GACL,SAAS;GACT,MAAM;GACN,MAAM;GACN,OAAO;EACT;CACF;CACA,cAAc;EACZ,SAAS;EACT,MAAM;EACN,MAAM;CACR;CACA,SAAS,CAAC;EAAE,MAAM;EAAc,QAAQ;CAAK,CAAC;CAC9C,kBAAkB;CAClB,aAAa;EAAC;EAAS;EAAa;CAA4B;CAChE,eAAe,OAAO,WAAW,IAAI,0BAA0B;EAAE;EAAO;CAAO,CAAC;AAClF,CAAC"}

package/dist/dropbox/api.d.mts

@@ -0,0 +1,63 @@
+import { StatefulRoute } from "../stateful-emulator.mjs";
+import { DropboxEmulatorState } from "./state.mjs";
+
+//#region src/dropbox/api.d.ts
+/** API version prefix of every Dropbox route. */
+declare const dropboxEmulatorBasePath = "/2";
+/**
+ * The fixture error envelopes, byte for byte (`not-found-envelope.ts`, `create-folder-conflict.ts`,
+ * and `upload-rev-precondition.ts`), each answered with HTTP 409.
+ */
+declare const dropboxEmulatorErrorBodies: {
+  readonly notFound: "{\"error_summary\": \"path/not_found/.\", \"error\": {\".tag\": \"path\", \"path\": {\".tag\": \"not_found\"}}}";
+  readonly folderConflict: "{\"error_summary\": \"path/conflict/folder/..\", \"error\": {\".tag\": \"path\", \"path\": {\".tag\": \"conflict\", \"conflict\": {\".tag\": \"folder\"}}}}";
+  readonly uploadConflict: "{\"error_summary\": \"path/conflict/file/..\", \"error\": {\".tag\": \"path\", \"path\": {\"reason\": {\".tag\": \"conflict\", \"conflict\": {\".tag\": \"file\"}}}}}";
+};
+/** Drill knobs (tests only): each makes the emulator disagree with one conformance claim. */
+type DropboxEmulatorDrills = {
+  /** `list_folder` ignores `limit`: one page with every entry and `has_more: false`. */readonly listFolderSinglePage?: boolean; /** `get_metadata` matches path components case-sensitively. */
+  readonly getMetadataCaseSensitive?: boolean; /** `search/continue_v2` answers the earlier pages' matches again before the new ones. */
+  readonly searchRepeatsMatches?: boolean; /** A missing path answers a `path_lookup/not_found` envelope (still 409). */
+  readonly notFoundAsPathLookup?: boolean; /** A folder create conflict answers `path/conflict/file` instead of `path/conflict/folder`. */
+  readonly folderConflictAsFile?: boolean; /** `delete_v2` keeps no deleted-entry record, so `include_deleted` is not emulated. */
+  readonly deleteLeavesNoTombstone?: boolean; /** `move_v2` gives the moved file a new id. */
+  readonly moveMintsNewId?: boolean; /** An `update` upload naming a stale rev overwrites instead of conflicting. */
+  readonly uploadIgnoresRev?: boolean;
+};
+declare const dropboxEmulatorDrillKnobs: ReadonlyArray<keyof DropboxEmulatorDrills>;
+/** A `list_folder` cursor (runtime data, not state). */
+type DropboxListCursor = {
+  readonly kind: 'list';
+  readonly folderId: string; /** The whole listing as rendered when the cursor was issued; any change is not emulated. */
+  readonly fingerprint: string;
+  readonly offset: number;
+  readonly limit: number;
+};
+/** A `search_v2` cursor (runtime data, not state). */
+type DropboxSearchCursor = {
+  readonly kind: 'search';
+  readonly query: string; /** Every match as rendered when the cursor was issued; any change is not emulated. */
+  readonly fingerprint: string;
+  readonly offset: number;
+  readonly maxResults: number;
+};
+type DropboxCursor = DropboxListCursor | DropboxSearchCursor;
+type DropboxApiEnv = {
+  /** Clock in epoch milliseconds (upload timestamps only). */readonly now: () => number;
+  readonly drills: Readonly<Record<keyof DropboxEmulatorDrills, boolean>>; /** Issued cursors by value (runtime-only; cleared by reset and seed). */
+  readonly cursors: Map<string, DropboxCursor>; /** Cursor numbers; never reset, so a cursor issued before a reset is never issued again. */
+  readonly cursorCounters: {
+    list: number;
+    search: number;
+  };
+};
+type Route = StatefulRoute<DropboxEmulatorState, DropboxApiEnv>;
+/** Origin of the RPC routes. */
+declare const dropboxEmulatorApiOrigin = "https://api.dropboxapi.com";
+/** Origin of the upload route. */
+declare const dropboxEmulatorContentOrigin = "https://content.dropboxapi.com";
+/** The route table: evidence plus handlers. `dropboxEmulatorRoutes` is its evidence part. */
+declare const dropboxApiRoutes: ReadonlyArray<Route>;
+//#endregion
+export { DropboxApiEnv, DropboxCursor, DropboxEmulatorDrills, DropboxListCursor, DropboxSearchCursor, dropboxApiRoutes, dropboxEmulatorApiOrigin, dropboxEmulatorBasePath, dropboxEmulatorContentOrigin, dropboxEmulatorDrillKnobs, dropboxEmulatorErrorBodies };
+//# sourceMappingURL=api.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.mts","names":[],"sources":["../../src/dropbox/api.ts"],"mappings":";;;;;cAwCa,uBAAA;AAAb;;;;AAAA,cAMa,0BAAA;EAAA;;;;;KAkBD,qBAAA;iGAED,oBAAA;WAEA,wBAAA,YAJsB;EAAA,SAMtB,oBAAA,YANsB;EAAA,SAQtB,oBAAA,YAJA;EAAA,SAMA,oBAAA,YAFA;EAAA,SAIA,uBAAA;EAAA,SAEA,cAAA,YAEA;EAAA,SAAA,gBAAA;AAAA;AAAA,cAGE,yBAAA,EAA2B,aAAa,OAAO,qBAAA;;KAYhD,iBAAA;EAAA,SACD,IAAA;EAAA,SACA,QAAA,UAFC;EAAA,SAID,WAAA;EAAA,SACA,MAAA;EAAA,SACA,KAAA;AAAA;;KAIC,mBAAA;EAAA,SACD,IAAA;EAAA,SACA,KAAA,UANK;EAAA,SAQL,WAAA;EAAA,SACA,MAAA;EAAA,SACA,UAAA;AAAA;AAAA,KAGC,aAAA,GAAgB,iBAAA,GAAoB,mBAAmB;AAAA,KAEvD,aAAA;EATD,qEAWA,GAAA;EAAA,SACA,MAAA,EAAQ,QAAA,CAAS,MAAA,OAAa,qBAAA,aAR9B;EAAA,SAUA,OAAA,EAAS,GAAA,SAAY,aAAA,GAVX;EAAA,SAYV,cAAA;IAAkB,IAAA;IAAc,MAAA;EAAA;AAAA;AAAA,KAGtC,KAAA,GAAQ,aAAA,CAAc,oBAAA,EAAsB,aAAA;;cAGpC,wBAAA;;cAGA,4BAAA;;cA46BA,gBAAA,EAAkB,aAAa,CAAC,KAAA"}