@copilotkit/aimock 1.45.1 → 1.47.0

package/dist/response/profiles.js

@@ -0,0 +1,65 @@
+//#region src/response/profiles.ts
+/** Inbound HTTP auth uses only provider-owned paths; shared routes stay legacy. */
+function authErrorDialectForPath(pathname) {
+	if (pathname === "/v1/messages" || pathname === "/v1/messages/count_tokens") return "messages";
+	if (pathname.startsWith("/v1beta/") || /^\/v1\/projects\/[^/]+\/locations\/[^/]+\/publishers\/google\//.test(pathname)) return "gemini";
+	return "openai";
+}
+/**
+* Shared catalog response dialect. The list route uses it only under
+* `policy.modelCatalog: "native"`. Auth retains its pathname-selected dialect.
+*/
+function isAnthropicModelRequest(headers) {
+	return headers["anthropic-version"] !== void 0 || headers["x-api-key"] !== void 0 && headers.authorization === void 0;
+}
+/** Static wire facts only. Status selection and transport behavior belong to callers. */
+const errorProfiles = {
+	openai: {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	},
+	messages: {
+		fixtureType: "api_error",
+		validationType: "invalid_request_error",
+		requiredHeaders: ["anthropic-version"]
+	},
+	bedrock: {
+		fixtureType: "api_error",
+		validationType: "invalid_request_error",
+		toolArgumentType: "InternalServerException"
+	},
+	"bedrock-converse": {
+		fixtureType: "api_error",
+		validationType: "invalid_request_error",
+		toolArgumentType: "InternalServerException"
+	},
+	ollama: {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	},
+	"ollama-embed": {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	},
+	cohere: {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	},
+	interactions: {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	},
+	gemini: {
+		fixtureType: "server_error",
+		validationType: "invalid_request_error"
+	}
+};
+/** Bedrock's body-level version and other wire families have no header requirement. */
+function missingRequiredHeader(wire, headers) {
+	if (wire !== "messages") return;
+	return errorProfiles.messages.requiredHeaders.find((name) => headers[name] === void 0);
+}
+
+//#endregion
+export { authErrorDialectForPath, errorProfiles, isAnthropicModelRequest, missingRequiredHeader };
+//# sourceMappingURL=profiles.js.map

package/dist/response/profiles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiles.js","names":[],"sources":["../../src/response/profiles.ts"],"sourcesContent":["import type { IncomingHttpHeaders } from \"node:http\";\n\n/** Inbound HTTP auth uses only provider-owned paths; shared routes stay legacy. */\nexport function authErrorDialectForPath(pathname: string): \"messages\" | \"gemini\" | \"openai\" {\n  if (pathname === \"/v1/messages\" || pathname === \"/v1/messages/count_tokens\") return \"messages\";\n  if (\n    pathname.startsWith(\"/v1beta/\") ||\n    /^\\/v1\\/projects\\/[^/]+\\/locations\\/[^/]+\\/publishers\\/google\\//.test(pathname)\n  )\n    return \"gemini\";\n  return \"openai\";\n}\n\n/**\n * Shared catalog response dialect. The list route uses it only under\n * `policy.modelCatalog: \"native\"`. Auth retains its pathname-selected dialect.\n */\nexport function isAnthropicModelRequest(headers: IncomingHttpHeaders): boolean {\n  return (\n    headers[\"anthropic-version\"] !== undefined ||\n    (headers[\"x-api-key\"] !== undefined && headers.authorization === undefined)\n  );\n}\n\n/** Static wire facts only. Status selection and transport behavior belong to callers. */\nexport const errorProfiles = {\n  openai: { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n  messages: {\n    fixtureType: \"api_error\",\n    validationType: \"invalid_request_error\",\n    requiredHeaders: [\"anthropic-version\"],\n  },\n  bedrock: {\n    fixtureType: \"api_error\",\n    validationType: \"invalid_request_error\",\n    toolArgumentType: \"InternalServerException\",\n  },\n  \"bedrock-converse\": {\n    fixtureType: \"api_error\",\n    validationType: \"invalid_request_error\",\n    toolArgumentType: \"InternalServerException\",\n  },\n  ollama: { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n  \"ollama-embed\": { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n  cohere: { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n  interactions: { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n  gemini: { fixtureType: \"server_error\", validationType: \"invalid_request_error\" },\n} as const;\n\nexport type ErrorWire = keyof typeof errorProfiles;\n\n/** Bedrock's body-level version and other wire families have no header requirement. */\nexport function missingRequiredHeader(\n  wire: ErrorWire,\n  headers: IncomingHttpHeaders,\n): string | undefined {\n  if (wire !== \"messages\") return;\n  return errorProfiles.messages.requiredHeaders.find((name) => headers[name] === undefined);\n}\n"],"mappings":";;AAGA,SAAgB,wBAAwB,UAAoD;AAC1F,KAAI,aAAa,kBAAkB,aAAa,4BAA6B,QAAO;AACpF,KACE,SAAS,WAAW,WAAW,IAC/B,iEAAiE,KAAK,SAAS,CAE/E,QAAO;AACT,QAAO;;;;;;AAOT,SAAgB,wBAAwB,SAAuC;AAC7E,QACE,QAAQ,yBAAyB,UAChC,QAAQ,iBAAiB,UAAa,QAAQ,kBAAkB;;;AAKrE,MAAa,gBAAgB;CAC3B,QAAQ;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CAChF,UAAU;EACR,aAAa;EACb,gBAAgB;EAChB,iBAAiB,CAAC,oBAAoB;EACvC;CACD,SAAS;EACP,aAAa;EACb,gBAAgB;EAChB,kBAAkB;EACnB;CACD,oBAAoB;EAClB,aAAa;EACb,gBAAgB;EAChB,kBAAkB;EACnB;CACD,QAAQ;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CAChF,gBAAgB;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CACxF,QAAQ;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CAChF,cAAc;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CACtF,QAAQ;EAAE,aAAa;EAAgB,gBAAgB;EAAyB;CACjF;;AAKD,SAAgB,sBACd,MACA,SACoB;AACpB,KAAI,SAAS,WAAY;AACzB,QAAO,cAAc,SAAS,gBAAgB,MAAM,SAAS,QAAQ,UAAU,OAAU"}

package/dist/response/proxy.cjs

@@ -0,0 +1,71 @@
+const require_lifecycle = require('./lifecycle.cjs');
+
+//#region src/response/proxy.ts
+/**
+* Responses torn down before they finished, judged at entry, on `close`, and
+* when the relay returns. Reading `res.writableFinished` only when journaling
+* is too late: on Node 20 and 22 a relay that calls `end()` on a destroyed
+* response makes it read `true` (Node 24+ keeps it `false`).
+*/
+const tornDownBeforeFinish = /* @__PURE__ */ new WeakSet();
+/**
+* Run a proxy relay while watching for a client hang-up.
+*
+* WHO killed a mid-flight stream decides what the journal says, and after the
+* fact the two look identical: `req.aborted`, `req.destroyed` and
+* `res.destroyed` all read the same whether the peer hung up or the recorder
+* tore the response down. So the hang-up is decided when the request socket
+* actually closes before the response ended, by the same rule the delivery
+* lifecycle uses ({@link teardownCause}): the client's socket closed or reset.
+* A FIN alone is not a hang-up. A response already gone when this is entered
+* is judged by that rule too, so a response aimock destroyed is not blamed on
+* the client. The listener is attached before `run` and removed after it: a
+* keep-alive socket outlives this request.
+*/
+async function withHangUpDetection(req, res, run) {
+	const socket = req.socket;
+	require_lifecycle.noteDeliveryStart(res);
+	const clientCaused = () => !res.writableEnded && require_lifecycle.teardownCause(res, socket) === "client";
+	let clientHungUp = (res.destroyed || socket?.destroyed === true) && clientCaused();
+	const noteSocketClose = () => {
+		if (clientCaused()) clientHungUp = true;
+	};
+	const noteTearDown = () => {
+		if (res.destroyed && !res.writableFinished) tornDownBeforeFinish.add(res);
+	};
+	noteTearDown();
+	socket?.on("close", noteSocketClose);
+	res.on("close", noteTearDown);
+	try {
+		return {
+			outcome: await run(),
+			clientHungUp
+		};
+	} finally {
+		noteTearDown();
+		socket?.off("close", noteSocketClose);
+		res.off("close", noteTearDown);
+	}
+}
+/**
+* The journal fields for a proxied response. A stream torn down before it
+* finished (destroyed, even when the relay called `end()` on it afterwards)
+* is marked interrupted and names the side that killed it: a client hang-up
+* is normal caller behaviour, an upstream/recorder tear-down is a fault worth
+* chasing. When no byte of the response reached the socket
+* ({@link statusLineSent}) the status is 0: the client never got a status
+* line. A response that finished, or was never torn down, gets no fields.
+*/
+function proxyInterruption(res, clientHungUp) {
+	if (!(res.destroyed && (tornDownBeforeFinish.has(res) || !res.writableFinished))) return {};
+	return {
+		...require_lifecycle.statusLineSent(res) ? {} : { status: 0 },
+		interrupted: true,
+		interruptReason: clientHungUp ? require_lifecycle.CLIENT_ABORTED : "proxy stream destroyed"
+	};
+}
+
+//#endregion
+exports.proxyInterruption = proxyInterruption;
+exports.withHangUpDetection = withHangUpDetection;
+//# sourceMappingURL=proxy.cjs.map

package/dist/response/proxy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.cjs","names":["teardownCause","statusLineSent","CLIENT_ABORTED"],"sources":["../../src/response/proxy.ts"],"sourcesContent":["import type * as http from \"node:http\";\nimport { CLIENT_ABORTED, noteDeliveryStart, statusLineSent, teardownCause } from \"./lifecycle.js\";\n\n/**\n * Responses torn down before they finished, judged at entry, on `close`, and\n * when the relay returns. Reading `res.writableFinished` only when journaling\n * is too late: on Node 20 and 22 a relay that calls `end()` on a destroyed\n * response makes it read `true` (Node 24+ keeps it `false`).\n */\nconst tornDownBeforeFinish = new WeakSet<http.ServerResponse>();\n\n/**\n * Run a proxy relay while watching for a client hang-up.\n *\n * WHO killed a mid-flight stream decides what the journal says, and after the\n * fact the two look identical: `req.aborted`, `req.destroyed` and\n * `res.destroyed` all read the same whether the peer hung up or the recorder\n * tore the response down. So the hang-up is decided when the request socket\n * actually closes before the response ended, by the same rule the delivery\n * lifecycle uses ({@link teardownCause}): the client's socket closed or reset.\n * A FIN alone is not a hang-up. A response already gone when this is entered\n * is judged by that rule too, so a response aimock destroyed is not blamed on\n * the client. The listener is attached before `run` and removed after it: a\n * keep-alive socket outlives this request.\n */\nexport async function withHangUpDetection<T>(\n  req: http.IncomingMessage,\n  res: http.ServerResponse,\n  run: () => Promise<T>,\n): Promise<{ outcome: T; clientHungUp: boolean }> {\n  const socket = req.socket;\n  noteDeliveryStart(res);\n  const clientCaused = (): boolean => !res.writableEnded && teardownCause(res, socket) === \"client\";\n  let clientHungUp = (res.destroyed || socket?.destroyed === true) && clientCaused();\n  const noteSocketClose = (): void => {\n    if (clientCaused()) clientHungUp = true;\n  };\n  const noteTearDown = (): void => {\n    if (res.destroyed && !res.writableFinished) tornDownBeforeFinish.add(res);\n  };\n  noteTearDown();\n  socket?.on(\"close\", noteSocketClose);\n  res.on(\"close\", noteTearDown);\n  try {\n    const outcome = await run();\n    return { outcome, clientHungUp };\n  } finally {\n    // The relay may have destroyed the response in its last tick, before\n    // `close` is emitted.\n    noteTearDown();\n    socket?.off(\"close\", noteSocketClose);\n    res.off(\"close\", noteTearDown);\n  }\n}\n\n/**\n * The journal fields for a proxied response. A stream torn down before it\n * finished (destroyed, even when the relay called `end()` on it afterwards)\n * is marked interrupted and names the side that killed it: a client hang-up\n * is normal caller behaviour, an upstream/recorder tear-down is a fault worth\n * chasing. When no byte of the response reached the socket\n * ({@link statusLineSent}) the status is 0: the client never got a status\n * line. A response that finished, or was never torn down, gets no fields.\n */\nexport function proxyInterruption(\n  res: http.ServerResponse,\n  clientHungUp: boolean,\n): { status?: 0; interrupted?: true; interruptReason?: string } {\n  const tornDown = res.destroyed && (tornDownBeforeFinish.has(res) || !res.writableFinished);\n  if (!tornDown) return {};\n  return {\n    ...(statusLineSent(res) ? {} : { status: 0 as const }),\n    interrupted: true,\n    interruptReason: clientHungUp ? CLIENT_ABORTED : \"proxy stream destroyed\",\n  };\n}\n"],"mappings":";;;;;;;;;AASA,MAAM,uCAAuB,IAAI,SAA8B;;;;;;;;;;;;;;;AAgB/D,eAAsB,oBACpB,KACA,KACA,KACgD;CAChD,MAAM,SAAS,IAAI;AACnB,qCAAkB,IAAI;CACtB,MAAM,qBAA8B,CAAC,IAAI,iBAAiBA,gCAAc,KAAK,OAAO,KAAK;CACzF,IAAI,gBAAgB,IAAI,aAAa,QAAQ,cAAc,SAAS,cAAc;CAClF,MAAM,wBAA8B;AAClC,MAAI,cAAc,CAAE,gBAAe;;CAErC,MAAM,qBAA2B;AAC/B,MAAI,IAAI,aAAa,CAAC,IAAI,iBAAkB,sBAAqB,IAAI,IAAI;;AAE3E,eAAc;AACd,SAAQ,GAAG,SAAS,gBAAgB;AACpC,KAAI,GAAG,SAAS,aAAa;AAC7B,KAAI;AAEF,SAAO;GAAE,SADO,MAAM,KAAK;GACT;GAAc;WACxB;AAGR,gBAAc;AACd,UAAQ,IAAI,SAAS,gBAAgB;AACrC,MAAI,IAAI,SAAS,aAAa;;;;;;;;;;;;AAalC,SAAgB,kBACd,KACA,cAC8D;AAE9D,KAAI,EADa,IAAI,cAAc,qBAAqB,IAAI,IAAI,IAAI,CAAC,IAAI,mBAC1D,QAAO,EAAE;AACxB,QAAO;EACL,GAAIC,iCAAe,IAAI,GAAG,EAAE,GAAG,EAAE,QAAQ,GAAY;EACrD,aAAa;EACb,iBAAiB,eAAeC,mCAAiB;EAClD"}

package/dist/response/proxy.js

@@ -0,0 +1,70 @@
+import { CLIENT_ABORTED, noteDeliveryStart, statusLineSent, teardownCause } from "./lifecycle.js";
+
+//#region src/response/proxy.ts
+/**
+* Responses torn down before they finished, judged at entry, on `close`, and
+* when the relay returns. Reading `res.writableFinished` only when journaling
+* is too late: on Node 20 and 22 a relay that calls `end()` on a destroyed
+* response makes it read `true` (Node 24+ keeps it `false`).
+*/
+const tornDownBeforeFinish = /* @__PURE__ */ new WeakSet();
+/**
+* Run a proxy relay while watching for a client hang-up.
+*
+* WHO killed a mid-flight stream decides what the journal says, and after the
+* fact the two look identical: `req.aborted`, `req.destroyed` and
+* `res.destroyed` all read the same whether the peer hung up or the recorder
+* tore the response down. So the hang-up is decided when the request socket
+* actually closes before the response ended, by the same rule the delivery
+* lifecycle uses ({@link teardownCause}): the client's socket closed or reset.
+* A FIN alone is not a hang-up. A response already gone when this is entered
+* is judged by that rule too, so a response aimock destroyed is not blamed on
+* the client. The listener is attached before `run` and removed after it: a
+* keep-alive socket outlives this request.
+*/
+async function withHangUpDetection(req, res, run) {
+	const socket = req.socket;
+	noteDeliveryStart(res);
+	const clientCaused = () => !res.writableEnded && teardownCause(res, socket) === "client";
+	let clientHungUp = (res.destroyed || socket?.destroyed === true) && clientCaused();
+	const noteSocketClose = () => {
+		if (clientCaused()) clientHungUp = true;
+	};
+	const noteTearDown = () => {
+		if (res.destroyed && !res.writableFinished) tornDownBeforeFinish.add(res);
+	};
+	noteTearDown();
+	socket?.on("close", noteSocketClose);
+	res.on("close", noteTearDown);
+	try {
+		return {
+			outcome: await run(),
+			clientHungUp
+		};
+	} finally {
+		noteTearDown();
+		socket?.off("close", noteSocketClose);
+		res.off("close", noteTearDown);
+	}
+}
+/**
+* The journal fields for a proxied response. A stream torn down before it
+* finished (destroyed, even when the relay called `end()` on it afterwards)
+* is marked interrupted and names the side that killed it: a client hang-up
+* is normal caller behaviour, an upstream/recorder tear-down is a fault worth
+* chasing. When no byte of the response reached the socket
+* ({@link statusLineSent}) the status is 0: the client never got a status
+* line. A response that finished, or was never torn down, gets no fields.
+*/
+function proxyInterruption(res, clientHungUp) {
+	if (!(res.destroyed && (tornDownBeforeFinish.has(res) || !res.writableFinished))) return {};
+	return {
+		...statusLineSent(res) ? {} : { status: 0 },
+		interrupted: true,
+		interruptReason: clientHungUp ? CLIENT_ABORTED : "proxy stream destroyed"
+	};
+}
+
+//#endregion
+export { proxyInterruption, withHangUpDetection };
+//# sourceMappingURL=proxy.js.map

package/dist/response/proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.js","names":[],"sources":["../../src/response/proxy.ts"],"sourcesContent":["import type * as http from \"node:http\";\nimport { CLIENT_ABORTED, noteDeliveryStart, statusLineSent, teardownCause } from \"./lifecycle.js\";\n\n/**\n * Responses torn down before they finished, judged at entry, on `close`, and\n * when the relay returns. Reading `res.writableFinished` only when journaling\n * is too late: on Node 20 and 22 a relay that calls `end()` on a destroyed\n * response makes it read `true` (Node 24+ keeps it `false`).\n */\nconst tornDownBeforeFinish = new WeakSet<http.ServerResponse>();\n\n/**\n * Run a proxy relay while watching for a client hang-up.\n *\n * WHO killed a mid-flight stream decides what the journal says, and after the\n * fact the two look identical: `req.aborted`, `req.destroyed` and\n * `res.destroyed` all read the same whether the peer hung up or the recorder\n * tore the response down. So the hang-up is decided when the request socket\n * actually closes before the response ended, by the same rule the delivery\n * lifecycle uses ({@link teardownCause}): the client's socket closed or reset.\n * A FIN alone is not a hang-up. A response already gone when this is entered\n * is judged by that rule too, so a response aimock destroyed is not blamed on\n * the client. The listener is attached before `run` and removed after it: a\n * keep-alive socket outlives this request.\n */\nexport async function withHangUpDetection<T>(\n  req: http.IncomingMessage,\n  res: http.ServerResponse,\n  run: () => Promise<T>,\n): Promise<{ outcome: T; clientHungUp: boolean }> {\n  const socket = req.socket;\n  noteDeliveryStart(res);\n  const clientCaused = (): boolean => !res.writableEnded && teardownCause(res, socket) === \"client\";\n  let clientHungUp = (res.destroyed || socket?.destroyed === true) && clientCaused();\n  const noteSocketClose = (): void => {\n    if (clientCaused()) clientHungUp = true;\n  };\n  const noteTearDown = (): void => {\n    if (res.destroyed && !res.writableFinished) tornDownBeforeFinish.add(res);\n  };\n  noteTearDown();\n  socket?.on(\"close\", noteSocketClose);\n  res.on(\"close\", noteTearDown);\n  try {\n    const outcome = await run();\n    return { outcome, clientHungUp };\n  } finally {\n    // The relay may have destroyed the response in its last tick, before\n    // `close` is emitted.\n    noteTearDown();\n    socket?.off(\"close\", noteSocketClose);\n    res.off(\"close\", noteTearDown);\n  }\n}\n\n/**\n * The journal fields for a proxied response. A stream torn down before it\n * finished (destroyed, even when the relay called `end()` on it afterwards)\n * is marked interrupted and names the side that killed it: a client hang-up\n * is normal caller behaviour, an upstream/recorder tear-down is a fault worth\n * chasing. When no byte of the response reached the socket\n * ({@link statusLineSent}) the status is 0: the client never got a status\n * line. A response that finished, or was never torn down, gets no fields.\n */\nexport function proxyInterruption(\n  res: http.ServerResponse,\n  clientHungUp: boolean,\n): { status?: 0; interrupted?: true; interruptReason?: string } {\n  const tornDown = res.destroyed && (tornDownBeforeFinish.has(res) || !res.writableFinished);\n  if (!tornDown) return {};\n  return {\n    ...(statusLineSent(res) ? {} : { status: 0 as const }),\n    interrupted: true,\n    interruptReason: clientHungUp ? CLIENT_ABORTED : \"proxy stream destroyed\",\n  };\n}\n"],"mappings":";;;;;;;;;AASA,MAAM,uCAAuB,IAAI,SAA8B;;;;;;;;;;;;;;;AAgB/D,eAAsB,oBACpB,KACA,KACA,KACgD;CAChD,MAAM,SAAS,IAAI;AACnB,mBAAkB,IAAI;CACtB,MAAM,qBAA8B,CAAC,IAAI,iBAAiB,cAAc,KAAK,OAAO,KAAK;CACzF,IAAI,gBAAgB,IAAI,aAAa,QAAQ,cAAc,SAAS,cAAc;CAClF,MAAM,wBAA8B;AAClC,MAAI,cAAc,CAAE,gBAAe;;CAErC,MAAM,qBAA2B;AAC/B,MAAI,IAAI,aAAa,CAAC,IAAI,iBAAkB,sBAAqB,IAAI,IAAI;;AAE3E,eAAc;AACd,SAAQ,GAAG,SAAS,gBAAgB;AACpC,KAAI,GAAG,SAAS,aAAa;AAC7B,KAAI;AAEF,SAAO;GAAE,SADO,MAAM,KAAK;GACT;GAAc;WACxB;AAGR,gBAAc;AACd,UAAQ,IAAI,SAAS,gBAAgB;AACrC,MAAI,IAAI,SAAS,aAAa;;;;;;;;;;;;AAalC,SAAgB,kBACd,KACA,cAC8D;AAE9D,KAAI,EADa,IAAI,cAAc,qBAAqB,IAAI,IAAI,IAAI,CAAC,IAAI,mBAC1D,QAAO,EAAE;AACxB,QAAO;EACL,GAAI,eAAe,IAAI,GAAG,EAAE,GAAG,EAAE,QAAQ,GAAY;EACrD,aAAa;EACb,iBAAiB,eAAe,iBAAiB;EAClD"}

package/dist/response/raw.cjs

@@ -0,0 +1,228 @@
+const require_errors = require('./errors.cjs');
+const require_helpers = require('../helpers.cjs');
+const require_raw_validation = require('../raw-validation.cjs');
+const require_sse_writer = require('../sse-writer.cjs');
+const require_misbehavior = require('../misbehavior.cjs');
+const require_fixture_loader = require('../fixture-loader.cjs');
+const require_deliver = require('./deliver.cjs');
+const require_aws_event_stream = require('../aws-event-stream.cjs');
+const require_openrouter_chat = require('../openrouter-chat.cjs');
+const require_ndjson_writer = require('../ndjson-writer.cjs');
+
+//#region src/response/raw.ts
+/**
+* The default headers of the typed stream on `wire`, read from the typed
+* codec: SSE and NDJSON add `Cache-Control: no-cache` and
+* `Connection: keep-alive`, the AWS event stream `Transfer-Encoding: chunked`.
+*/
+function rawStreamHeaders(wire) {
+	switch (wire) {
+		case "openai-responses":
+		case "openai-chat":
+		case "anthropic":
+		case "gemini":
+		case "gemini-interactions":
+		case "cohere": return require_sse_writer.sseCodec({ done: false }).headers;
+		case "ollama":
+		case "ollama-generate": return require_ndjson_writer.ndjsonCodec().headers;
+		case "bedrock-invoke":
+		case "bedrock-converse": return require_aws_event_stream.eventStreamCodec().headers;
+	}
+}
+/** The non-streaming JSON default, as `deliverJson` sends it. */
+const JSON_HEADERS = { "Content-Type": "application/json" };
+/**
+* `defaults` with each `authored` header laid over it. Header names are
+* case-insensitive: an authored header replaces the default of the same name
+* in any letter case and takes the default's spelling, so a later spread over
+* the same defaults (as `deliverJson` does) still has one key per name.
+*/
+function overrideHeaders(defaults, authored) {
+	const merged = { ...defaults };
+	const spelling = new Map(Object.keys(defaults).map((name) => [name.toLowerCase(), name]));
+	for (const [name, value] of Object.entries(authored ?? {})) merged[spelling.get(name.toLowerCase()) ?? name] = value;
+	return merged;
+}
+/** One raw event, framed for `wire`. Events are checked before framing (raw-validation.ts). */
+function encodeRawFrame(wire, event) {
+	const json = JSON.stringify(event);
+	switch (wire) {
+		case "openai-responses":
+		case "anthropic":
+		case "cohere": return `event: ${String(event.type)}\ndata: ${json}\n\n`;
+		case "openai-chat":
+		case "gemini":
+		case "gemini-interactions": return `data: ${json}\n\n`;
+		case "ollama":
+		case "ollama-generate": return `${json}\n`;
+		case "bedrock-invoke": return require_aws_event_stream.encodeEventStreamMessage("chunk", { bytes: Buffer.from(json, "utf8").toString("base64") });
+		case "bedrock-converse": {
+			const [eventType] = Object.keys(event);
+			const payload = event[eventType];
+			if (payload === null || typeof payload !== "object" || Array.isArray(payload)) throw new Error(`raw framing internal error: bedrock-converse event "${eventType}" has no object payload`);
+			return require_aws_event_stream.encodeEventStreamMessage(eventType, payload);
+		}
+	}
+}
+/**
+* Bytes written after the last frame, if any. Only `openai-chat` has a
+* terminal (`data: [DONE]`), sent unless `raw.done === false` and never after
+* an interrupted stream.
+*/
+function rawTrailer(wire, raw, aborted) {
+	if (wire === "openai-chat" && !aborted && raw.done !== false) return "data: [DONE]\n\n";
+}
+/** The error code for a request the raw fixture has no body for. */
+const RAW_MODE_UNAVAILABLE = "aimock_raw_mode_unavailable";
+/** The error code for a raw fixture that fails its checks or targets another wire. */
+const RAW_FIXTURE_INVALID = "aimock_raw_fixture_invalid";
+/**
+* The raw events as a frame codec for the shared frame loop. Its headers are
+* the typed stream's defaults for `wire` with `raw.headers` laid over them.
+*/
+function rawCodec(wire, raw) {
+	return {
+		headers: overrideHeaders(rawStreamHeaders(wire), raw.headers),
+		encode: (event) => encodeRawFrame(wire, event),
+		trailer: (aborted) => {
+			const trailer = rawTrailer(wire, raw, aborted);
+			return trailer === void 0 ? [] : [trailer];
+		}
+	};
+}
+/**
+* The error body for a raw 500, in the dialect of the handler's misbehavior
+* errors. Dialects with no code slot (Gemini, Ollama, OpenRouter) carry the
+* code as a message prefix.
+*/
+function renderRawError(ctx, code, message) {
+	if (ctx.openRouter) return { body: require_openrouter_chat.serializeOpenRouterError(500, `${code}: ${message}`) };
+	switch (ctx.errorWire) {
+		case "openai": return require_errors.renderError("openai", "misbehavior", {
+			message,
+			type: "server_error",
+			...ctx.wire === "openai-chat" ? {
+				param: null,
+				includeParam: true
+			} : {},
+			code
+		});
+		case "messages": return require_errors.renderError("messages", "misbehavior", {
+			type: "api_error",
+			code,
+			message
+		});
+		case "gemini": return require_errors.renderError("gemini", "misbehavior", {
+			bodyCode: 500,
+			message: `${code}: ${message}`,
+			status: "INTERNAL"
+		});
+		case "bedrock":
+		case "bedrock-converse": return require_errors.renderError(ctx.errorWire, "misbehavior", {
+			type: "InternalServerException",
+			code,
+			message
+		});
+		default: return require_errors.renderError(ctx.errorWire, "misbehavior", {
+			code,
+			message
+		});
+	}
+}
+/**
+* Serve a raw passthrough fixture on the handler's wire: check it, journal it,
+* and send its events or JSON through the shared delivery layer. A fixture
+* that fails a check, targets another wire, or has no body for the requested
+* mode gets a 500 in the handler's misbehavior error dialect, and an error log
+* line. A reply with status 400 or more is never delayed, streaming or not,
+* and one with `json` answers in JSON even to a streaming request.
+*/
+async function serveRawResponse(ctx) {
+	const { wire, stream, req, res, fixture, journal, defaults, testId } = ctx;
+	const raw = ctx.response.raw;
+	const journalBase = {
+		method: req.method ?? "POST",
+		path: req.url ?? "/",
+		headers: require_helpers.flattenHeaders(req.headers),
+		body: ctx.body
+	};
+	const record = (entry) => require_misbehavior.recordMisbehaviorOutcome({
+		entry,
+		summary: ctx.misbehaviorSummary,
+		defaults,
+		testId
+	});
+	const status = raw.status ?? 200;
+	const errorReply = status >= 400;
+	const servesStream = stream && !(errorReply && raw.json !== void 0);
+	let failure;
+	const problems = require_raw_validation.checkRawResponse(raw, require_fixture_loader.rawFixtureContext(fixture, ctx.response)).filter((finding) => finding.severity === "error");
+	if (problems.length > 0) failure = {
+		code: RAW_FIXTURE_INVALID,
+		message: `invalid raw fixture: ${problems.map((p) => p.message).join("; ")}`
+	};
+	else if (raw.wire !== wire) failure = {
+		code: RAW_FIXTURE_INVALID,
+		message: `raw fixture is for ${raw.wire}, not ${wire}`
+	};
+	else if (servesStream ? raw.events === void 0 : raw.json === void 0) failure = {
+		code: RAW_MODE_UNAVAILABLE,
+		message: `raw fixture has no "${servesStream ? "events" : "json"}" body for a ${servesStream ? "streaming" : "non-streaming"} request on ${wire}`
+	};
+	if (failure) {
+		defaults.logger.error(`${journalBase.method} ${journalBase.path}: ${failure.message}`);
+		const entry = journal.add({
+			...journalBase,
+			response: {
+				status: 500,
+				fixture
+			}
+		});
+		entry.response.error = failure.message;
+		record(entry);
+		const rendered = renderRawError(ctx, failure.code, failure.message);
+		for (const [name, value] of Object.entries(rendered.headers ?? {})) res.setHeader(name, value);
+		require_sse_writer.writeErrorResponse(res, 500, rendered.body);
+		return;
+	}
+	const entry = journal.add({
+		...journalBase,
+		response: {
+			status,
+			fixture
+		}
+	});
+	record(entry);
+	if (servesStream) {
+		const events = raw.events;
+		if (events === void 0) throw new Error(`raw serve internal error: a streamed reply on ${wire} has no events`);
+		await require_deliver.deliverStream(res, entry, fixture, rawCodec(wire, raw), events, errorReply ? { latency: 0 } : {
+			latency: fixture.latency ?? defaults.latency,
+			streamingProfile: fixture.streamingProfile,
+			recordedTimings: fixture.recordedTimings,
+			replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed
+		}, { status: raw.status });
+		return;
+	}
+	const json = raw.json;
+	if (json === void 0) throw new Error(`raw serve internal error: a JSON reply on ${wire} has no json`);
+	const servedLength = JSON.stringify(json).length;
+	await require_deliver.deliverJson(res, entry, errorReply ? {
+		...fixture,
+		nonStreamingTiming: false,
+		nonStreamingTimingAllProviders: false
+	} : fixture, () => json, {
+		surface: wire === "openai-chat" ? "openai-chat" : "other",
+		status: raw.status,
+		payloadLength: servedLength,
+		chunkSize: Math.max(1, fixture.chunkSize ?? defaults.chunkSize),
+		recordedTimings: fixture.recordedTimings,
+		replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
+		headers: overrideHeaders(JSON_HEADERS, raw.headers)
+	});
+}
+
+//#endregion
+exports.RAW_MODE_UNAVAILABLE = RAW_MODE_UNAVAILABLE;
+exports.serveRawResponse = serveRawResponse;
+//# sourceMappingURL=raw.cjs.map

package/dist/response/raw.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw.cjs","names":["sseCodec","ndjsonCodec","eventStreamCodec","encodeEventStreamMessage","serializeOpenRouterError","renderError","flattenHeaders","recordMisbehaviorOutcome","checkRawResponse","rawFixtureContext","deliverStream","deliverJson"],"sources":["../../src/response/raw.ts"],"sourcesContent":["/**\n * @internal Raw passthrough fixtures (#549): per-wire framing and serving.\n *\n * A raw fixture supplies event objects; aimock adds only the named wire's\n * framing, using exactly the bytes the typed handlers write for that wire:\n *\n * - named SSE (`openai-responses`, `anthropic`, `cohere`):\n *   `event: <type>\\ndata: <json>\\n\\n`\n * - data SSE (`openai-chat`, `gemini`, `gemini-interactions`): `data: <json>\\n\\n`;\n *   `openai-chat` ends with `data: [DONE]\\n\\n` unless `raw.done === false`\n * - NDJSON (`ollama`, `ollama-generate`): `<json>\\n`\n * - AWS event stream: `bedrock-invoke` wraps each event as a `chunk` frame with\n *   base64 `bytes`; `bedrock-converse` takes the event's single key as the\n *   frame's event type and its value as the payload.\n *\n * The framing functions are pure. `serveRawResponse` checks and journals the\n * fixture. It writes one reply itself: the untimed 500 for a fixture that\n * fails a check, targets another wire or has no body for the request mode.\n * Every other reply goes through the shared delivery layer (`deliverStream`,\n * `deliverJson`), which owns the delay loop, writability checks and abort\n * handling. A reply with a status of 400 or more is never delayed.\n */\nimport type * as http from \"node:http\";\nimport { encodeEventStreamMessage, eventStreamCodec } from \"../aws-event-stream.js\";\nimport { rawFixtureContext } from \"../fixture-loader.js\";\nimport { flattenHeaders } from \"../helpers.js\";\nimport type { Journal } from \"../journal.js\";\nimport { recordMisbehaviorOutcome, type MisbehaviorSummary } from \"../misbehavior.js\";\nimport { serializeOpenRouterError } from \"../openrouter-chat.js\";\nimport { ndjsonCodec } from \"../ndjson-writer.js\";\nimport { checkRawResponse } from \"../raw-validation.js\";\nimport { sseCodec, writeErrorResponse } from \"../sse-writer.js\";\nimport type { Fixture, HandlerDefaults, JournalEntry, RawResponse, RawWireId } from \"../types.js\";\nimport { deliverJson, deliverStream } from \"./deliver.js\";\nimport { renderError } from \"./errors.js\";\nimport type { FrameCodec } from \"./frame-loop.js\";\nimport type { ErrorWire } from \"./profiles.js\";\n\n/** The streaming Content-Type each wire's typed handler sends. */\nexport function rawContentType(wire: RawWireId): string {\n  switch (wire) {\n    case \"openai-responses\":\n    case \"openai-chat\":\n    case \"anthropic\":\n    case \"gemini\":\n    case \"gemini-interactions\":\n    case \"cohere\":\n      return \"text/event-stream\";\n    case \"ollama\":\n    case \"ollama-generate\":\n      return \"application/x-ndjson\";\n    case \"bedrock-invoke\":\n    case \"bedrock-converse\":\n      return \"application/vnd.amazon.eventstream\";\n  }\n}\n\n/**\n * The default headers of the typed stream on `wire`, read from the typed\n * codec: SSE and NDJSON add `Cache-Control: no-cache` and\n * `Connection: keep-alive`, the AWS event stream `Transfer-Encoding: chunked`.\n */\nfunction rawStreamHeaders(wire: RawWireId): Record<string, string> {\n  switch (wire) {\n    case \"openai-responses\":\n    case \"openai-chat\":\n    case \"anthropic\":\n    case \"gemini\":\n    case \"gemini-interactions\":\n    case \"cohere\":\n      return sseCodec({ done: false }).headers;\n    case \"ollama\":\n    case \"ollama-generate\":\n      return ndjsonCodec().headers;\n    case \"bedrock-invoke\":\n    case \"bedrock-converse\":\n      return eventStreamCodec().headers;\n  }\n}\n\n/** The non-streaming JSON default, as `deliverJson` sends it. */\nconst JSON_HEADERS: Readonly<Record<string, string>> = { \"Content-Type\": \"application/json\" };\n\n/**\n * `defaults` with each `authored` header laid over it. Header names are\n * case-insensitive: an authored header replaces the default of the same name\n * in any letter case and takes the default's spelling, so a later spread over\n * the same defaults (as `deliverJson` does) still has one key per name.\n */\nfunction overrideHeaders(\n  defaults: Readonly<Record<string, string>>,\n  authored: Readonly<Record<string, string>> | undefined,\n): Record<string, string> {\n  const merged: Record<string, string> = { ...defaults };\n  const spelling = new Map(Object.keys(defaults).map((name) => [name.toLowerCase(), name]));\n  for (const [name, value] of Object.entries(authored ?? {})) {\n    merged[spelling.get(name.toLowerCase()) ?? name] = value;\n  }\n  return merged;\n}\n\n/** One raw event, framed for `wire`. Events are checked before framing (raw-validation.ts). */\nexport function encodeRawFrame(wire: RawWireId, event: Record<string, unknown>): string | Buffer {\n  const json = JSON.stringify(event);\n  switch (wire) {\n    case \"openai-responses\":\n    case \"anthropic\":\n    case \"cohere\":\n      return `event: ${String(event.type)}\\ndata: ${json}\\n\\n`;\n    case \"openai-chat\":\n    case \"gemini\":\n    case \"gemini-interactions\":\n      return `data: ${json}\\n\\n`;\n    case \"ollama\":\n    case \"ollama-generate\":\n      return `${json}\\n`;\n    case \"bedrock-invoke\":\n      return encodeEventStreamMessage(\"chunk\", {\n        bytes: Buffer.from(json, \"utf8\").toString(\"base64\"),\n      });\n    case \"bedrock-converse\": {\n      // The checker guarantees exactly one key whose value is a JSON object.\n      const [eventType] = Object.keys(event);\n      const payload = event[eventType];\n      if (payload === null || typeof payload !== \"object\" || Array.isArray(payload)) {\n        throw new Error(\n          `raw framing internal error: bedrock-converse event \"${eventType}\" has no object payload`,\n        );\n      }\n      return encodeEventStreamMessage(eventType, payload);\n    }\n  }\n}\n\n/**\n * Bytes written after the last frame, if any. Only `openai-chat` has a\n * terminal (`data: [DONE]`), sent unless `raw.done === false` and never after\n * an interrupted stream.\n */\nexport function rawTrailer(\n  wire: RawWireId,\n  raw: RawResponse[\"raw\"],\n  aborted: boolean,\n): string | undefined {\n  if (wire === \"openai-chat\" && !aborted && raw.done !== false) return \"data: [DONE]\\n\\n\";\n  return undefined;\n}\n\n// ─── Serving ──────────────────────────────────────────────────────────────────\n\n/** The error code for a request the raw fixture has no body for. */\nexport const RAW_MODE_UNAVAILABLE = \"aimock_raw_mode_unavailable\";\n/** The error code for a raw fixture that fails its checks or targets another wire. */\nexport const RAW_FIXTURE_INVALID = \"aimock_raw_fixture_invalid\";\n\n/** Everything {@link serveRawResponse} needs from the calling handler. */\nexport interface RawServeContext {\n  wire: RawWireId;\n  /** Whether the request asked for a stream, as the handler decides it. */\n  stream: boolean;\n  req: http.IncomingMessage;\n  res: http.ServerResponse;\n  fixture: Fixture;\n  response: RawResponse;\n  /** The journaled request body, as the handler journals it. */\n  body: JournalEntry[\"body\"];\n  journal: Journal;\n  defaults: HandlerDefaults;\n  testId: string;\n  misbehaviorSummary?: MisbehaviorSummary;\n  /** The dialect of the handler's own `renderError(…, \"misbehavior\", …)` call. */\n  errorWire: ErrorWire;\n  /** OpenAI chat requests that arrived on the OpenRouter route. */\n  openRouter?: boolean;\n}\n\n/**\n * The raw events as a frame codec for the shared frame loop. Its headers are\n * the typed stream's defaults for `wire` with `raw.headers` laid over them.\n */\nexport function rawCodec(\n  wire: RawWireId,\n  raw: RawResponse[\"raw\"],\n): FrameCodec<Record<string, unknown>> {\n  return {\n    headers: overrideHeaders(rawStreamHeaders(wire), raw.headers),\n    encode: (event) => encodeRawFrame(wire, event),\n    trailer: (aborted) => {\n      const trailer = rawTrailer(wire, raw, aborted);\n      return trailer === undefined ? [] : [trailer];\n    },\n  };\n}\n\n/**\n * The error body for a raw 500, in the dialect of the handler's misbehavior\n * errors. Dialects with no code slot (Gemini, Ollama, OpenRouter) carry the\n * code as a message prefix.\n */\nfunction renderRawError(\n  ctx: RawServeContext,\n  code: string,\n  message: string,\n): { body: string; headers?: Record<string, string> } {\n  if (ctx.openRouter) return { body: serializeOpenRouterError(500, `${code}: ${message}`) };\n  switch (ctx.errorWire) {\n    case \"openai\":\n      return renderError(\"openai\", \"misbehavior\", {\n        message,\n        type: \"server_error\",\n        ...(ctx.wire === \"openai-chat\" ? { param: null, includeParam: true as const } : {}),\n        code,\n      });\n    case \"messages\":\n      return renderError(\"messages\", \"misbehavior\", { type: \"api_error\", code, message });\n    case \"gemini\":\n      return renderError(\"gemini\", \"misbehavior\", {\n        bodyCode: 500,\n        message: `${code}: ${message}`,\n        status: \"INTERNAL\",\n      });\n    case \"bedrock\":\n    case \"bedrock-converse\":\n      return renderError(ctx.errorWire, \"misbehavior\", {\n        type: \"InternalServerException\",\n        code,\n        message,\n      });\n    default:\n      return renderError(ctx.errorWire, \"misbehavior\", { code, message });\n  }\n}\n\n/**\n * Serve a raw passthrough fixture on the handler's wire: check it, journal it,\n * and send its events or JSON through the shared delivery layer. A fixture\n * that fails a check, targets another wire, or has no body for the requested\n * mode gets a 500 in the handler's misbehavior error dialect, and an error log\n * line. A reply with status 400 or more is never delayed, streaming or not,\n * and one with `json` answers in JSON even to a streaming request.\n */\nexport async function serveRawResponse(ctx: RawServeContext): Promise<void> {\n  const { wire, stream, req, res, fixture, journal, defaults, testId } = ctx;\n  const raw = ctx.response.raw;\n  const journalBase = {\n    method: req.method ?? \"POST\",\n    path: req.url ?? \"/\",\n    headers: flattenHeaders(req.headers),\n    body: ctx.body,\n  };\n  const record = (entry: JournalEntry): void =>\n    recordMisbehaviorOutcome({ entry, summary: ctx.misbehaviorSummary, defaults, testId });\n\n  const status = raw.status ?? 200;\n  // An error reply (status >= 400) is never delayed, streaming or not, as\n  // typed error replies are not. Fixture interruptions still apply.\n  const errorReply = status >= 400;\n  // An error status with a JSON body answers in JSON even to a streaming\n  // request, as provider APIs do; the JSON wins over any events.\n  const servesStream = stream && !(errorReply && raw.json !== undefined);\n\n  let failure: { code: string; message: string } | undefined;\n  const problems = checkRawResponse(raw, rawFixtureContext(fixture, ctx.response)).filter(\n    (finding) => finding.severity === \"error\",\n  );\n  if (problems.length > 0) {\n    failure = {\n      code: RAW_FIXTURE_INVALID,\n      message: `invalid raw fixture: ${problems.map((p) => p.message).join(\"; \")}`,\n    };\n  } else if (raw.wire !== wire) {\n    failure = { code: RAW_FIXTURE_INVALID, message: `raw fixture is for ${raw.wire}, not ${wire}` };\n  } else if (servesStream ? raw.events === undefined : raw.json === undefined) {\n    failure = {\n      code: RAW_MODE_UNAVAILABLE,\n      message: `raw fixture has no \"${servesStream ? \"events\" : \"json\"}\" body for a ${\n        servesStream ? \"streaming\" : \"non-streaming\"\n      } request on ${wire}`,\n    };\n  }\n  if (failure) {\n    defaults.logger.error(`${journalBase.method} ${journalBase.path}: ${failure.message}`);\n    const entry = journal.add({ ...journalBase, response: { status: 500, fixture } });\n    entry.response.error = failure.message;\n    record(entry);\n    const rendered = renderRawError(ctx, failure.code, failure.message);\n    for (const [name, value] of Object.entries(rendered.headers ?? {})) res.setHeader(name, value);\n    writeErrorResponse(res, 500, rendered.body);\n    return;\n  }\n\n  const entry = journal.add({ ...journalBase, response: { status, fixture } });\n  record(entry);\n\n  if (servesStream) {\n    const events = raw.events;\n    if (events === undefined) {\n      throw new Error(`raw serve internal error: a streamed reply on ${wire} has no events`);\n    }\n    await deliverStream(\n      res,\n      entry,\n      fixture,\n      rawCodec(wire, raw),\n      events,\n      errorReply\n        ? { latency: 0 }\n        : {\n            latency: fixture.latency ?? defaults.latency,\n            streamingProfile: fixture.streamingProfile,\n            recordedTimings: fixture.recordedTimings,\n            replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,\n          },\n      // The codec already carries raw.headers over its defaults.\n      { status: raw.status },\n    );\n    return;\n  }\n\n  // The wait is sized from the served JSON, as typed replies size theirs from\n  // the served content, in chunks of the fixture's or server's chunk size.\n  const json = raw.json;\n  if (json === undefined) {\n    throw new Error(`raw serve internal error: a JSON reply on ${wire} has no json`);\n  }\n  const servedLength = JSON.stringify(json).length;\n  // deliverJson reads the timing opt-ins from the fixture. With them off, an\n  // error reply still gets its writability check and journaling, but no wait.\n  await deliverJson(\n    res,\n    entry,\n    errorReply\n      ? { ...fixture, nonStreamingTiming: false, nonStreamingTimingAllProviders: false }\n      : fixture,\n    () => json,\n    {\n      surface: wire === \"openai-chat\" ? \"openai-chat\" : \"other\",\n      status: raw.status,\n      payloadLength: servedLength,\n      chunkSize: Math.max(1, fixture.chunkSize ?? defaults.chunkSize),\n      recordedTimings: fixture.recordedTimings,\n      replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,\n      headers: overrideHeaders(JSON_HEADERS, raw.headers),\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA8DA,SAAS,iBAAiB,MAAyC;AACjE,SAAQ,MAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,SACH,QAAOA,4BAAS,EAAE,MAAM,OAAO,CAAC,CAAC;EACnC,KAAK;EACL,KAAK,kBACH,QAAOC,mCAAa,CAAC;EACvB,KAAK;EACL,KAAK,mBACH,QAAOC,2CAAkB,CAAC;;;;AAKhC,MAAM,eAAiD,EAAE,gBAAgB,oBAAoB;;;;;;;AAQ7F,SAAS,gBACP,UACA,UACwB;CACxB,MAAM,SAAiC,EAAE,GAAG,UAAU;CACtD,MAAM,WAAW,IAAI,IAAI,OAAO,KAAK,SAAS,CAAC,KAAK,SAAS,CAAC,KAAK,aAAa,EAAE,KAAK,CAAC,CAAC;AACzF,MAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,YAAY,EAAE,CAAC,CACxD,QAAO,SAAS,IAAI,KAAK,aAAa,CAAC,IAAI,QAAQ;AAErD,QAAO;;;AAIT,SAAgB,eAAe,MAAiB,OAAiD;CAC/F,MAAM,OAAO,KAAK,UAAU,MAAM;AAClC,SAAQ,MAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK,SACH,QAAO,UAAU,OAAO,MAAM,KAAK,CAAC,UAAU,KAAK;EACrD,KAAK;EACL,KAAK;EACL,KAAK,sBACH,QAAO,SAAS,KAAK;EACvB,KAAK;EACL,KAAK,kBACH,QAAO,GAAG,KAAK;EACjB,KAAK,iBACH,QAAOC,kDAAyB,SAAS,EACvC,OAAO,OAAO,KAAK,MAAM,OAAO,CAAC,SAAS,SAAS,EACpD,CAAC;EACJ,KAAK,oBAAoB;GAEvB,MAAM,CAAC,aAAa,OAAO,KAAK,MAAM;GACtC,MAAM,UAAU,MAAM;AACtB,OAAI,YAAY,QAAQ,OAAO,YAAY,YAAY,MAAM,QAAQ,QAAQ,CAC3E,OAAM,IAAI,MACR,uDAAuD,UAAU,yBAClE;AAEH,UAAOA,kDAAyB,WAAW,QAAQ;;;;;;;;;AAUzD,SAAgB,WACd,MACA,KACA,SACoB;AACpB,KAAI,SAAS,iBAAiB,CAAC,WAAW,IAAI,SAAS,MAAO,QAAO;;;AAOvE,MAAa,uBAAuB;;AAEpC,MAAa,sBAAsB;;;;;AA2BnC,SAAgB,SACd,MACA,KACqC;AACrC,QAAO;EACL,SAAS,gBAAgB,iBAAiB,KAAK,EAAE,IAAI,QAAQ;EAC7D,SAAS,UAAU,eAAe,MAAM,MAAM;EAC9C,UAAU,YAAY;GACpB,MAAM,UAAU,WAAW,MAAM,KAAK,QAAQ;AAC9C,UAAO,YAAY,SAAY,EAAE,GAAG,CAAC,QAAQ;;EAEhD;;;;;;;AAQH,SAAS,eACP,KACA,MACA,SACoD;AACpD,KAAI,IAAI,WAAY,QAAO,EAAE,MAAMC,iDAAyB,KAAK,GAAG,KAAK,IAAI,UAAU,EAAE;AACzF,SAAQ,IAAI,WAAZ;EACE,KAAK,SACH,QAAOC,2BAAY,UAAU,eAAe;GAC1C;GACA,MAAM;GACN,GAAI,IAAI,SAAS,gBAAgB;IAAE,OAAO;IAAM,cAAc;IAAe,GAAG,EAAE;GAClF;GACD,CAAC;EACJ,KAAK,WACH,QAAOA,2BAAY,YAAY,eAAe;GAAE,MAAM;GAAa;GAAM;GAAS,CAAC;EACrF,KAAK,SACH,QAAOA,2BAAY,UAAU,eAAe;GAC1C,UAAU;GACV,SAAS,GAAG,KAAK,IAAI;GACrB,QAAQ;GACT,CAAC;EACJ,KAAK;EACL,KAAK,mBACH,QAAOA,2BAAY,IAAI,WAAW,eAAe;GAC/C,MAAM;GACN;GACA;GACD,CAAC;EACJ,QACE,QAAOA,2BAAY,IAAI,WAAW,eAAe;GAAE;GAAM;GAAS,CAAC;;;;;;;;;;;AAYzE,eAAsB,iBAAiB,KAAqC;CAC1E,MAAM,EAAE,MAAM,QAAQ,KAAK,KAAK,SAAS,SAAS,UAAU,WAAW;CACvE,MAAM,MAAM,IAAI,SAAS;CACzB,MAAM,cAAc;EAClB,QAAQ,IAAI,UAAU;EACtB,MAAM,IAAI,OAAO;EACjB,SAASC,+BAAe,IAAI,QAAQ;EACpC,MAAM,IAAI;EACX;CACD,MAAM,UAAU,UACdC,6CAAyB;EAAE;EAAO,SAAS,IAAI;EAAoB;EAAU;EAAQ,CAAC;CAExF,MAAM,SAAS,IAAI,UAAU;CAG7B,MAAM,aAAa,UAAU;CAG7B,MAAM,eAAe,UAAU,EAAE,cAAc,IAAI,SAAS;CAE5D,IAAI;CACJ,MAAM,WAAWC,wCAAiB,KAAKC,yCAAkB,SAAS,IAAI,SAAS,CAAC,CAAC,QAC9E,YAAY,QAAQ,aAAa,QACnC;AACD,KAAI,SAAS,SAAS,EACpB,WAAU;EACR,MAAM;EACN,SAAS,wBAAwB,SAAS,KAAK,MAAM,EAAE,QAAQ,CAAC,KAAK,KAAK;EAC3E;UACQ,IAAI,SAAS,KACtB,WAAU;EAAE,MAAM;EAAqB,SAAS,sBAAsB,IAAI,KAAK,QAAQ;EAAQ;UACtF,eAAe,IAAI,WAAW,SAAY,IAAI,SAAS,OAChE,WAAU;EACR,MAAM;EACN,SAAS,uBAAuB,eAAe,WAAW,OAAO,eAC/D,eAAe,cAAc,gBAC9B,cAAc;EAChB;AAEH,KAAI,SAAS;AACX,WAAS,OAAO,MAAM,GAAG,YAAY,OAAO,GAAG,YAAY,KAAK,IAAI,QAAQ,UAAU;EACtF,MAAM,QAAQ,QAAQ,IAAI;GAAE,GAAG;GAAa,UAAU;IAAE,QAAQ;IAAK;IAAS;GAAE,CAAC;AACjF,QAAM,SAAS,QAAQ,QAAQ;AAC/B,SAAO,MAAM;EACb,MAAM,WAAW,eAAe,KAAK,QAAQ,MAAM,QAAQ,QAAQ;AACnE,OAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,SAAS,WAAW,EAAE,CAAC,CAAE,KAAI,UAAU,MAAM,MAAM;AAC9F,wCAAmB,KAAK,KAAK,SAAS,KAAK;AAC3C;;CAGF,MAAM,QAAQ,QAAQ,IAAI;EAAE,GAAG;EAAa,UAAU;GAAE;GAAQ;GAAS;EAAE,CAAC;AAC5E,QAAO,MAAM;AAEb,KAAI,cAAc;EAChB,MAAM,SAAS,IAAI;AACnB,MAAI,WAAW,OACb,OAAM,IAAI,MAAM,iDAAiD,KAAK,gBAAgB;AAExF,QAAMC,8BACJ,KACA,OACA,SACA,SAAS,MAAM,IAAI,EACnB,QACA,aACI,EAAE,SAAS,GAAG,GACd;GACE,SAAS,QAAQ,WAAW,SAAS;GACrC,kBAAkB,QAAQ;GAC1B,iBAAiB,QAAQ;GACzB,aAAa,QAAQ,eAAe,SAAS;GAC9C,EAEL,EAAE,QAAQ,IAAI,QAAQ,CACvB;AACD;;CAKF,MAAM,OAAO,IAAI;AACjB,KAAI,SAAS,OACX,OAAM,IAAI,MAAM,6CAA6C,KAAK,cAAc;CAElF,MAAM,eAAe,KAAK,UAAU,KAAK,CAAC;AAG1C,OAAMC,4BACJ,KACA,OACA,aACI;EAAE,GAAG;EAAS,oBAAoB;EAAO,gCAAgC;EAAO,GAChF,eACE,MACN;EACE,SAAS,SAAS,gBAAgB,gBAAgB;EAClD,QAAQ,IAAI;EACZ,eAAe;EACf,WAAW,KAAK,IAAI,GAAG,QAAQ,aAAa,SAAS,UAAU;EAC/D,iBAAiB,QAAQ;EACzB,aAAa,QAAQ,eAAe,SAAS;EAC7C,SAAS,gBAAgB,cAAc,IAAI,QAAQ;EACpD,CACF"}