@yolk-sdk/emulators 0.1.0-canary.96

package/dist/notion.mjs

@@ -0,0 +1,127 @@
+import { emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { StatefulFault, StatefulFaultMatch, checkBooleanDrills, makeStatefulEmulator, routeEvidence } from "./stateful-emulator.mjs";
+import { statefulCoreRuntime } from "./stateful-core.mjs";
+import { NotionEmulatorBlock, NotionEmulatorBotUser, NotionEmulatorDataSource, NotionEmulatorDatabase, NotionEmulatorImpliedPage, NotionEmulatorPage, NotionEmulatorParent, NotionEmulatorProfile, NotionEmulatorPropertyItems, NotionEmulatorSeed, NotionEmulatorStateSchema, buildSeedState, decodeState } from "./notion/state.mjs";
+import { notionApiRoutes, notionEmulatorBasePath, notionEmulatorDrillKnobs, notionEmulatorOrigin, notionEmulatorVersion } from "./notion/api.mjs";
+import { Data, Predicate } from "effect";
+//#region src/notion.ts
+/**
+* Stateful Notion emulator (the `/v1` routes on `https://api.notion.com` at API version
+* 2025-09-03), built on the upstream `@emulators/core` custom runtime, with a request ledger,
+* status faults, and an `/_emulate/*` control plane.
+*
+* It never imports SDK code: its wire shapes, error envelopes, and default seed are copied as data
+* from the synthetic Notion conformance fixtures, and every route names the conformance cases it
+* follows in `notionEmulatorRoutes`. Only the routes those eight cases (with their cleanup) send
+* are emulated. Response behaviour comes only from the fixtures: anything they do not show answers
+* one ledgered 400 not-emulated, writes nothing, and uses up no fault. That includes a search
+* without matches or matching a trashed page, so the read-only leftover lookup fails on a clean
+* workspace and after the write case (the live runner prints its lookup-failed WARN). Search
+* considers only the pages whose content the state holds (an implied page never matches) and
+* refuses a match shown only as a query row. Every route answers only on the recorded origin
+* `https://api.notion.com` (`fetchOn(origin)` serves it behind a loopback rewrite).
+*
+* Request-shape latitude (`/notion`, the only accepted deviations): any bearer value (never
+* checked or stored); extra request headers; JSON key order; `content-type` media-type
+* parameters; the order of query parameters; Notion ids with or without dashes, in any case; any
+* search `query` (looked up in the state); and any `page_size` from 1 to 100 whose page shows
+* only recorded results (the data source query: 1). `Notion-Version` must be `2025-09-03`.
+* Everything else (other keys, filters, booleans, sorts, query parameters, another origin,
+* titles, repeated or missing `page_size`, and cursors not issued for the same list since the
+* last reset or whose list changed) is not emulated.
+*
+* Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by
+* `makeNotionEmulator` (importing this module has no side effects).
+*
+* @experimental
+*/
+/**
+* Route evidence manifest: every emulated route, whether it writes, and the conformance cases
+* whose (currently synthetic, unverified) wire claims it follows. Kept in sync with the handlers
+* by construction (both come from one route table).
+*/
+const notionEmulatorRoutes = notionApiRoutes.map(routeEvidence);
+/**
+* Optional fault filter; an omitted field matches every request. `method` is the HTTP method;
+* `path` is the raw request path (ending in `*`, a prefix); `route` is a route template of the
+* manifest (another value is rejected when the fault is added).
+*/
+const NotionFaultMatch = StatefulFaultMatch;
+/**
+* A status fault (400-599): answer matching requests with this status, headers, and body instead
+* of the route's write, so nothing is written. The body defaults to
+* `{ error: { type: 'emulator_fault', message } }`; `count` limits how many requests it answers.
+* Only a request the emulator would answer reaches a fault: a request that is not emulated, by
+* its shape or by the state, never uses one up.
+*/
+const NotionFault = StatefulFault;
+/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */
+var NotionEmulatorInputInvalid = class extends Data.TaggedError("NotionEmulatorInputInvalid") {
+	get message() {
+		return `Invalid Notion emulator ${this.input}: ${this.reason}`;
+	}
+};
+const inputInvalid = (input, reason) => new NotionEmulatorInputInvalid({
+	input,
+	reason
+});
+/**
+* Create a stateful Notion emulator on the `@emulators/core` custom runtime. Each call has its
+* own state, ledger, and faults. Rejects with `NotionEmulatorInputInvalid` for an invalid seed or
+* option. Every request needs `Notion-Version: 2025-09-03` (else not emulated). See
+* `src/stateful-emulator.ts` for the request precedence.
+*/
+const makeNotionEmulator = async (options = {}) => {
+	const initial = buildSeedState(options.seed ?? {});
+	if (Predicate.isString(initial)) throw inputInvalid("seed", initial);
+	checkBooleanDrills(options.drills, notionEmulatorDrillKnobs, inputInvalid);
+	const drills = options.drills ?? {};
+	const env = {
+		now: options.now ?? (() => Date.now()),
+		drills: {
+			searchRepeatsResults: drills.searchRepeatsResults === true,
+			botUserAsPerson: drills.botUserAsPerson === true,
+			envelopeStatusMismatch: drills.envelopeStatusMismatch === true,
+			omitTitlePlainText: drills.omitTitlePlainText === true,
+			blockCursorRepeats: drills.blockCursorRepeats === true,
+			rejectDoubleEncodedPropertyId: drills.rejectDoubleEncodedPropertyId === true,
+			rowParentAsDatabase: drills.rowParentAsDatabase === true,
+			trashedPageNotFound: drills.trashedPageNotFound === true
+		},
+		cursors: /* @__PURE__ */ new Map(),
+		propertyCursorCounter: { next: 1 },
+		generation: { current: 0 },
+		firstIssued: /* @__PURE__ */ new Map()
+	};
+	return await makeStatefulEmulator({
+		routes: notionApiRoutes,
+		env,
+		initial,
+		buildSeed: buildSeedState,
+		requestProblem: (header) => header("notion-version") === "2025-09-03" ? void 0 : `Notion-Version other than ${notionEmulatorVersion} (the version every fixture sends) is not emulated`,
+		recordHeaders: [{
+			name: "notion-version",
+			json: false
+		}],
+		clearRuntime: () => {
+			env.cursors.clear();
+			env.generation.current += 1;
+		},
+		runtimeState: () => ({}),
+		seedSummary: (state) => ({
+			pages: state.pages.length,
+			blocks: state.blocks.length,
+			dataSources: state.dataSources.length
+		}),
+		inputInvalid
+	}, statefulCoreRuntime({
+		name: "notion",
+		initial,
+		decodeState,
+		inputInvalid
+	}));
+};
+//#endregion
+export { NotionEmulatorBlock, NotionEmulatorBotUser, NotionEmulatorDataSource, NotionEmulatorDatabase, NotionEmulatorImpliedPage, NotionEmulatorInputInvalid, NotionEmulatorPage, NotionEmulatorParent, NotionEmulatorProfile, NotionEmulatorPropertyItems, NotionEmulatorSeed, NotionEmulatorStateSchema, NotionFault, NotionFaultMatch, emulatorEvidenceHeader, makeNotionEmulator, notionEmulatorBasePath, notionEmulatorOrigin, notionEmulatorRoutes, notionEmulatorVersion };
+
+//# sourceMappingURL=notion.mjs.map

package/dist/notion.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"notion.mjs","names":[],"sources":["../src/notion.ts"],"sourcesContent":["/**\n * Stateful Notion emulator (the `/v1` routes on `https://api.notion.com` at API version\n * 2025-09-03), built on the upstream `@emulators/core` custom runtime, with a request ledger,\n * status faults, and an `/_emulate/*` control plane.\n *\n * It never imports SDK code: its wire shapes, error envelopes, and default seed are copied as data\n * from the synthetic Notion conformance fixtures, and every route names the conformance cases it\n * follows in `notionEmulatorRoutes`. Only the routes those eight cases (with their cleanup) send\n * are emulated. Response behaviour comes only from the fixtures: anything they do not show answers\n * one ledgered 400 not-emulated, writes nothing, and uses up no fault. That includes a search\n * without matches or matching a trashed page, so the read-only leftover lookup fails on a clean\n * workspace and after the write case (the live runner prints its lookup-failed WARN). Search\n * considers only the pages whose content the state holds (an implied page never matches) and\n * refuses a match shown only as a query row. Every route answers only on the recorded origin\n * `https://api.notion.com` (`fetchOn(origin)` serves it behind a loopback rewrite).\n *\n * Request-shape latitude (`/notion`, the only accepted deviations): any bearer value (never\n * checked or stored); extra request headers; JSON key order; `content-type` media-type\n * parameters; the order of query parameters; Notion ids with or without dashes, in any case; any\n * search `query` (looked up in the state); and any `page_size` from 1 to 100 whose page shows\n * only recorded results (the data source query: 1). `Notion-Version` must be `2025-09-03`.\n * Everything else (other keys, filters, booleans, sorts, query parameters, another origin,\n * titles, repeated or missing `page_size`, and cursors not issued for the same list since the\n * last reset or whose list changed) is not emulated.\n *\n * Node-only: `@emulators/core` imports Node builtins, so the core is loaded lazily by\n * `makeNotionEmulator` (importing this module has no side effects).\n *\n * @experimental\n */\nimport { Data, Predicate } from 'effect'\nimport {\n  notionApiRoutes,\n  notionEmulatorDrillKnobs,\n  notionEmulatorVersion,\n  type NotionApiEnv,\n  type NotionEmulatorDrills\n} from './notion/api.ts'\nimport {\n  buildSeedState,\n  decodeState,\n  type NotionEmulatorSeed,\n  type NotionEmulatorState\n} from './notion/state.ts'\nimport type { EmulatorRouteEvidence } from './route-evidence.ts'\nimport {\n  StatefulFault,\n  StatefulFaultMatch,\n  checkBooleanDrills,\n  makeStatefulEmulator,\n  routeEvidence,\n  type StatefulCoverage,\n  type StatefulEmulatorApi,\n  type StatefulFaultState,\n  type StatefulInputKind,\n  type StatefulLedgerEntry\n} from './stateful-emulator.ts'\nimport { statefulCoreRuntime } from './stateful-core.ts'\n\nexport type { EmulatorEvidence, EmulatorRouteEvidence } from './route-evidence.ts'\n\nexport { emulatorEvidenceHeader } from './route-evidence.ts'\n\nexport {\n  notionEmulatorBasePath,\n  notionEmulatorOrigin,\n  notionEmulatorVersion,\n  type NotionEmulatorDrills\n} from './notion/api.ts'\n\nexport {\n  NotionEmulatorBlock,\n  NotionEmulatorBotUser,\n  NotionEmulatorDataSource,\n  NotionEmulatorDatabase,\n  NotionEmulatorImpliedPage,\n  NotionEmulatorPage,\n  NotionEmulatorParent,\n  NotionEmulatorProfile,\n  NotionEmulatorPropertyItems,\n  NotionEmulatorSeed,\n  NotionEmulatorStateSchema,\n  type NotionEmulatorState\n} from './notion/state.ts'\n\n/**\n * Route evidence manifest: every emulated route, whether it writes, and the conformance cases\n * whose (currently synthetic, unverified) wire claims it follows. Kept in sync with the handlers\n * by construction (both come from one route table).\n */\nexport const notionEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> =\n  notionApiRoutes.map(routeEvidence)\n\n/**\n * Optional fault filter; an omitted field matches every request. `method` is the HTTP method;\n * `path` is the raw request path (ending in `*`, a prefix); `route` is a route template of the\n * manifest (another value is rejected when the fault is added).\n */\nexport const NotionFaultMatch = StatefulFaultMatch\n\nexport type NotionFaultMatch = typeof StatefulFaultMatch.Type\n\n/**\n * A status fault (400-599): answer matching requests with this status, headers, and body instead\n * of the route's write, so nothing is written. The body defaults to\n * `{ error: { type: 'emulator_fault', message } }`; `count` limits how many requests it answers.\n * Only a request the emulator would answer reaches a fault: a request that is not emulated, by\n * its shape or by the state, never uses one up.\n */\nexport const NotionFault = StatefulFault\n\nexport type NotionFault = StatefulFault\n\nexport type NotionFaultState = StatefulFaultState\n\nexport type NotionLedgerEntry = StatefulLedgerEntry\n\nexport type NotionCoverage = StatefulCoverage\n\n/** Invalid emulator input from the JS API: a seed, a fault, or an option. A programmer error. */\nexport class NotionEmulatorInputInvalid extends Data.TaggedError('NotionEmulatorInputInvalid')<{\n  readonly input: StatefulInputKind\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid Notion emulator ${this.input}: ${this.reason}`\n  }\n}\n\nexport type NotionEmulatorOptions = {\n  /** Typed seed; defaults to the fixture entities (`profile: 'default'`). */\n  readonly seed?: NotionEmulatorSeed\n  /** Clock in epoch milliseconds (created page timestamps). Defaults to `Date.now`. */\n  readonly now?: () => number\n  /** Drill knobs (tests only): make the emulator disagree with one conformance claim. */\n  readonly drills?: NotionEmulatorDrills\n}\n\nexport type NotionEmulator = StatefulEmulatorApi<NotionEmulatorState, NotionEmulatorSeed>\n\nconst inputInvalid = (input: StatefulInputKind, reason: string) =>\n  new NotionEmulatorInputInvalid({ input, reason })\n\n/**\n * Create a stateful Notion emulator on the `@emulators/core` custom runtime. Each call has its\n * own state, ledger, and faults. Rejects with `NotionEmulatorInputInvalid` for an invalid seed or\n * option. Every request needs `Notion-Version: 2025-09-03` (else not emulated). See\n * `src/stateful-emulator.ts` for the request precedence.\n */\nexport const makeNotionEmulator = async (\n  options: NotionEmulatorOptions = {}\n): Promise<NotionEmulator> => {\n  const initial = buildSeedState(options.seed ?? {})\n\n  if (Predicate.isString(initial)) {\n    throw inputInvalid('seed', initial)\n  }\n\n  checkBooleanDrills(options.drills, notionEmulatorDrillKnobs, inputInvalid)\n\n  const drills = options.drills ?? {}\n\n  const env: NotionApiEnv = {\n    now: options.now ?? (() => Date.now()),\n    drills: {\n      searchRepeatsResults: drills.searchRepeatsResults === true,\n      botUserAsPerson: drills.botUserAsPerson === true,\n      envelopeStatusMismatch: drills.envelopeStatusMismatch === true,\n      omitTitlePlainText: drills.omitTitlePlainText === true,\n      blockCursorRepeats: drills.blockCursorRepeats === true,\n      rejectDoubleEncodedPropertyId: drills.rejectDoubleEncodedPropertyId === true,\n      rowParentAsDatabase: drills.rowParentAsDatabase === true,\n      trashedPageNotFound: drills.trashedPageNotFound === true\n    },\n    cursors: new Map(),\n    propertyCursorCounter: { next: 1 },\n    generation: { current: 0 },\n    firstIssued: new Map()\n  }\n\n  const api = await makeStatefulEmulator<NotionEmulatorState, NotionApiEnv, NotionEmulatorSeed>(\n    {\n      routes: notionApiRoutes,\n      env,\n      initial,\n      buildSeed: buildSeedState,\n      requestProblem: header =>\n        header('notion-version') === notionEmulatorVersion\n          ? undefined\n          : `Notion-Version other than ${notionEmulatorVersion} (the version every fixture sends) is not emulated`,\n      recordHeaders: [{ name: 'notion-version', json: false }],\n      // Cursor values never cross a reset or seed: property cursor numbers keep advancing, and the\n      // generation makes later search and block cursors distinct from earlier ones.\n      clearRuntime: () => {\n        env.cursors.clear()\n        env.generation.current += 1\n      },\n      runtimeState: () => ({}),\n      seedSummary: state => ({\n        pages: state.pages.length,\n        blocks: state.blocks.length,\n        dataSources: state.dataSources.length\n      }),\n      inputInvalid\n    },\n    statefulCoreRuntime({ name: 'notion', initial, decodeState, inputInvalid })\n  )\n\n  return api\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,MAAa,uBACX,gBAAgB,IAAI,aAAa;;;;;;AAOnC,MAAa,mBAAmB;;;;;;;;AAWhC,MAAa,cAAc;;AAW3B,IAAa,6BAAb,cAAgD,KAAK,YAAY,4BAA4B,EAG1F;CACD,IAAa,UAAkB;EAC7B,OAAO,2BAA2B,KAAK,MAAM,IAAI,KAAK;CACxD;AACF;AAaA,MAAM,gBAAgB,OAA0B,WAC9C,IAAI,2BAA2B;CAAE;CAAO;AAAO,CAAC;;;;;;;AAQlD,MAAa,qBAAqB,OAChC,UAAiC,CAAC,MACN;CAC5B,MAAM,UAAU,eAAe,QAAQ,QAAQ,CAAC,CAAC;CAEjD,IAAI,UAAU,SAAS,OAAO,GAC5B,MAAM,aAAa,QAAQ,OAAO;CAGpC,mBAAmB,QAAQ,QAAQ,0BAA0B,YAAY;CAEzE,MAAM,SAAS,QAAQ,UAAU,CAAC;CAElC,MAAM,MAAoB;EACxB,KAAK,QAAQ,cAAc,KAAK,IAAI;EACpC,QAAQ;GACN,sBAAsB,OAAO,yBAAyB;GACtD,iBAAiB,OAAO,oBAAoB;GAC5C,wBAAwB,OAAO,2BAA2B;GAC1D,oBAAoB,OAAO,uBAAuB;GAClD,oBAAoB,OAAO,uBAAuB;GAClD,+BAA+B,OAAO,kCAAkC;GACxE,qBAAqB,OAAO,wBAAwB;GACpD,qBAAqB,OAAO,wBAAwB;EACtD;EACA,yBAAS,IAAI,IAAI;EACjB,uBAAuB,EAAE,MAAM,EAAE;EACjC,YAAY,EAAE,SAAS,EAAE;EACzB,6BAAa,IAAI,IAAI;CACvB;CA8BA,OAAO,MA5BW,qBAChB;EACE,QAAQ;EACR;EACA;EACA,WAAW;EACX,iBAAgB,WACd,OAAO,gBAAgB,MAAA,eACnB,KAAA,IACA,6BAA6B,sBAAsB;EACzD,eAAe,CAAC;GAAE,MAAM;GAAkB,MAAM;EAAM,CAAC;EAGvD,oBAAoB;GAClB,IAAI,QAAQ,MAAM;GAClB,IAAI,WAAW,WAAW;EAC5B;EACA,qBAAqB,CAAC;EACtB,cAAa,WAAU;GACrB,OAAO,MAAM,MAAM;GACnB,QAAQ,MAAM,OAAO;GACrB,aAAa,MAAM,YAAY;EACjC;EACA;CACF,GACA,oBAAoB;EAAE,MAAM;EAAU;EAAS;EAAa;CAAa,CAAC,CAC5E;AAGF"}

package/dist/openai.d.mts

@@ -0,0 +1,165 @@
+import { EmulatorEvidence, EmulatorRouteEvidence, emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { ChatCompletionsEmulator, ChatCoverage, ChatFault, ChatFaultKind, ChatFaultMatch, ChatFaultState, ChatLedgerEntry, ChatRouteCoverage, ChatScriptedError, ChatScriptedToolCall, ChatScriptedUsage } from "./chat-completions.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/openai.d.ts
+declare const openAiChatCompletionsPath = "/v1/chat/completions";
+/** Synthetic-safe default model ids, including the OpenAI chat conformance defaults. */
+declare const openAiEmulatorDefaultModels: ReadonlyArray<string>;
+/**
+ * Route evidence manifest: every emulated OpenAI route and the conformance
+ * cases whose (currently synthetic, unverified) wire shapes it follows.
+ */
+declare const openAiEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence>;
+/** Optional fault filter; an omitted field matches every request. `path` ending in `*` is a prefix. */
+declare const OpenAiFaultMatch: Schema.Struct<{
+  readonly path: Schema.optionalKey<Schema.String>;
+  readonly model: Schema.optionalKey<Schema.String>;
+}>;
+type OpenAiFaultMatch = ChatFaultMatch;
+/**
+ * Wire faults for emulated routes, the same kinds as the Gateway emulator:
+ * `status` (the body defaults to an OpenAI error envelope),
+ * `error-after-chunks`, and `truncate-after-chunks`. Statuses that cannot
+ * carry a body and redirects are rejected, as are invalid headers and
+ * `location`. A chunk fault that cannot take effect answers 500 and is not
+ * consumed.
+ */
+declare const OpenAiFault: 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;
+}>]>;
+type OpenAiFault = ChatFault;
+type OpenAiFaultKind = ChatFaultKind;
+/** Usage for a scripted turn (sent as the wire `usage` object). */
+declare const OpenAiScriptedUsage: Schema.Struct<{
+  readonly promptTokens: Schema.Int;
+  readonly completionTokens: Schema.Int;
+  readonly reasoningTokens: Schema.optionalKey<Schema.Int>;
+}>;
+type OpenAiScriptedUsage = ChatScriptedUsage;
+/** One scripted tool call; its JSON arguments stream as these fragments. */
+declare const OpenAiScriptedToolCall: Schema.Struct<{
+  readonly name: Schema.NonEmptyString;
+  readonly argumentFragments: Schema.$Array<Schema.String>;
+  readonly id: Schema.optionalKey<Schema.NonEmptyString>;
+}>;
+type OpenAiScriptedToolCall = ChatScriptedToolCall;
+/**
+ * A scripted completion. Every field is exact (nothing is filled in) except:
+ * `usage` omitted is synthesized when the request asks for usage, and `null`
+ * drops it; `finishReason` omitted is `tool_calls` with tool calls, else
+ * `stop`. Reasoning is not emulated: reasoning fields are rejected.
+ */
+declare const OpenAiScriptedCompletion: Schema.Struct<{
+  text: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  toolCalls: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly argumentFragments: Schema.$Array<Schema.String>;
+    readonly id: Schema.optionalKey<Schema.NonEmptyString>;
+  }>>>;
+  usage: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+    readonly promptTokens: Schema.Int;
+    readonly completionTokens: Schema.Int;
+    readonly reasoningTokens: Schema.optionalKey<Schema.Int>;
+  }>>>;
+  finishReason: Schema.optionalKey<Schema.NonEmptyString>;
+}>;
+type OpenAiScriptedCompletion = typeof OpenAiScriptedCompletion.Type;
+/** A scripted error response: status, body (a string is sent as is), and optional headers. */
+declare const OpenAiScriptedError: 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 OpenAiScriptedError = ChatScriptedError;
+/** A turn queued for the next chat completion request. */
+declare const OpenAiScriptedTurn: 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<{
+  text: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  toolCalls: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly argumentFragments: Schema.$Array<Schema.String>;
+    readonly id: Schema.optionalKey<Schema.NonEmptyString>;
+  }>>>;
+  usage: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+    readonly promptTokens: Schema.Int;
+    readonly completionTokens: Schema.Int;
+    readonly reasoningTokens: Schema.optionalKey<Schema.Int>;
+  }>>>;
+  finishReason: Schema.optionalKey<Schema.NonEmptyString>;
+}>]>;
+type OpenAiScriptedTurn = typeof OpenAiScriptedTurn.Type;
+declare const OpenAiEmulatorInputInvalid_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: "OpenAiEmulatorInputInvalid";
+} & Readonly<A>;
+/** Thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input; a programmer error. */
+declare class OpenAiEmulatorInputInvalid extends OpenAiEmulatorInputInvalid_base<{
+  readonly input: 'fault' | 'turn';
+  readonly reason: string;
+}> {
+  get message(): string;
+}
+type OpenAiLedgerEntry = ChatLedgerEntry;
+type OpenAiFaultState = ChatFaultState;
+type OpenAiRouteCoverage = ChatRouteCoverage;
+type OpenAiCoverage = ChatCoverage;
+type OpenAiEmulatorOptions = {
+  /** Model ids that exist. Defaults to `openAiEmulatorDefaultModels`. */readonly knownModels?: ReadonlyArray<string>;
+};
+type OpenAiEmulator = ChatCompletionsEmulator<OpenAiScriptedTurn>;
+/**
+ * Create an OpenAI Chat Completions emulator. Each call has independent
+ * ledger, fault, and script state.
+ *
+ * Without a script, `POST /v1/chat/completions` answers a known model with
+ * synthetic text deltas (`stream: true`: `chat.completion.chunk` SSE, a finish
+ * chunk, a usage chunk when `stream_options.include_usage` is set, and
+ * `data: [DONE]`; `stream: false`: one `chat.completion` JSON body). A request
+ * with `tools` gets one tool call whose arguments are synthesized from the
+ * tool's JSON Schema and streamed in fragments, finishing with `tool_calls`.
+ * Unknown models get the OpenAI error envelope (404, `model_not_found`); a
+ * missing bearer credential gets a 401 envelope (`invalid_api_key`); unknown
+ * routes get a 404 JSON error. The ledger records the
+ * `max_completion_tokens` limit as `maxCompletionTokens`.
+ *
+ * Precedence per chat request matches the Gateway emulator: authentication and
+ * JSON validation, then the first matching `status` fault, then the next
+ * scripted turn, then model validation and defaults; a first matching chunk
+ * fault then shapes the body. Credential headers are never recorded, and the
+ * bearer value is never checked or stored.
+ */
+declare const makeOpenAiEmulator: (options?: OpenAiEmulatorOptions) => OpenAiEmulator;
+//#endregion
+export { type EmulatorEvidence, type EmulatorRouteEvidence, OpenAiCoverage, OpenAiEmulator, OpenAiEmulatorInputInvalid, OpenAiEmulatorOptions, OpenAiFault, OpenAiFaultKind, OpenAiFaultMatch, OpenAiFaultState, OpenAiLedgerEntry, OpenAiRouteCoverage, OpenAiScriptedCompletion, OpenAiScriptedError, OpenAiScriptedToolCall, OpenAiScriptedTurn, OpenAiScriptedUsage, emulatorEvidenceHeader, makeOpenAiEmulator, openAiChatCompletionsPath, openAiEmulatorDefaultModels, openAiEmulatorRoutes };
+//# sourceMappingURL=openai.d.mts.map

package/dist/openai.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.mts","names":[],"sources":["../src/openai.ts"],"mappings":";;;;;cA4Ca,yBAAA;;cAGA,2BAAA,EAA6B,aAAa;;AAHjB;AAGtC;;cAMa,oBAAA,EAAsB,aAAa,CAAC,qBAAA;;cAkBpC,gBAAA,EAAgB,MAAA,CAAA,MAAA;EAAA;;;KAEjB,gBAAA,GAAmB,cAAc;AApByB;AAkBtE;;;;;;;AAlBsE,cA8BzD,WAAA,EAAW,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;KAEZ,WAAA,GAAc,SAAS;AAAA,KAEvB,eAAA,GAAkB,aAAa;;cAG9B,mBAAA,EAAmB,MAAA,CAAA,MAAA;EAAA;;;;KAEpB,mBAAA,GAAsB,iBAAiB;;cAGtC,sBAAA,EAAsB,MAAA,CAAA,MAAA;EAAA;;;;KAEvB,sBAAA,GAAyB,oBAAoB;;;;;;;cAQ5C,wBAAA,EAAwB,MAAA,CAAA,MAAA;;;;;;;;;;;;;;KAEzB,wBAAA,UAAkC,wBAAA,CAAyB,IAAI;;cAG9D,mBAAA,EAAmB,MAAA,CAAA,MAAA;EAAA;;;;;;KAEpB,mBAAA,GAAsB,iBAAiB;;cAGtC,kBAAA,EAAkB,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;KAEnB,kBAAA,UAA4B,kBAAA,CAAmB,IAAI;AAAA,cAAA,+BAAA;;;;cAGlD,0BAAA,SAAmC,+BAAA;EAAA,SACrC,KAAA;EAAA,SACA,MAAA;AAAA;EAAA,IAEI,OAAA,CAAA;AAAA;AAAA,KAKH,iBAAA,GAAoB,eAAe;AAAA,KAEnC,gBAAA,GAAmB,cAAc;AAAA,KAEjC,mBAAA,GAAsB,iBAAiB;AAAA,KAEvC,cAAA,GAAiB,YAAY;AAAA,KAE7B,qBAAA;kFAED,WAAA,GAAc,aAAa;AAAA;AAAA,KAG1B,cAAA,GAAiB,uBAAuB,CAAC,kBAAA;;;;;;;;;;;;;;;;;;;;;;cA2BxC,kBAAA,GAAsB,OAAA,GAAS,qBAAA,KAA6B,cA4BrE"}

package/dist/openai.mjs

@@ -0,0 +1,141 @@
+import { emulatorEvidenceHeader } from "./route-evidence.mjs";
+import { ChatFault, ChatFaultMatch, ChatScriptedError, ChatScriptedToolCall, ChatScriptedUsage, chatScriptedCompletionFields, makeChatCompletionsEmulator } from "./chat-completions.mjs";
+import { Data } from "effect";
+import * as Schema from "effect/Schema";
+//#region src/openai.ts
+/**
+* OpenAI Chat Completions emulator: a plain fetch handler for
+* `POST /v1/chat/completions` (origin `https://api.openai.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 OpenAI chat
+* conformance fixtures (`chat.completion.chunk` SSE, usage chunk,
+* `data: [DONE]`, the `chat.completion` JSON body, and the
+* `{ error: { message, type, param, code } }` envelope) and are linked to
+* those conformance case ids in `openAiEmulatorRoutes`. The Chat Completions
+* machinery is shared with the Gateway emulator (`chat-completions.ts`).
+*
+* Reasoning models are not emulated yet: no default model streams reasoning,
+* and scripted turns cannot carry reasoning.
+*
+* Runtime-portable Web APIs only (`Request`, `Response`, `ReadableStream`,
+* `TextEncoder`, `URL`); no Effect runtime is required to use it.
+*
+* @experimental
+*/
+const openAiChatCompletionsPath = "/v1/chat/completions";
+/** Synthetic-safe default model ids, including the OpenAI chat conformance defaults. */
+const openAiEmulatorDefaultModels = ["gpt-4.1-nano", "gpt-4.1-mini"];
+/**
+* Route evidence manifest: every emulated OpenAI route and the conformance
+* cases whose (currently synthetic, unverified) wire shapes it follows.
+*/
+const openAiEmulatorRoutes = [{
+	method: "POST",
+	path: openAiChatCompletionsPath,
+	kind: "provider",
+	write: false,
+	caseIds: [
+		"openai.chat.stream.plain-text",
+		"openai.chat.stream.tool-call-deltas",
+		"openai.chat.stream.error-envelope",
+		"openai.chat.json.plain-text"
+	],
+	evidence: "unverified",
+	observedAt: void 0
+}];
+/** Optional fault filter; an omitted field matches every request. `path` ending in `*` is a prefix. */
+const OpenAiFaultMatch = ChatFaultMatch;
+/**
+* Wire faults for emulated routes, the same kinds as the Gateway emulator:
+* `status` (the body defaults to an OpenAI error envelope),
+* `error-after-chunks`, and `truncate-after-chunks`. Statuses that cannot
+* carry a body and redirects are rejected, as are invalid headers and
+* `location`. A chunk fault that cannot take effect answers 500 and is not
+* consumed.
+*/
+const OpenAiFault = ChatFault;
+/** Usage for a scripted turn (sent as the wire `usage` object). */
+const OpenAiScriptedUsage = ChatScriptedUsage;
+/** One scripted tool call; its JSON arguments stream as these fragments. */
+const OpenAiScriptedToolCall = ChatScriptedToolCall;
+/**
+* A scripted completion. Every field is exact (nothing is filled in) except:
+* `usage` omitted is synthesized when the request asks for usage, and `null`
+* drops it; `finishReason` omitted is `tool_calls` with tool calls, else
+* `stop`. Reasoning is not emulated: reasoning fields are rejected.
+*/
+const OpenAiScriptedCompletion = Schema.Struct(chatScriptedCompletionFields);
+/** A scripted error response: status, body (a string is sent as is), and optional headers. */
+const OpenAiScriptedError = ChatScriptedError;
+/** A turn queued for the next chat completion request. */
+const OpenAiScriptedTurn = Schema.Union([OpenAiScriptedError, OpenAiScriptedCompletion]);
+/** Thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input; a programmer error. */
+var OpenAiEmulatorInputInvalid = class extends Data.TaggedError("OpenAiEmulatorInputInvalid") {
+	get message() {
+		return `Invalid OpenAI emulator ${this.input}: ${this.reason}`;
+	}
+};
+const openAiErrorEnvelope = (error) => ({ error: {
+	message: error.message,
+	type: error.type,
+	param: null,
+	code: error.code
+} });
+/**
+* Create an OpenAI Chat Completions emulator. Each call has independent
+* ledger, fault, and script state.
+*
+* Without a script, `POST /v1/chat/completions` answers a known model with
+* synthetic text deltas (`stream: true`: `chat.completion.chunk` SSE, a finish
+* chunk, a usage chunk when `stream_options.include_usage` is set, and
+* `data: [DONE]`; `stream: false`: one `chat.completion` JSON body). A request
+* with `tools` gets one tool call whose arguments are synthesized from the
+* tool's JSON Schema and streamed in fragments, finishing with `tool_calls`.
+* Unknown models get the OpenAI error envelope (404, `model_not_found`); a
+* missing bearer credential gets a 401 envelope (`invalid_api_key`); unknown
+* routes get a 404 JSON error. The ledger records the
+* `max_completion_tokens` limit as `maxCompletionTokens`.
+*
+* Precedence per chat request matches the Gateway emulator: authentication and
+* JSON validation, then the first matching `status` fault, then the next
+* scripted turn, then model validation and defaults; a first matching chunk
+* fault then shapes the body. Credential headers are never recorded, and the
+* bearer value is never checked or stored.
+*/
+const makeOpenAiEmulator = (options = {}) => makeChatCompletionsEmulator({
+	path: openAiChatCompletionsPath,
+	routes: openAiEmulatorRoutes,
+	knownModels: options.knownModels ?? openAiEmulatorDefaultModels,
+	reasoningModels: void 0,
+	errorEnvelope: openAiErrorEnvelope,
+	unknownModel: {
+		status: 404,
+		error: {
+			message: "Synthetic placeholder: the requested model does not exist.",
+			type: "invalid_request_error",
+			code: "model_not_found"
+		}
+	},
+	auth: { unauthorized: {
+		message: "Synthetic: missing or invalid API key.",
+		type: "invalid_request_error",
+		code: "invalid_api_key"
+	} },
+	completionTokenField: "max_completion_tokens",
+	responseIdPrefix: "chatcmpl-synthetic",
+	defaultText: [
+		"Hello",
+		" from the",
+		" synthetic OpenAI emulator."
+	],
+	turnSchema: OpenAiScriptedTurn,
+	inputInvalid: (input, reason) => new OpenAiEmulatorInputInvalid({
+		input,
+		reason
+	})
+});
+//#endregion
+export { OpenAiEmulatorInputInvalid, OpenAiFault, OpenAiFaultMatch, OpenAiScriptedCompletion, OpenAiScriptedError, OpenAiScriptedToolCall, OpenAiScriptedTurn, OpenAiScriptedUsage, emulatorEvidenceHeader, makeOpenAiEmulator, openAiChatCompletionsPath, openAiEmulatorDefaultModels, openAiEmulatorRoutes };
+
+//# sourceMappingURL=openai.mjs.map

package/dist/openai.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.mjs","names":[],"sources":["../src/openai.ts"],"sourcesContent":["/**\n * OpenAI Chat Completions emulator: a plain fetch handler for\n * `POST /v1/chat/completions` (origin `https://api.openai.com`), with scripted\n * turns, wire faults, a request ledger, and an `/_emulate/*` control plane.\n *\n * It never imports SDK code: its wire shapes follow the synthetic OpenAI chat\n * conformance fixtures (`chat.completion.chunk` SSE, usage chunk,\n * `data: [DONE]`, the `chat.completion` JSON body, and the\n * `{ error: { message, type, param, code } }` envelope) and are linked to\n * those conformance case ids in `openAiEmulatorRoutes`. The Chat Completions\n * machinery is shared with the Gateway emulator (`chat-completions.ts`).\n *\n * Reasoning models are not emulated yet: no default model streams reasoning,\n * and scripted turns cannot carry reasoning.\n *\n * Runtime-portable Web APIs only (`Request`, `Response`, `ReadableStream`,\n * `TextEncoder`, `URL`); no Effect runtime is required to use it.\n *\n * @experimental\n */\nimport { Data } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport {\n  ChatFault,\n  ChatFaultMatch,\n  ChatScriptedError,\n  ChatScriptedToolCall,\n  ChatScriptedUsage,\n  chatScriptedCompletionFields,\n  makeChatCompletionsEmulator,\n  type ChatCompletionsEmulator,\n  type ChatCoverage,\n  type ChatFaultKind,\n  type ChatFaultState,\n  type ChatLedgerEntry,\n  type ChatRouteCoverage,\n  type ChatWireError\n} from './chat-completions.ts'\nimport type { EmulatorRouteEvidence } from './route-evidence.ts'\n\nexport type { EmulatorEvidence, EmulatorRouteEvidence } from './route-evidence.ts'\n\nexport { emulatorEvidenceHeader } from './route-evidence.ts'\n\nexport const openAiChatCompletionsPath = '/v1/chat/completions'\n\n/** Synthetic-safe default model ids, including the OpenAI chat conformance defaults. */\nexport const openAiEmulatorDefaultModels: ReadonlyArray<string> = ['gpt-4.1-nano', 'gpt-4.1-mini']\n\n/**\n * Route evidence manifest: every emulated OpenAI route and the conformance\n * cases whose (currently synthetic, unverified) wire shapes it follows.\n */\nexport const openAiEmulatorRoutes: ReadonlyArray<EmulatorRouteEvidence> = [\n  {\n    method: 'POST',\n    path: openAiChatCompletionsPath,\n    kind: 'provider',\n    write: false,\n    caseIds: [\n      'openai.chat.stream.plain-text',\n      'openai.chat.stream.tool-call-deltas',\n      'openai.chat.stream.error-envelope',\n      'openai.chat.json.plain-text'\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 OpenAiFaultMatch = ChatFaultMatch\n\nexport type OpenAiFaultMatch = ChatFaultMatch\n\n/**\n * Wire faults for emulated routes, the same kinds as the Gateway emulator:\n * `status` (the body defaults to an OpenAI error envelope),\n * `error-after-chunks`, and `truncate-after-chunks`. Statuses that cannot\n * carry a body and redirects are rejected, as are invalid headers and\n * `location`. A chunk fault that cannot take effect answers 500 and is not\n * consumed.\n */\nexport const OpenAiFault = ChatFault\n\nexport type OpenAiFault = ChatFault\n\nexport type OpenAiFaultKind = ChatFaultKind\n\n/** Usage for a scripted turn (sent as the wire `usage` object). */\nexport const OpenAiScriptedUsage = ChatScriptedUsage\n\nexport type OpenAiScriptedUsage = ChatScriptedUsage\n\n/** One scripted tool call; its JSON arguments stream as these fragments. */\nexport const OpenAiScriptedToolCall = ChatScriptedToolCall\n\nexport type OpenAiScriptedToolCall = ChatScriptedToolCall\n\n/**\n * A scripted completion. Every field is exact (nothing is filled in) except:\n * `usage` omitted is synthesized when the request asks for usage, and `null`\n * drops it; `finishReason` omitted is `tool_calls` with tool calls, else\n * `stop`. Reasoning is not emulated: reasoning fields are rejected.\n */\nexport const OpenAiScriptedCompletion = Schema.Struct(chatScriptedCompletionFields)\n\nexport type OpenAiScriptedCompletion = typeof OpenAiScriptedCompletion.Type\n\n/** A scripted error response: status, body (a string is sent as is), and optional headers. */\nexport const OpenAiScriptedError = ChatScriptedError\n\nexport type OpenAiScriptedError = ChatScriptedError\n\n/** A turn queued for the next chat completion request. */\nexport const OpenAiScriptedTurn = Schema.Union([OpenAiScriptedError, OpenAiScriptedCompletion])\n\nexport type OpenAiScriptedTurn = typeof OpenAiScriptedTurn.Type\n\n/** Thrown by the JS API (`faults.add`, `script.enqueue`) for invalid input; a programmer error. */\nexport class OpenAiEmulatorInputInvalid extends Data.TaggedError('OpenAiEmulatorInputInvalid')<{\n  readonly input: 'fault' | 'turn'\n  readonly reason: string\n}> {\n  override get message(): string {\n    return `Invalid OpenAI emulator ${this.input}: ${this.reason}`\n  }\n}\n\nexport type OpenAiLedgerEntry = ChatLedgerEntry\n\nexport type OpenAiFaultState = ChatFaultState\n\nexport type OpenAiRouteCoverage = ChatRouteCoverage\n\nexport type OpenAiCoverage = ChatCoverage\n\nexport type OpenAiEmulatorOptions = {\n  /** Model ids that exist. Defaults to `openAiEmulatorDefaultModels`. */\n  readonly knownModels?: ReadonlyArray<string>\n}\n\nexport type OpenAiEmulator = ChatCompletionsEmulator<OpenAiScriptedTurn>\n\nconst openAiErrorEnvelope = (error: ChatWireError): Schema.Json => ({\n  error: { message: error.message, type: error.type, param: null, code: error.code }\n})\n\n/**\n * Create an OpenAI Chat Completions emulator. Each call has independent\n * ledger, fault, and script state.\n *\n * Without a script, `POST /v1/chat/completions` answers a known model with\n * synthetic text deltas (`stream: true`: `chat.completion.chunk` SSE, a finish\n * chunk, a usage chunk when `stream_options.include_usage` is set, and\n * `data: [DONE]`; `stream: false`: one `chat.completion` JSON body). A request\n * with `tools` gets one tool call whose arguments are synthesized from the\n * tool's JSON Schema and streamed in fragments, finishing with `tool_calls`.\n * Unknown models get the OpenAI error envelope (404, `model_not_found`); a\n * missing bearer credential gets a 401 envelope (`invalid_api_key`); unknown\n * routes get a 404 JSON error. The ledger records the\n * `max_completion_tokens` limit as `maxCompletionTokens`.\n *\n * Precedence per chat request matches the Gateway emulator: authentication and\n * JSON validation, then the first matching `status` fault, then the next\n * scripted turn, then model validation and defaults; a first matching chunk\n * fault then shapes the body. Credential headers are never recorded, and the\n * bearer value is never checked or stored.\n */\nexport const makeOpenAiEmulator = (options: OpenAiEmulatorOptions = {}): OpenAiEmulator =>\n  makeChatCompletionsEmulator({\n    path: openAiChatCompletionsPath,\n    routes: openAiEmulatorRoutes,\n    knownModels: options.knownModels ?? openAiEmulatorDefaultModels,\n    reasoningModels: undefined,\n    errorEnvelope: openAiErrorEnvelope,\n    // Copied data shape of the synthetic OpenAI error-envelope fixture (unknown model id).\n    unknownModel: {\n      status: 404,\n      error: {\n        message: 'Synthetic placeholder: the requested model does not exist.',\n        type: 'invalid_request_error',\n        code: 'model_not_found'\n      }\n    },\n    auth: {\n      unauthorized: {\n        message: 'Synthetic: missing or invalid API key.',\n        type: 'invalid_request_error',\n        code: 'invalid_api_key'\n      }\n    },\n    completionTokenField: 'max_completion_tokens',\n    responseIdPrefix: 'chatcmpl-synthetic',\n    defaultText: ['Hello', ' from the', ' synthetic OpenAI emulator.'],\n    turnSchema: OpenAiScriptedTurn,\n    inputInvalid: (input, reason) => new OpenAiEmulatorInputInvalid({ input, reason })\n  })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAa,4BAA4B;;AAGzC,MAAa,8BAAqD,CAAC,gBAAgB,cAAc;;;;;AAMjG,MAAa,uBAA6D,CACxE;CACE,QAAQ;CACR,MAAM;CACN,MAAM;CACN,OAAO;CACP,SAAS;EACP;EACA;EACA;EACA;CACF;CACA,UAAU;CACV,YAAY,KAAA;AACd,CACF;;AAGA,MAAa,mBAAmB;;;;;;;;;AAYhC,MAAa,cAAc;;AAO3B,MAAa,sBAAsB;;AAKnC,MAAa,yBAAyB;;;;;;;AAUtC,MAAa,2BAA2B,OAAO,OAAO,4BAA4B;;AAKlF,MAAa,sBAAsB;;AAKnC,MAAa,qBAAqB,OAAO,MAAM,CAAC,qBAAqB,wBAAwB,CAAC;;AAK9F,IAAa,6BAAb,cAAgD,KAAK,YAAY,4BAA4B,EAG1F;CACD,IAAa,UAAkB;EAC7B,OAAO,2BAA2B,KAAK,MAAM,IAAI,KAAK;CACxD;AACF;AAiBA,MAAM,uBAAuB,WAAuC,EAClE,OAAO;CAAE,SAAS,MAAM;CAAS,MAAM,MAAM;CAAM,OAAO;CAAM,MAAM,MAAM;AAAK,EACnF;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,sBAAsB,UAAiC,CAAC,MACnE,4BAA4B;CAC1B,MAAM;CACN,QAAQ;CACR,aAAa,QAAQ,eAAe;CACpC,iBAAiB,KAAA;CACjB,eAAe;CAEf,cAAc;EACZ,QAAQ;EACR,OAAO;GACL,SAAS;GACT,MAAM;GACN,MAAM;EACR;CACF;CACA,MAAM,EACJ,cAAc;EACZ,SAAS;EACT,MAAM;EACN,MAAM;CACR,EACF;CACA,sBAAsB;CACtB,kBAAkB;CAClB,aAAa;EAAC;EAAS;EAAa;CAA6B;CACjE,YAAY;CACZ,eAAe,OAAO,WAAW,IAAI,2BAA2B;EAAE;EAAO;CAAO,CAAC;AACnF,CAAC"}

package/dist/opencode-recordings.d.mts

@@ -0,0 +1,7 @@
+import { FixtureRecording } from "./fixture-route.mjs";
+
+//#region src/opencode-recordings.d.ts
+declare const openCodeGoRecordings: ReadonlyArray<FixtureRecording>;
+//#endregion
+export { openCodeGoRecordings };
+//# sourceMappingURL=opencode-recordings.d.mts.map

package/dist/opencode-recordings.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode-recordings.d.mts","names":[],"sources":["../src/opencode-recordings.ts"],"mappings":";;;cASa,oBAAA,EAAsB,aAAa,CAAC,gBAAA"}