@effect-uai/core 0.12.0 → 0.12.1

package/dist/streaming/Lines.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Lines.mjs","names":[],"sources":["../../src/streaming/Lines.ts"],"sourcesContent":["import { Stream } from \"effect\"\n\n/**\n * Split a string stream on `\\n`, emitting one line per element. Buffers\n * partial chunks until a newline arrives, and flushes any non-newline\n * tail at stream end - so streams that don't terminate with `\\n`\n * (typical of LLM token streams) still get their last line. Empty lines\n * are dropped, `\\r` is stripped (handles `\\r\\n` endings).\n *\n * Intended use: feed text deltas from a model that has been prompted to\n * emit JSONL (or any other newline-delimited format), then parse /\n * validate each emitted line.\n */\nexport const lines = <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<string, E, R> =>\n  linesStrict(Stream.concat(self, Stream.make(\"\\n\")))\n\n/**\n * Like `lines`, but only emits lines that were terminated by `\\n`. Any\n * partial trailing content is dropped at stream end. Use when you want\n * strict \"complete-line-or-nothing\" semantics.\n */\nexport const linesStrict = <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.mapAccum(\n      (): string => \"\",\n      (buffer, chunk: string) => {\n        const combined = buffer + chunk\n        const parts = combined.split(\"\\n\")\n        const tail = parts.pop() ?? \"\"\n        return [tail, parts.map((line) => line.replace(/\\r/g, \"\"))] as const\n      },\n    ),\n    Stream.filter((line) => line.trim().length > 0),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;AAaA,MAAa,SAAe,SAC1B,YAAY,OAAO,OAAO,MAAM,OAAO,KAAK,KAAK,CAAC,CAAC;;;;;;AAOrD,MAAa,eAAqB,SAChC,KAAK,KACH,OAAO,eACS,KACb,QAAQ,UAAkB;CAEzB,MAAM,SADW,SAAS,OACH,MAAM,KAAK;AAElC,QAAO,CADM,MAAM,KAAK,IAAI,IACd,MAAM,KAAK,SAAS,KAAK,QAAQ,OAAO,GAAG,CAAC,CAAC;EAE9D,EACD,OAAO,QAAQ,SAAS,KAAK,MAAM,CAAC,SAAS,EAAE,CAChD"}
+{"version":3,"file":"Lines.mjs","names":[],"sources":["../../src/streaming/Lines.ts"],"sourcesContent":["import { Stream } from \"effect\"\n\n/**\n * Split a string stream on `\\n`, emitting one line per element. Buffers\n * partial chunks until a newline arrives, and flushes any non-newline\n * tail at stream end - so streams that don't terminate with `\\n`\n * (typical of LLM token streams) still get their last line. Empty lines\n * are dropped, `\\r` is stripped (handles `\\r\\n` endings).\n *\n * Intended use: feed text deltas from a model that has been prompted to\n * emit JSONL (or any other newline-delimited format), then parse /\n * validate each emitted line.\n */\nexport const lines = <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<string, E, R> =>\n  linesStrict(Stream.concat(self, Stream.make(\"\\n\")))\n\n/**\n * Like `lines`, but only emits lines that were terminated by `\\n`. Any\n * partial trailing content is dropped at stream end. Use when you want\n * strict \"complete-line-or-nothing\" semantics.\n */\nexport const linesStrict = <E, R>(self: Stream.Stream<string, E, R>): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.mapAccum(\n      (): string => \"\",\n      (buffer, chunk: string) => {\n        const combined = buffer + chunk\n        const parts = combined.split(\"\\n\")\n        const tail = parts.pop() ?? \"\"\n        return [tail, parts.map((line) => line.replace(/\\r/g, \"\"))] as const\n      },\n    ),\n    Stream.filter((line) => line.trim().length > 0),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;AAaA,MAAa,SAAe,SAC1B,YAAY,OAAO,OAAO,MAAM,OAAO,KAAK,IAAI,CAAC,CAAC;;;;;;AAOpD,MAAa,eAAqB,SAChC,KAAK,KACH,OAAO,eACS,KACb,QAAQ,UAAkB;CAEzB,MAAM,SADW,SAAS,MAAA,CACH,MAAM,IAAI;CAEjC,OAAO,CADM,MAAM,IAAI,KAAK,IACd,MAAM,KAAK,SAAS,KAAK,QAAQ,OAAO,EAAE,CAAC,CAAC;AAC5D,CACF,GACA,OAAO,QAAQ,SAAS,KAAK,KAAK,CAAC,CAAC,SAAS,CAAC,CAChD"}

package/dist/streaming/SSE.d.mts

@@ -1,6 +1,4 @@
 import { Stream } from "effect";
-
-//#region src/streaming/SSE.d.ts
 declare namespace SSE_d_exports {
   export { Event, fromBytes, toBytes };
 }

package/dist/streaming/SSE.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"SSE.d.mts","names":[],"sources":["../../src/streaming/SSE.ts"],"mappings":";;;;;;;;;;;;KASY,KAAA;EAAA,SACD,KAAA;EAAA,SACA,IAAA;EAAA,SACA,EAAA;AAAA;;;;;;;AA8BX;cAAa,SAAA,SACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA,MAClC,MAAA,CAAO,MAAA,CAAO,KAAA,EAAO,CAAA,EAAG,CAAA;;;;;cAed,OAAA,SAAiB,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,KAAA,EAAO,CAAA,EAAG,CAAA,MAAK,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,CAAA,EAAG,CAAA"}
+{"version":3,"file":"SSE.d.mts","names":[],"sources":["../../src/streaming/SSE.ts"],"mappings":";;;;;;;;;;KASY;WACD;WACA;WACA;;;;;;;;;cA8BE,YAAa,GAAG,GAAC,MACtB,OAAO,OAAO,YAAY,GAAG,OAClC,OAAO,OAAO,OAAO,GAAG;;;;;cAed,UAAW,GAAG,GAAC,MAAQ,OAAO,OAAO,OAAO,GAAG,OAAK,OAAO,OAAO,YAAY,GAAG"}

package/dist/streaming/SSE.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 import { Stream } from "effect";
 import { Sse } from "effect/unstable/encoding";
 //#region src/streaming/SSE.ts

package/dist/streaming/SSE.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"SSE.mjs","names":[],"sources":["../../src/streaming/SSE.ts"],"sourcesContent":["import { Stream } from \"effect\"\nimport { Sse } from \"effect/unstable/encoding\"\n\n/**\n * One Server-Sent Event. Fields per the WHATWG spec:\n * - `event`: optional event name (absent for the default \"message\")\n * - `data`: payload, with multiple `data:` lines joined by `\\n`\n * - `id`: optional last-event id\n */\nexport type Event = {\n  readonly event?: string\n  readonly data: string\n  readonly id?: string\n}\n\nconst toEvent = (wire: Sse.Event): Event => ({\n  data: wire.data,\n  ...(wire.event !== \"message\" && { event: wire.event }),\n  ...(wire.id !== undefined && { id: wire.id }),\n})\n\ntype ParserState = {\n  readonly parser: Sse.Parser\n  readonly out: Array<Event>\n}\n\nconst makeParserState = (): ParserState => {\n  const out: Array<Event> = []\n  const parser = Sse.makeParser((event) => {\n    // `retry:` reconnection hints have no representation in `Event`\n    if (event._tag === \"Event\") out.push(toEvent(event))\n  })\n  return { parser, out }\n}\n\n/**\n * Decode a `Stream<Uint8Array>` (e.g. an HTTP response body) into a\n * `Stream<SSE.Event>`, using the spec parser from `effect/unstable/encoding`.\n * An event is dispatched only once its terminating blank line arrives, so a\n * partial event at stream end (clean or failed) is discarded per the spec\n * rather than surfaced as a truncated frame.\n */\nexport const fromBytes = <E, R>(\n  self: Stream.Stream<Uint8Array, E, R>,\n): Stream.Stream<Event, E, R> =>\n  self.pipe(\n    Stream.decodeText,\n    Stream.mapAccum(makeParserState, (state, text: string) => {\n      state.parser.feed(text)\n      return [state, state.out.splice(0)] as const\n    }),\n  )\n\nconst encoder = new TextEncoder()\n\n/**\n * Encode a `Stream<Event>` as `Stream<Uint8Array>` ready to send on an\n * HTTP response with `Content-Type: text/event-stream`.\n */\nexport const toBytes = <E, R>(self: Stream.Stream<Event, E, R>): Stream.Stream<Uint8Array, E, R> =>\n  Stream.map(self, (ev) =>\n    encoder.encode(\n      Sse.encoder.write({\n        _tag: \"Event\",\n        event: ev.event ?? \"message\",\n        id: ev.id,\n        data: ev.data,\n      }),\n    ),\n  )\n"],"mappings":";;;;;;;;AAeA,MAAM,WAAW,UAA4B;CAC3C,MAAM,KAAK;CACX,GAAI,KAAK,UAAU,aAAa,EAAE,OAAO,KAAK,OAAO;CACrD,GAAI,KAAK,OAAO,KAAA,KAAa,EAAE,IAAI,KAAK,IAAI;CAC7C;AAOD,MAAM,wBAAqC;CACzC,MAAM,MAAoB,EAAE;AAK5B,QAAO;EAAE,QAJM,IAAI,YAAY,UAAU;AAEvC,OAAI,MAAM,SAAS,QAAS,KAAI,KAAK,QAAQ,MAAM,CAAC;IAEvC;EAAE;EAAK;;;;;;;;;AAUxB,MAAa,aACX,SAEA,KAAK,KACH,OAAO,YACP,OAAO,SAAS,kBAAkB,OAAO,SAAiB;AACxD,OAAM,OAAO,KAAK,KAAK;AACvB,QAAO,CAAC,OAAO,MAAM,IAAI,OAAO,EAAE,CAAC;EACnC,CACH;AAEH,MAAM,UAAU,IAAI,aAAa;;;;;AAMjC,MAAa,WAAiB,SAC5B,OAAO,IAAI,OAAO,OAChB,QAAQ,OACN,IAAI,QAAQ,MAAM;CAChB,MAAM;CACN,OAAO,GAAG,SAAS;CACnB,IAAI,GAAG;CACP,MAAM,GAAG;CACV,CAAC,CACH,CACF"}
+{"version":3,"file":"SSE.mjs","names":[],"sources":["../../src/streaming/SSE.ts"],"sourcesContent":["import { Stream } from \"effect\"\nimport { Sse } from \"effect/unstable/encoding\"\n\n/**\n * One Server-Sent Event. Fields per the WHATWG spec:\n * - `event`: optional event name (absent for the default \"message\")\n * - `data`: payload, with multiple `data:` lines joined by `\\n`\n * - `id`: optional last-event id\n */\nexport type Event = {\n  readonly event?: string\n  readonly data: string\n  readonly id?: string\n}\n\nconst toEvent = (wire: Sse.Event): Event => ({\n  data: wire.data,\n  ...(wire.event !== \"message\" && { event: wire.event }),\n  ...(wire.id !== undefined && { id: wire.id }),\n})\n\ntype ParserState = {\n  readonly parser: Sse.Parser\n  readonly out: Array<Event>\n}\n\nconst makeParserState = (): ParserState => {\n  const out: Array<Event> = []\n  const parser = Sse.makeParser((event) => {\n    // `retry:` reconnection hints have no representation in `Event`\n    if (event._tag === \"Event\") out.push(toEvent(event))\n  })\n  return { parser, out }\n}\n\n/**\n * Decode a `Stream<Uint8Array>` (e.g. an HTTP response body) into a\n * `Stream<SSE.Event>`, using the spec parser from `effect/unstable/encoding`.\n * An event is dispatched only once its terminating blank line arrives, so a\n * partial event at stream end (clean or failed) is discarded per the spec\n * rather than surfaced as a truncated frame.\n */\nexport const fromBytes = <E, R>(\n  self: Stream.Stream<Uint8Array, E, R>,\n): Stream.Stream<Event, E, R> =>\n  self.pipe(\n    Stream.decodeText,\n    Stream.mapAccum(makeParserState, (state, text: string) => {\n      state.parser.feed(text)\n      return [state, state.out.splice(0)] as const\n    }),\n  )\n\nconst encoder = new TextEncoder()\n\n/**\n * Encode a `Stream<Event>` as `Stream<Uint8Array>` ready to send on an\n * HTTP response with `Content-Type: text/event-stream`.\n */\nexport const toBytes = <E, R>(self: Stream.Stream<Event, E, R>): Stream.Stream<Uint8Array, E, R> =>\n  Stream.map(self, (ev) =>\n    encoder.encode(\n      Sse.encoder.write({\n        _tag: \"Event\",\n        event: ev.event ?? \"message\",\n        id: ev.id,\n        data: ev.data,\n      }),\n    ),\n  )\n"],"mappings":";;;;;;;;AAeA,MAAM,WAAW,UAA4B;CAC3C,MAAM,KAAK;CACX,GAAI,KAAK,UAAU,aAAa,EAAE,OAAO,KAAK,MAAM;CACpD,GAAI,KAAK,OAAO,KAAA,KAAa,EAAE,IAAI,KAAK,GAAG;AAC7C;AAOA,MAAM,wBAAqC;CACzC,MAAM,MAAoB,CAAC;CAK3B,OAAO;EAAE,QAJM,IAAI,YAAY,UAAU;GAEvC,IAAI,MAAM,SAAS,SAAS,IAAI,KAAK,QAAQ,KAAK,CAAC;EACrD,CACc;EAAG;CAAI;AACvB;;;;;;;;AASA,MAAa,aACX,SAEA,KAAK,KACH,OAAO,YACP,OAAO,SAAS,kBAAkB,OAAO,SAAiB;CACxD,MAAM,OAAO,KAAK,IAAI;CACtB,OAAO,CAAC,OAAO,MAAM,IAAI,OAAO,CAAC,CAAC;AACpC,CAAC,CACH;AAEF,MAAM,UAAU,IAAI,YAAY;;;;;AAMhC,MAAa,WAAiB,SAC5B,OAAO,IAAI,OAAO,OAChB,QAAQ,OACN,IAAI,QAAQ,MAAM;CAChB,MAAM;CACN,OAAO,GAAG,SAAS;CACnB,IAAI,GAAG;CACP,MAAM,GAAG;AACX,CAAC,CACH,CACF"}

package/dist/streaming/SSE.test.d.mts

@@ -1 +1 @@
-export { };
+export {}

package/dist/streaming/SSE.test.mjs

@@ -1,5 +1,6 @@
 import { fromBytes, toBytes } from "./SSE.mjs";
-import { c as it, n as globalExpect, o as describe } from "../dist-CcRV3-A5.mjs";
+import { m as it, o as describe } from "../utils-CiH_DjFW.mjs";
+import { n as globalExpect } from "../test.DNmyFkvJ-YPzDR0Co.mjs";
 import { Cause, Deferred, Effect, Exit, Fiber, Result, Stream } from "effect";
 //#region src/streaming/SSE.test.ts
 const enc = new TextEncoder();
@@ -12,16 +13,19 @@ const runUntilEnd = (s) => Effect.runPromise(s.pipe(Stream.result, Stream.runCol
 const failuresOf = (exit) => Exit.isFailure(exit) ? exit.cause.reasons.filter(Cause.isFailReason).map((r) => r.error) : [];
 describe("SSE.fromBytes", () => {
 	it("parses a single complete event", async () => {
-		globalExpect(await collect(fromBytes(bytesOf("event: foo\ndata: hello\n\n")))).toEqual([{
+		const out = await collect(fromBytes(bytesOf("event: foo\ndata: hello\n\n")));
+		globalExpect(out).toEqual([{
 			event: "foo",
 			data: "hello"
 		}]);
 	});
 	it("joins multiple data lines with \\n", async () => {
-		globalExpect(await collect(fromBytes(bytesOf("data: line1\ndata: line2\ndata: line3\n\n")))).toEqual([{ data: "line1\nline2\nline3" }]);
+		const out = await collect(fromBytes(bytesOf("data: line1\ndata: line2\ndata: line3\n\n")));
+		globalExpect(out).toEqual([{ data: "line1\nline2\nline3" }]);
 	});
 	it("handles events split across chunk boundaries", async () => {
-		globalExpect(await collect(fromBytes(bytesOf("event: split\nda", "ta: hi\n", "\nevent: next\ndata: x\n\n")))).toEqual([{
+		const out = await collect(fromBytes(bytesOf("event: split\nda", "ta: hi\n", "\nevent: next\ndata: x\n\n")));
+		globalExpect(out).toEqual([{
 			event: "split",
 			data: "hi"
 		}, {
@@ -30,34 +34,41 @@ describe("SSE.fromBytes", () => {
 		}]);
 	});
 	it("handles CRLF line endings", async () => {
-		globalExpect(await collect(fromBytes(bytesOf("event: a\r\ndata: b\r\n\r\n")))).toEqual([{
+		const out = await collect(fromBytes(bytesOf("event: a\r\ndata: b\r\n\r\n")));
+		globalExpect(out).toEqual([{
 			event: "a",
 			data: "b"
 		}]);
 	});
 	it("preserves id and skips comment lines", async () => {
-		globalExpect(await collect(fromBytes(bytesOf(": ping\nid: 42\ndata: x\n\n")))).toEqual([{
+		const out = await collect(fromBytes(bytesOf(": ping\nid: 42\ndata: x\n\n")));
+		globalExpect(out).toEqual([{
 			id: "42",
 			data: "x"
 		}]);
 	});
 	it("parses a data field with no space after the colon", async () => {
-		globalExpect(await collect(fromBytes(bytesOf("data:x\n\n")))).toEqual([{ data: "x" }]);
+		const out = await collect(fromBytes(bytesOf("data:x\n\n")));
+		globalExpect(out).toEqual([{ data: "x" }]);
 	});
 	it("ignores an id containing a NUL character", async () => {
-		globalExpect(await collect(fromBytes(bytesOf("id: a\0b\ndata: x\n\n")))).toEqual([{ data: "x" }]);
+		const out = await collect(fromBytes(bytesOf("id: a\0b\ndata: x\n\n")));
+		globalExpect(out).toEqual([{ data: "x" }]);
 	});
 	it("discards a trailing event without a closing blank line", async () => {
-		globalExpect(await collect(fromBytes(bytesOf("data: tail")))).toEqual([]);
+		const out = await collect(fromBytes(bytesOf("data: tail")));
+		globalExpect(out).toEqual([]);
 	});
 	it("discards buffered partial data when the upstream fails mid-stream", async () => {
-		const { seen, failures } = await runUntilEnd(fromBytes(Stream.concat(bytesOf("data: good\n\ndata: partial-tr"), Stream.fail("boom"))));
+		const failing = Stream.concat(bytesOf("data: good\n\ndata: partial-tr"), Stream.fail("boom"));
+		const { seen, failures } = await runUntilEnd(fromBytes(failing));
 		globalExpect(seen).toEqual([{ data: "good" }]);
 		globalExpect(failures).toEqual(["boom"]);
 	});
 	it("discards a partial multi-byte char in the text decoder when the upstream fails", async () => {
 		const partialSquid = enc.encode("data: 🦑\n\n").slice(0, 8);
-		const { seen, failures } = await runUntilEnd(fromBytes(Stream.concat(Stream.fromIterable([enc.encode("data: ok\n\n"), partialSquid]), Stream.fail("boom"))));
+		const failing = Stream.concat(Stream.fromIterable([enc.encode("data: ok\n\n"), partialSquid]), Stream.fail("boom"));
+		const { seen, failures } = await runUntilEnd(fromBytes(failing));
 		globalExpect(seen).toEqual([{ data: "ok" }]);
 		globalExpect(failures).toEqual(["boom"]);
 	});
@@ -81,22 +92,27 @@ describe("SSE.fromBytes", () => {
 		globalExpect(failuresOf(exit)).toEqual([]);
 	});
 	it("ignores retry directives", async () => {
-		globalExpect(await collect(fromBytes(bytesOf("retry: 3000\n\ndata: a\n\n")))).toEqual([{ data: "a" }]);
+		const out = await collect(fromBytes(bytesOf("retry: 3000\n\ndata: a\n\n")));
+		globalExpect(out).toEqual([{ data: "a" }]);
 	});
 	it("treats an explicit 'event: message' as the default event", async () => {
-		globalExpect(await collect(fromBytes(bytesOf("event: message\ndata: x\n\n")))).toEqual([{ data: "x" }]);
+		const out = await collect(fromBytes(bytesOf("event: message\ndata: x\n\n")));
+		globalExpect(out).toEqual([{ data: "x" }]);
 	});
 	it("does not dispatch events with no data", async () => {
-		globalExpect(await collect(fromBytes(bytesOf("event: ping\n\ndata: x\n\n")))).toEqual([{ data: "x" }]);
+		const out = await collect(fromBytes(bytesOf("event: ping\n\ndata: x\n\n")));
+		globalExpect(out).toEqual([{ data: "x" }]);
 	});
 	it("ignores empty blocks between events", async () => {
-		globalExpect(await collect(fromBytes(bytesOf("data: a\n\n\n\ndata: b\n\n")))).toEqual([{ data: "a" }, { data: "b" }]);
+		const out = await collect(fromBytes(bytesOf("data: a\n\n\n\ndata: b\n\n")));
+		globalExpect(out).toEqual([{ data: "a" }, { data: "b" }]);
 	});
 	it("handles a UTF-8 multi-byte char split across chunks", async () => {
 		const squidBytes = enc.encode("data: 🦑\n\n");
 		const a = squidBytes.slice(0, 8);
 		const b = squidBytes.slice(8);
-		globalExpect(await collect(fromBytes(Stream.fromIterable([a, b])))).toEqual([{ data: "🦑" }]);
+		const out = await collect(fromBytes(Stream.fromIterable([a, b])));
+		globalExpect(out).toEqual([{ data: "🦑" }]);
 	});
 });
 describe("SSE.toBytes round-trip", () => {
@@ -113,7 +129,8 @@ describe("SSE.toBytes round-trip", () => {
 				data: "x"
 			}
 		];
-		globalExpect(await collect(Stream.fromIterable(events).pipe(toBytes, fromBytes))).toEqual(events);
+		const reparsed = await collect(Stream.fromIterable(events).pipe(toBytes, fromBytes));
+		globalExpect(reparsed).toEqual(events);
 	});
 });
 //#endregion

package/dist/streaming/SSE.test.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"SSE.test.mjs","names":["SSE.fromBytes","SSE.toBytes"],"sources":["../../src/streaming/SSE.test.ts"],"sourcesContent":["import { Cause, Deferred, Effect, Exit, Fiber, Result, Stream } from \"effect\"\nimport { describe, expect, it } from \"vitest\"\nimport * as SSE from \"./SSE.js\"\n\nconst enc = new TextEncoder()\nconst bytesOf = (...chunks: ReadonlyArray<string>) =>\n  Stream.fromIterable(chunks.map((c) => enc.encode(c)))\n\nconst collect = <A, E>(s: Stream.Stream<A, E>) => Effect.runPromise(Stream.runCollect(s))\n\nconst runUntilEnd = <A, E>(s: Stream.Stream<A, E>) =>\n  Effect.runPromise(\n    s.pipe(\n      Stream.result,\n      Stream.runCollect,\n      Effect.map((results) => ({\n        seen: results.filter(Result.isSuccess).map((r) => r.success),\n        failures: results.filter(Result.isFailure).map((r) => r.failure),\n      })),\n    ),\n  )\n\nconst failuresOf = (exit: Exit.Exit<unknown, unknown>): ReadonlyArray<unknown> =>\n  Exit.isFailure(exit) ? exit.cause.reasons.filter(Cause.isFailReason).map((r) => r.error) : []\n\ndescribe(\"SSE.fromBytes\", () => {\n  it(\"parses a single complete event\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"event: foo\\ndata: hello\\n\\n\")))\n    expect(out).toEqual([{ event: \"foo\", data: \"hello\" }])\n  })\n\n  it(\"joins multiple data lines with \\\\n\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"data: line1\\ndata: line2\\ndata: line3\\n\\n\")))\n    expect(out).toEqual([{ data: \"line1\\nline2\\nline3\" }])\n  })\n\n  it(\"handles events split across chunk boundaries\", async () => {\n    const out = await collect(\n      SSE.fromBytes(bytesOf(\"event: split\\nda\", \"ta: hi\\n\", \"\\nevent: next\\ndata: x\\n\\n\")),\n    )\n    expect(out).toEqual([\n      { event: \"split\", data: \"hi\" },\n      { event: \"next\", data: \"x\" },\n    ])\n  })\n\n  it(\"handles CRLF line endings\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"event: a\\r\\ndata: b\\r\\n\\r\\n\")))\n    expect(out).toEqual([{ event: \"a\", data: \"b\" }])\n  })\n\n  it(\"preserves id and skips comment lines\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\": ping\\nid: 42\\ndata: x\\n\\n\")))\n    expect(out).toEqual([{ id: \"42\", data: \"x\" }])\n  })\n\n  it(\"parses a data field with no space after the colon\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"data:x\\n\\n\")))\n    expect(out).toEqual([{ data: \"x\" }])\n  })\n\n  it(\"ignores an id containing a NUL character\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"id: a\\u0000b\\ndata: x\\n\\n\")))\n    expect(out).toEqual([{ data: \"x\" }])\n  })\n\n  it(\"discards a trailing event without a closing blank line\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"data: tail\")))\n    expect(out).toEqual([])\n  })\n\n  it(\"discards buffered partial data when the upstream fails mid-stream\", async () => {\n    const failing = Stream.concat(\n      bytesOf(\"data: good\\n\\ndata: partial-tr\"),\n      Stream.fail(\"boom\" as const),\n    )\n    const { seen, failures } = await runUntilEnd(SSE.fromBytes(failing))\n    expect(seen).toEqual([{ data: \"good\" }])\n    expect(failures).toEqual([\"boom\"])\n  })\n\n  it(\"discards a partial multi-byte char in the text decoder when the upstream fails\", async () => {\n    const partialSquid = enc.encode(\"data: 🦑\\n\\n\").slice(0, 8)\n    const failing = Stream.concat(\n      Stream.fromIterable([enc.encode(\"data: ok\\n\\n\"), partialSquid]),\n      Stream.fail(\"boom\" as const),\n    )\n    const { seen, failures } = await runUntilEnd(SSE.fromBytes(failing))\n    expect(seen).toEqual([{ data: \"ok\" }])\n    expect(failures).toEqual([\"boom\"])\n  })\n\n  it(\"discards buffered partial data when the stream is interrupted\", async () => {\n    const { seen, exit } = await Effect.runPromise(\n      Effect.gen(function* () {\n        const seen: Array<SSE.Event> = []\n        const latch = yield* Deferred.make<void>()\n        const hanging = Stream.concat(bytesOf(\"data: good\\n\\ndata: partial\"), Stream.never)\n        const fiber = yield* Stream.runForEach(SSE.fromBytes(hanging), (e) =>\n          Effect.sync(() => {\n            seen.push(e)\n          }).pipe(Effect.andThen(Deferred.succeed(latch, void 0))),\n        ).pipe(Effect.forkChild)\n        yield* Deferred.await(latch)\n        yield* Fiber.interrupt(fiber)\n        const exit = yield* Fiber.await(fiber)\n        return { seen, exit }\n      }),\n    )\n    expect(seen).toEqual([{ data: \"good\" }])\n    expect(Exit.isFailure(exit)).toBe(true)\n    expect(failuresOf(exit)).toEqual([])\n  })\n\n  it(\"ignores retry directives\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"retry: 3000\\n\\ndata: a\\n\\n\")))\n    expect(out).toEqual([{ data: \"a\" }])\n  })\n\n  it(\"treats an explicit 'event: message' as the default event\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"event: message\\ndata: x\\n\\n\")))\n    expect(out).toEqual([{ data: \"x\" }])\n  })\n\n  it(\"does not dispatch events with no data\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"event: ping\\n\\ndata: x\\n\\n\")))\n    expect(out).toEqual([{ data: \"x\" }])\n  })\n\n  it(\"ignores empty blocks between events\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"data: a\\n\\n\\n\\ndata: b\\n\\n\")))\n    expect(out).toEqual([{ data: \"a\" }, { data: \"b\" }])\n  })\n\n  it(\"handles a UTF-8 multi-byte char split across chunks\", async () => {\n    // \"🦑\" is 0xF0 0x9F 0xA6 0x91. Split between bytes 2 and 3.\n    const squidBytes = enc.encode(\"data: 🦑\\n\\n\")\n    const a = squidBytes.slice(0, 8) // \"data: \" + first 2 bytes of squid\n    const b = squidBytes.slice(8) // remaining squid bytes + \"\\n\\n\"\n    const out = await collect(SSE.fromBytes(Stream.fromIterable([a, b])))\n    expect(out).toEqual([{ data: \"🦑\" }])\n  })\n})\n\ndescribe(\"SSE.toBytes round-trip\", () => {\n  it(\"re-parses what it serializes\", async () => {\n    const events: ReadonlyArray<SSE.Event> = [\n      { event: \"a\", data: \"hello\" },\n      { data: \"multi\\nline\" },\n      { event: \"b\", id: \"7\", data: \"x\" },\n    ]\n    const reparsed = await collect(Stream.fromIterable(events).pipe(SSE.toBytes, SSE.fromBytes))\n    expect(reparsed).toEqual(events)\n  })\n})\n"],"mappings":"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"}
+{"version":3,"file":"SSE.test.mjs","names":["SSE.fromBytes","SSE.toBytes"],"sources":["../../src/streaming/SSE.test.ts"],"sourcesContent":["import { Cause, Deferred, Effect, Exit, Fiber, Result, Stream } from \"effect\"\nimport { describe, expect, it } from \"vitest\"\nimport * as SSE from \"./SSE.js\"\n\nconst enc = new TextEncoder()\nconst bytesOf = (...chunks: ReadonlyArray<string>) =>\n  Stream.fromIterable(chunks.map((c) => enc.encode(c)))\n\nconst collect = <A, E>(s: Stream.Stream<A, E>) => Effect.runPromise(Stream.runCollect(s))\n\nconst runUntilEnd = <A, E>(s: Stream.Stream<A, E>) =>\n  Effect.runPromise(\n    s.pipe(\n      Stream.result,\n      Stream.runCollect,\n      Effect.map((results) => ({\n        seen: results.filter(Result.isSuccess).map((r) => r.success),\n        failures: results.filter(Result.isFailure).map((r) => r.failure),\n      })),\n    ),\n  )\n\nconst failuresOf = (exit: Exit.Exit<unknown, unknown>): ReadonlyArray<unknown> =>\n  Exit.isFailure(exit) ? exit.cause.reasons.filter(Cause.isFailReason).map((r) => r.error) : []\n\ndescribe(\"SSE.fromBytes\", () => {\n  it(\"parses a single complete event\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"event: foo\\ndata: hello\\n\\n\")))\n    expect(out).toEqual([{ event: \"foo\", data: \"hello\" }])\n  })\n\n  it(\"joins multiple data lines with \\\\n\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"data: line1\\ndata: line2\\ndata: line3\\n\\n\")))\n    expect(out).toEqual([{ data: \"line1\\nline2\\nline3\" }])\n  })\n\n  it(\"handles events split across chunk boundaries\", async () => {\n    const out = await collect(\n      SSE.fromBytes(bytesOf(\"event: split\\nda\", \"ta: hi\\n\", \"\\nevent: next\\ndata: x\\n\\n\")),\n    )\n    expect(out).toEqual([\n      { event: \"split\", data: \"hi\" },\n      { event: \"next\", data: \"x\" },\n    ])\n  })\n\n  it(\"handles CRLF line endings\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"event: a\\r\\ndata: b\\r\\n\\r\\n\")))\n    expect(out).toEqual([{ event: \"a\", data: \"b\" }])\n  })\n\n  it(\"preserves id and skips comment lines\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\": ping\\nid: 42\\ndata: x\\n\\n\")))\n    expect(out).toEqual([{ id: \"42\", data: \"x\" }])\n  })\n\n  it(\"parses a data field with no space after the colon\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"data:x\\n\\n\")))\n    expect(out).toEqual([{ data: \"x\" }])\n  })\n\n  it(\"ignores an id containing a NUL character\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"id: a\\u0000b\\ndata: x\\n\\n\")))\n    expect(out).toEqual([{ data: \"x\" }])\n  })\n\n  it(\"discards a trailing event without a closing blank line\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"data: tail\")))\n    expect(out).toEqual([])\n  })\n\n  it(\"discards buffered partial data when the upstream fails mid-stream\", async () => {\n    const failing = Stream.concat(\n      bytesOf(\"data: good\\n\\ndata: partial-tr\"),\n      Stream.fail(\"boom\" as const),\n    )\n    const { seen, failures } = await runUntilEnd(SSE.fromBytes(failing))\n    expect(seen).toEqual([{ data: \"good\" }])\n    expect(failures).toEqual([\"boom\"])\n  })\n\n  it(\"discards a partial multi-byte char in the text decoder when the upstream fails\", async () => {\n    const partialSquid = enc.encode(\"data: 🦑\\n\\n\").slice(0, 8)\n    const failing = Stream.concat(\n      Stream.fromIterable([enc.encode(\"data: ok\\n\\n\"), partialSquid]),\n      Stream.fail(\"boom\" as const),\n    )\n    const { seen, failures } = await runUntilEnd(SSE.fromBytes(failing))\n    expect(seen).toEqual([{ data: \"ok\" }])\n    expect(failures).toEqual([\"boom\"])\n  })\n\n  it(\"discards buffered partial data when the stream is interrupted\", async () => {\n    const { seen, exit } = await Effect.runPromise(\n      Effect.gen(function* () {\n        const seen: Array<SSE.Event> = []\n        const latch = yield* Deferred.make<void>()\n        const hanging = Stream.concat(bytesOf(\"data: good\\n\\ndata: partial\"), Stream.never)\n        const fiber = yield* Stream.runForEach(SSE.fromBytes(hanging), (e) =>\n          Effect.sync(() => {\n            seen.push(e)\n          }).pipe(Effect.andThen(Deferred.succeed(latch, void 0))),\n        ).pipe(Effect.forkChild)\n        yield* Deferred.await(latch)\n        yield* Fiber.interrupt(fiber)\n        const exit = yield* Fiber.await(fiber)\n        return { seen, exit }\n      }),\n    )\n    expect(seen).toEqual([{ data: \"good\" }])\n    expect(Exit.isFailure(exit)).toBe(true)\n    expect(failuresOf(exit)).toEqual([])\n  })\n\n  it(\"ignores retry directives\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"retry: 3000\\n\\ndata: a\\n\\n\")))\n    expect(out).toEqual([{ data: \"a\" }])\n  })\n\n  it(\"treats an explicit 'event: message' as the default event\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"event: message\\ndata: x\\n\\n\")))\n    expect(out).toEqual([{ data: \"x\" }])\n  })\n\n  it(\"does not dispatch events with no data\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"event: ping\\n\\ndata: x\\n\\n\")))\n    expect(out).toEqual([{ data: \"x\" }])\n  })\n\n  it(\"ignores empty blocks between events\", async () => {\n    const out = await collect(SSE.fromBytes(bytesOf(\"data: a\\n\\n\\n\\ndata: b\\n\\n\")))\n    expect(out).toEqual([{ data: \"a\" }, { data: \"b\" }])\n  })\n\n  it(\"handles a UTF-8 multi-byte char split across chunks\", async () => {\n    // \"🦑\" is 0xF0 0x9F 0xA6 0x91. Split between bytes 2 and 3.\n    const squidBytes = enc.encode(\"data: 🦑\\n\\n\")\n    const a = squidBytes.slice(0, 8) // \"data: \" + first 2 bytes of squid\n    const b = squidBytes.slice(8) // remaining squid bytes + \"\\n\\n\"\n    const out = await collect(SSE.fromBytes(Stream.fromIterable([a, b])))\n    expect(out).toEqual([{ data: \"🦑\" }])\n  })\n})\n\ndescribe(\"SSE.toBytes round-trip\", () => {\n  it(\"re-parses what it serializes\", async () => {\n    const events: ReadonlyArray<SSE.Event> = [\n      { event: \"a\", data: \"hello\" },\n      { data: \"multi\\nline\" },\n      { event: \"b\", id: \"7\", data: \"x\" },\n    ]\n    const reparsed = await collect(Stream.fromIterable(events).pipe(SSE.toBytes, SSE.fromBytes))\n    expect(reparsed).toEqual(events)\n  })\n})\n"],"mappings":"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"}

package/dist/structured-format/StructuredFormat.d.mts

@@ -1,2 +1,2 @@
-import { c as decodeJsonLines, d as parseJson, i as StructuredFormat, l as decodeJsonLinesRecoverable, n as JsonParseError, o as StructuredSchema, r as StructuredDecodeError, s as decode, t as DecodeIssue, u as fromEffectSchema } from "../StructuredFormat-DHaUJBdd.mjs";
+import { c as decodeJsonLines, d as parseJson, i as StructuredFormat, l as decodeJsonLinesRecoverable, n as JsonParseError, o as StructuredSchema, r as StructuredDecodeError, s as decode, t as DecodeIssue, u as fromEffectSchema } from "../StructuredFormat-BlZhyOsi.mjs";
 export { DecodeIssue, JsonParseError, StructuredDecodeError, StructuredFormat, StructuredSchema, decode, decodeJsonLines, decodeJsonLinesRecoverable, fromEffectSchema, parseJson };

package/dist/structured-format/StructuredFormat.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 import { Data, Effect, Match, Schema, Stream, pipe } from "effect";
 //#region src/structured-format/StructuredFormat.ts
 var StructuredFormat_exports = /* @__PURE__ */ __exportAll({

package/dist/structured-format/StructuredFormat.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"StructuredFormat.mjs","names":[],"sources":["../../src/structured-format/StructuredFormat.ts"],"sourcesContent":["import type { StandardJSONSchemaV1, StandardSchemaV1 } from \"@standard-schema/spec\"\nimport { Data, Effect, Match, Result, Schema, Stream, pipe } from \"effect\"\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-validator schema constraint for structured outputs. Any schema\n * implementing both Standard Schema (runtime validation) and Standard\n * JSON Schema (wire encoding) works directly: Zod 4+, Valibot, ArkType,\n * and Effect Schema after `fromEffectSchema`.\n */\nexport type StructuredSchema<Output = unknown> = StandardSchemaV1<unknown, Output> &\n  StandardJSONSchemaV1<unknown, Output>\n\n/**\n * A schema-bound output the user wants the model to produce. Pairs the\n * cross-validator schema with metadata providers need (name, description,\n * strict-mode flag).\n */\nexport type StructuredFormat<A> = {\n  readonly name: string\n  readonly description?: string\n  readonly schema: StructuredSchema<A>\n  /**\n   * Provider strict-mode flag. OpenAI, Anthropic, and Mistral honour it\n   * (constrained decoding); other providers ignore.\n   */\n  readonly strict?: boolean\n}\n\n/** A single path-scoped validation problem. Library-agnostic shape. */\nexport type DecodeIssue = {\n  readonly path: ReadonlyArray<string | number>\n  readonly message: string\n}\n\n// ---------------------------------------------------------------------------\n// Errors\n// ---------------------------------------------------------------------------\n\n/**\n * Schema validation failed. `raw` is the original text (or stringified\n * value) that failed; `issues` is a flat list of per-field problems.\n */\nexport class StructuredDecodeError extends Data.TaggedError(\"StructuredDecodeError\")<{\n  readonly raw: string\n  readonly issues: ReadonlyArray<DecodeIssue>\n}> {}\n\n/**\n * `JSON.parse` threw on a string that was supposed to be JSON. Distinct\n * from `StructuredDecodeError`: the bytes weren't even JSON.\n */\nexport class JsonParseError extends Data.TaggedError(\"StructuredJsonParseError\")<{\n  readonly raw: string\n  readonly cause: unknown\n}> {}\n\n// ---------------------------------------------------------------------------\n// Constructors\n// ---------------------------------------------------------------------------\n\n/**\n * Wrap an Effect `Schema` as a `StructuredFormat`. Effect Schema doesn't\n * natively implement Standard Schema; this helper installs the\n * `~standard` and JSON Schema interfaces.\n */\nexport const fromEffectSchema = <S extends Schema.Codec<any, any, never, any>>(\n  schema: S,\n  options?: {\n    readonly name?: string\n    readonly description?: string\n    readonly strict?: boolean\n  },\n): StructuredFormat<S[\"Type\"]> => ({\n  name: options?.name ?? \"output\",\n  schema: Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(schema)),\n  ...(options?.description !== undefined && {\n    description: options.description,\n  }),\n  ...(options?.strict !== undefined && { strict: options.strict }),\n})\n\n// ---------------------------------------------------------------------------\n// Standard Schema → DecodeIssue\n// ---------------------------------------------------------------------------\n\nconst propertyKeyToScalar = Match.type<PropertyKey>().pipe(\n  Match.when(Match.string, (s) => s),\n  Match.when(Match.number, (n) => n),\n  Match.when(Match.symbol, (s) => s.toString()),\n  Match.exhaustive,\n)\n\nconst segmentToKey = Match.type<PropertyKey | StandardSchemaV1.PathSegment>().pipe(\n  Match.when(Match.string, (s) => s),\n  Match.when(Match.number, (n) => n),\n  Match.when(Match.symbol, (s) => s.toString()),\n  Match.orElse((segment) => propertyKeyToScalar(segment.key)),\n)\n\nconst issueToDecode = (issue: StandardSchemaV1.Issue): DecodeIssue => ({\n  path: (issue.path ?? []).map(segmentToKey),\n  message: issue.message,\n})\n\n// ---------------------------------------------------------------------------\n// Decoding\n// ---------------------------------------------------------------------------\n\n/**\n * Validate an `unknown` against the format's schema. Returns the typed\n * value or a `StructuredDecodeError`. Standard Schema's `validate` may\n * be async; this function handles both sync and async results.\n */\nexport const decode =\n  <A>(format: StructuredFormat<A>) =>\n  (raw: unknown): Effect.Effect<A, StructuredDecodeError> =>\n    pipe(\n      Effect.promise(async () => format.schema[\"~standard\"].validate(raw)),\n      Effect.flatMap((result) =>\n        result.issues === undefined\n          ? Effect.succeed(result.value)\n          : Effect.fail(\n              new StructuredDecodeError({\n                raw: typeof raw === \"string\" ? raw : JSON.stringify(raw),\n                issues: result.issues.map(issueToDecode),\n              }),\n            ),\n      ),\n    )\n\n/**\n * Parse a JSON string then validate against the format's schema. Two\n * failure modes: `JsonParseError` (bytes weren't JSON) and\n * `StructuredDecodeError` (JSON didn't match the schema).\n */\nexport const parseJson =\n  <A>(format: StructuredFormat<A>) =>\n  (raw: string): Effect.Effect<A, JsonParseError | StructuredDecodeError> =>\n    pipe(\n      Effect.try({\n        // Validation runs through Standard Schema (Zod / Valibot / Effect), not\n        // Effect Schema, so its JSON codecs don't apply here; and JSON.parse is\n        // a separate step on purpose, to surface JsonParseError distinctly.\n        // @effect-diagnostics-next-line effect/preferSchemaOverJson:off\n        try: () => JSON.parse(raw),\n        catch: (cause) => new JsonParseError({ raw, cause }),\n      }),\n      Effect.flatMap(decode(format)),\n    )\n\n/**\n * Stream operator: each input string is JSON-parsed and validated.\n * Failures surface in the stream's failure channel, distinguished by tag.\n */\nexport const decodeJsonLines =\n  <A>(format: StructuredFormat<A>) =>\n  <E, R>(\n    self: Stream.Stream<string, E, R>,\n  ): Stream.Stream<A, E | JsonParseError | StructuredDecodeError, R> =>\n    self.pipe(Stream.mapEffect(parseJson(format)))\n\n/**\n * Like {@link decodeJsonLines}, but each line yields a `Result` instead of\n * failing the stream. Use when one bad line shouldn't abort the rest —\n * log-and-continue, or partial-recovery with a corrective re-prompt.\n * Upstream errors (the input stream's own `E`) still propagate normally.\n */\nexport const decodeJsonLinesRecoverable =\n  <A>(format: StructuredFormat<A>) =>\n  <E, R>(\n    self: Stream.Stream<string, E, R>,\n  ): Stream.Stream<Result.Result<A, JsonParseError | StructuredDecodeError>, E, R> =>\n    self.pipe(Stream.mapEffect((line) => Effect.result(parseJson(format)(line))))\n"],"mappings":";;;;;;;;;;;;;;;;AA8CA,IAAa,wBAAb,cAA2C,KAAK,YAAY,wBAAwB,CAGjF;;;;;AAMH,IAAa,iBAAb,cAAoC,KAAK,YAAY,2BAA2B,CAG7E;;;;;;AAWH,MAAa,oBACX,QACA,aAKiC;CACjC,MAAM,SAAS,QAAQ;CACvB,QAAQ,OAAO,uBAAuB,OAAO,mBAAmB,OAAO,CAAC;CACxE,GAAI,SAAS,gBAAgB,KAAA,KAAa,EACxC,aAAa,QAAQ,aACtB;CACD,GAAI,SAAS,WAAW,KAAA,KAAa,EAAE,QAAQ,QAAQ,QAAQ;CAChE;AAMD,MAAM,sBAAsB,MAAM,MAAmB,CAAC,KACpD,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,EAClC,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,EAClC,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,UAAU,CAAC,EAC7C,MAAM,WACP;AAED,MAAM,eAAe,MAAM,MAAkD,CAAC,KAC5E,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,EAClC,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,EAClC,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,UAAU,CAAC,EAC7C,MAAM,QAAQ,YAAY,oBAAoB,QAAQ,IAAI,CAAC,CAC5D;AAED,MAAM,iBAAiB,WAAgD;CACrE,OAAO,MAAM,QAAQ,EAAE,EAAE,IAAI,aAAa;CAC1C,SAAS,MAAM;CAChB;;;;;;AAWD,MAAa,UACP,YACH,QACC,KACE,OAAO,QAAQ,YAAY,OAAO,OAAO,aAAa,SAAS,IAAI,CAAC,EACpE,OAAO,SAAS,WACd,OAAO,WAAW,KAAA,IACd,OAAO,QAAQ,OAAO,MAAM,GAC5B,OAAO,KACL,IAAI,sBAAsB;CACxB,KAAK,OAAO,QAAQ,WAAW,MAAM,KAAK,UAAU,IAAI;CACxD,QAAQ,OAAO,OAAO,IAAI,cAAc;CACzC,CAAC,CACH,CACN,CACF;;;;;;AAOL,MAAa,aACP,YACH,QACC,KACE,OAAO,IAAI;CAKT,WAAW,KAAK,MAAM,IAAI;CAC1B,QAAQ,UAAU,IAAI,eAAe;EAAE;EAAK;EAAO,CAAC;CACrD,CAAC,EACF,OAAO,QAAQ,OAAO,OAAO,CAAC,CAC/B;;;;;AAML,MAAa,mBACP,YAEF,SAEA,KAAK,KAAK,OAAO,UAAU,UAAU,OAAO,CAAC,CAAC;;;;;;;AAQlD,MAAa,8BACP,YAEF,SAEA,KAAK,KAAK,OAAO,WAAW,SAAS,OAAO,OAAO,UAAU,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC"}
+{"version":3,"file":"StructuredFormat.mjs","names":[],"sources":["../../src/structured-format/StructuredFormat.ts"],"sourcesContent":["import type { StandardJSONSchemaV1, StandardSchemaV1 } from \"@standard-schema/spec\"\nimport { Data, Effect, Match, Result, Schema, Stream, pipe } from \"effect\"\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/**\n * Cross-validator schema constraint for structured outputs. Any schema\n * implementing both Standard Schema (runtime validation) and Standard\n * JSON Schema (wire encoding) works directly: Zod 4+, Valibot, ArkType,\n * and Effect Schema after `fromEffectSchema`.\n */\nexport type StructuredSchema<Output = unknown> = StandardSchemaV1<unknown, Output> &\n  StandardJSONSchemaV1<unknown, Output>\n\n/**\n * A schema-bound output the user wants the model to produce. Pairs the\n * cross-validator schema with metadata providers need (name, description,\n * strict-mode flag).\n */\nexport type StructuredFormat<A> = {\n  readonly name: string\n  readonly description?: string\n  readonly schema: StructuredSchema<A>\n  /**\n   * Provider strict-mode flag. OpenAI, Anthropic, and Mistral honour it\n   * (constrained decoding); other providers ignore.\n   */\n  readonly strict?: boolean\n}\n\n/** A single path-scoped validation problem. Library-agnostic shape. */\nexport type DecodeIssue = {\n  readonly path: ReadonlyArray<string | number>\n  readonly message: string\n}\n\n// ---------------------------------------------------------------------------\n// Errors\n// ---------------------------------------------------------------------------\n\n/**\n * Schema validation failed. `raw` is the original text (or stringified\n * value) that failed; `issues` is a flat list of per-field problems.\n */\nexport class StructuredDecodeError extends Data.TaggedError(\"StructuredDecodeError\")<{\n  readonly raw: string\n  readonly issues: ReadonlyArray<DecodeIssue>\n}> {}\n\n/**\n * `JSON.parse` threw on a string that was supposed to be JSON. Distinct\n * from `StructuredDecodeError`: the bytes weren't even JSON.\n */\nexport class JsonParseError extends Data.TaggedError(\"StructuredJsonParseError\")<{\n  readonly raw: string\n  readonly cause: unknown\n}> {}\n\n// ---------------------------------------------------------------------------\n// Constructors\n// ---------------------------------------------------------------------------\n\n/**\n * Wrap an Effect `Schema` as a `StructuredFormat`. Effect Schema doesn't\n * natively implement Standard Schema; this helper installs the\n * `~standard` and JSON Schema interfaces.\n */\nexport const fromEffectSchema = <S extends Schema.Codec<any, any, never, any>>(\n  schema: S,\n  options?: {\n    readonly name?: string\n    readonly description?: string\n    readonly strict?: boolean\n  },\n): StructuredFormat<S[\"Type\"]> => ({\n  name: options?.name ?? \"output\",\n  schema: Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(schema)),\n  ...(options?.description !== undefined && {\n    description: options.description,\n  }),\n  ...(options?.strict !== undefined && { strict: options.strict }),\n})\n\n// ---------------------------------------------------------------------------\n// Standard Schema → DecodeIssue\n// ---------------------------------------------------------------------------\n\nconst propertyKeyToScalar = Match.type<PropertyKey>().pipe(\n  Match.when(Match.string, (s) => s),\n  Match.when(Match.number, (n) => n),\n  Match.when(Match.symbol, (s) => s.toString()),\n  Match.exhaustive,\n)\n\nconst segmentToKey = Match.type<PropertyKey | StandardSchemaV1.PathSegment>().pipe(\n  Match.when(Match.string, (s) => s),\n  Match.when(Match.number, (n) => n),\n  Match.when(Match.symbol, (s) => s.toString()),\n  Match.orElse((segment) => propertyKeyToScalar(segment.key)),\n)\n\nconst issueToDecode = (issue: StandardSchemaV1.Issue): DecodeIssue => ({\n  path: (issue.path ?? []).map(segmentToKey),\n  message: issue.message,\n})\n\n// ---------------------------------------------------------------------------\n// Decoding\n// ---------------------------------------------------------------------------\n\n/**\n * Validate an `unknown` against the format's schema. Returns the typed\n * value or a `StructuredDecodeError`. Standard Schema's `validate` may\n * be async; this function handles both sync and async results.\n */\nexport const decode =\n  <A>(format: StructuredFormat<A>) =>\n  (raw: unknown): Effect.Effect<A, StructuredDecodeError> =>\n    pipe(\n      Effect.promise(async () => format.schema[\"~standard\"].validate(raw)),\n      Effect.flatMap((result) =>\n        result.issues === undefined\n          ? Effect.succeed(result.value)\n          : Effect.fail(\n              new StructuredDecodeError({\n                raw: typeof raw === \"string\" ? raw : JSON.stringify(raw),\n                issues: result.issues.map(issueToDecode),\n              }),\n            ),\n      ),\n    )\n\n/**\n * Parse a JSON string then validate against the format's schema. Two\n * failure modes: `JsonParseError` (bytes weren't JSON) and\n * `StructuredDecodeError` (JSON didn't match the schema).\n */\nexport const parseJson =\n  <A>(format: StructuredFormat<A>) =>\n  (raw: string): Effect.Effect<A, JsonParseError | StructuredDecodeError> =>\n    pipe(\n      Effect.try({\n        // Validation runs through Standard Schema (Zod / Valibot / Effect), not\n        // Effect Schema, so its JSON codecs don't apply here; and JSON.parse is\n        // a separate step on purpose, to surface JsonParseError distinctly.\n        // @effect-diagnostics-next-line effect/preferSchemaOverJson:off\n        try: () => JSON.parse(raw),\n        catch: (cause) => new JsonParseError({ raw, cause }),\n      }),\n      Effect.flatMap(decode(format)),\n    )\n\n/**\n * Stream operator: each input string is JSON-parsed and validated.\n * Failures surface in the stream's failure channel, distinguished by tag.\n */\nexport const decodeJsonLines =\n  <A>(format: StructuredFormat<A>) =>\n  <E, R>(\n    self: Stream.Stream<string, E, R>,\n  ): Stream.Stream<A, E | JsonParseError | StructuredDecodeError, R> =>\n    self.pipe(Stream.mapEffect(parseJson(format)))\n\n/**\n * Like {@link decodeJsonLines}, but each line yields a `Result` instead of\n * failing the stream. Use when one bad line shouldn't abort the rest —\n * log-and-continue, or partial-recovery with a corrective re-prompt.\n * Upstream errors (the input stream's own `E`) still propagate normally.\n */\nexport const decodeJsonLinesRecoverable =\n  <A>(format: StructuredFormat<A>) =>\n  <E, R>(\n    self: Stream.Stream<string, E, R>,\n  ): Stream.Stream<Result.Result<A, JsonParseError | StructuredDecodeError>, E, R> =>\n    self.pipe(Stream.mapEffect((line) => Effect.result(parseJson(format)(line))))\n"],"mappings":";;;;;;;;;;;;;;;;AA8CA,IAAa,wBAAb,cAA2C,KAAK,YAAY,uBAAuB,CAAC,CAGjF,CAAC;;;;;AAMJ,IAAa,iBAAb,cAAoC,KAAK,YAAY,0BAA0B,CAAC,CAG7E,CAAC;;;;;;AAWJ,MAAa,oBACX,QACA,aAKiC;CACjC,MAAM,SAAS,QAAQ;CACvB,QAAQ,OAAO,uBAAuB,OAAO,mBAAmB,MAAM,CAAC;CACvE,GAAI,SAAS,gBAAgB,KAAA,KAAa,EACxC,aAAa,QAAQ,YACvB;CACA,GAAI,SAAS,WAAW,KAAA,KAAa,EAAE,QAAQ,QAAQ,OAAO;AAChE;AAMA,MAAM,sBAAsB,MAAM,KAAkB,CAAC,CAAC,KACpD,MAAM,KAAK,MAAM,SAAS,MAAM,CAAC,GACjC,MAAM,KAAK,MAAM,SAAS,MAAM,CAAC,GACjC,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,SAAS,CAAC,GAC5C,MAAM,UACR;AAEA,MAAM,eAAe,MAAM,KAAiD,CAAC,CAAC,KAC5E,MAAM,KAAK,MAAM,SAAS,MAAM,CAAC,GACjC,MAAM,KAAK,MAAM,SAAS,MAAM,CAAC,GACjC,MAAM,KAAK,MAAM,SAAS,MAAM,EAAE,SAAS,CAAC,GAC5C,MAAM,QAAQ,YAAY,oBAAoB,QAAQ,GAAG,CAAC,CAC5D;AAEA,MAAM,iBAAiB,WAAgD;CACrE,OAAO,MAAM,QAAQ,CAAC,EAAA,CAAG,IAAI,YAAY;CACzC,SAAS,MAAM;AACjB;;;;;;AAWA,MAAa,UACP,YACH,QACC,KACE,OAAO,QAAQ,YAAY,OAAO,OAAO,YAAY,CAAC,SAAS,GAAG,CAAC,GACnE,OAAO,SAAS,WACd,OAAO,WAAW,KAAA,IACd,OAAO,QAAQ,OAAO,KAAK,IAC3B,OAAO,KACL,IAAI,sBAAsB;CACxB,KAAK,OAAO,QAAQ,WAAW,MAAM,KAAK,UAAU,GAAG;CACvD,QAAQ,OAAO,OAAO,IAAI,aAAa;AACzC,CAAC,CACH,CACN,CACF;;;;;;AAOJ,MAAa,aACP,YACH,QACC,KACE,OAAO,IAAI;CAKT,WAAW,KAAK,MAAM,GAAG;CACzB,QAAQ,UAAU,IAAI,eAAe;EAAE;EAAK;CAAM,CAAC;AACrD,CAAC,GACD,OAAO,QAAQ,OAAO,MAAM,CAAC,CAC/B;;;;;AAMJ,MAAa,mBACP,YAEF,SAEA,KAAK,KAAK,OAAO,UAAU,UAAU,MAAM,CAAC,CAAC;;;;;;;AAQjD,MAAa,8BACP,YAEF,SAEA,KAAK,KAAK,OAAO,WAAW,SAAS,OAAO,OAAO,UAAU,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC"}

package/dist/structured-format/StructuredFormat.test.d.mts

@@ -1 +1 @@
-export { };
+export {}

package/dist/structured-format/StructuredFormat.test.mjs

@@ -1,11 +1,13 @@
 import { JsonParseError, StructuredDecodeError, decodeJsonLines, decodeJsonLinesRecoverable, fromEffectSchema } from "./StructuredFormat.mjs";
-import { c as it, n as globalExpect, o as describe } from "../dist-CcRV3-A5.mjs";
+import { m as it, o as describe } from "../utils-CiH_DjFW.mjs";
+import { n as globalExpect } from "../test.DNmyFkvJ-YPzDR0Co.mjs";
 import { Effect, Exit, Filter, Result, Schema, Stream } from "effect";
 //#region src/structured-format/StructuredFormat.test.ts
-const itemFormat = fromEffectSchema(Schema.Struct({
+const Item = Schema.Struct({
 	id: Schema.Number,
 	name: Schema.String
-}), { name: "Item" });
+});
+const itemFormat = fromEffectSchema(Item, { name: "Item" });
 const linesOf = (...xs) => Stream.fromIterable(xs);
 const collect = (s) => Effect.runPromise(Stream.runCollect(s).pipe(Effect.map((c) => Array.from(c))));
 describe("decodeJsonLinesRecoverable", () => {
@@ -48,7 +50,8 @@ describe("decodeJsonLinesRecoverable", () => {
 		globalExpect(Exit.isFailure(exit)).toBe(true);
 	});
 	it("composes with filter-success / log-and-continue", async () => {
-		globalExpect(await collect(linesOf("{\"id\":1,\"name\":\"a\"}", "garbage", "{\"id\":2,\"name\":\"b\"}").pipe(decodeJsonLinesRecoverable(itemFormat), Stream.filterMap(Filter.fromPredicateOption(Result.getSuccess))))).toEqual([{
+		const out = await collect(linesOf("{\"id\":1,\"name\":\"a\"}", "garbage", "{\"id\":2,\"name\":\"b\"}").pipe(decodeJsonLinesRecoverable(itemFormat), Stream.filterMap(Filter.fromPredicateOption(Result.getSuccess))));
+		globalExpect(out).toEqual([{
 			id: 1,
 			name: "a"
 		}, {

package/dist/structured-format/StructuredFormat.test.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"StructuredFormat.test.mjs","names":[],"sources":["../../src/structured-format/StructuredFormat.test.ts"],"sourcesContent":["import { Effect, Exit, Filter, Result, Schema, Stream } from \"effect\"\nimport { describe, expect, it } from \"vitest\"\nimport {\n  decodeJsonLines,\n  decodeJsonLinesRecoverable,\n  fromEffectSchema,\n  JsonParseError,\n  StructuredDecodeError,\n} from \"./StructuredFormat.js\"\n\nconst Item = Schema.Struct({ id: Schema.Number, name: Schema.String })\ntype Item = typeof Item.Type\nconst itemFormat = fromEffectSchema(Item, { name: \"Item\" })\n\nconst linesOf = (...xs: ReadonlyArray<string>): Stream.Stream<string> => Stream.fromIterable(xs)\n\nconst collect = <A, E>(s: Stream.Stream<A, E>) =>\n  Effect.runPromise(Stream.runCollect(s).pipe(Effect.map((c) => Array.from(c))))\n\ndescribe(\"decodeJsonLinesRecoverable\", () => {\n  it(\"yields a Success for each well-formed line\", async () => {\n    const out = await collect(\n      linesOf('{\"id\":1,\"name\":\"a\"}', '{\"id\":2,\"name\":\"b\"}').pipe(\n        decodeJsonLinesRecoverable(itemFormat),\n      ),\n    )\n\n    expect(out).toHaveLength(2)\n    expect(Result.isSuccess(out[0]!)).toBe(true)\n    expect(Result.isSuccess(out[1]!)).toBe(true)\n    if (Result.isSuccess(out[0]!) && Result.isSuccess(out[1]!)) {\n      expect(out[0]!.success).toEqual<Item>({ id: 1, name: \"a\" })\n      expect(out[1]!.success).toEqual<Item>({ id: 2, name: \"b\" })\n    }\n  })\n\n  it(\"yields a Failure for a malformed JSON line WITHOUT aborting the stream\", async () => {\n    const out = await collect(\n      linesOf('{\"id\":1,\"name\":\"a\"}', \"not json at all\", '{\"id\":3,\"name\":\"c\"}').pipe(\n        decodeJsonLinesRecoverable(itemFormat),\n      ),\n    )\n\n    expect(out).toHaveLength(3)\n    expect(Result.isSuccess(out[0]!)).toBe(true)\n    expect(Result.isFailure(out[1]!)).toBe(true)\n    expect(Result.isSuccess(out[2]!)).toBe(true)\n    if (Result.isFailure(out[1]!)) {\n      expect(out[1]!.failure).toBeInstanceOf(JsonParseError)\n    }\n  })\n\n  it(\"yields a Failure for a schema-invalid line without aborting\", async () => {\n    const out = await collect(\n      linesOf(\n        '{\"id\":1,\"name\":\"a\"}',\n        '{\"id\":\"not-a-number\",\"name\":\"b\"}', // schema fail\n        '{\"id\":3,\"name\":\"c\"}',\n      ).pipe(decodeJsonLinesRecoverable(itemFormat)),\n    )\n\n    expect(out).toHaveLength(3)\n    expect(Result.isSuccess(out[0]!)).toBe(true)\n    expect(Result.isFailure(out[1]!)).toBe(true)\n    expect(Result.isSuccess(out[2]!)).toBe(true)\n    if (Result.isFailure(out[1]!)) {\n      expect(out[1]!.failure).toBeInstanceOf(StructuredDecodeError)\n    }\n  })\n\n  it(\"propagates upstream errors normally (only DECODE failures are lifted into Result)\", async () => {\n    const boom = new Error(\"upstream broke\")\n    const stream = Stream.concat(linesOf('{\"id\":1,\"name\":\"a\"}'), Stream.fail(boom)).pipe(\n      decodeJsonLinesRecoverable(itemFormat),\n    )\n\n    const exit = await Effect.runPromise(Effect.exit(Stream.runCollect(stream)))\n    expect(Exit.isFailure(exit)).toBe(true)\n  })\n\n  it(\"composes with filter-success / log-and-continue\", async () => {\n    const out = await collect(\n      linesOf('{\"id\":1,\"name\":\"a\"}', \"garbage\", '{\"id\":2,\"name\":\"b\"}').pipe(\n        decodeJsonLinesRecoverable(itemFormat),\n        Stream.filterMap(Filter.fromPredicateOption(Result.getSuccess)),\n      ),\n    )\n\n    expect(out).toEqual<Array<Item>>([\n      { id: 1, name: \"a\" },\n      { id: 2, name: \"b\" },\n    ])\n  })\n})\n\ndescribe(\"decodeJsonLines (fail-fast, sanity)\", () => {\n  it(\"aborts the stream on the first bad line\", async () => {\n    const stream = linesOf('{\"id\":1,\"name\":\"a\"}', \"garbage\", '{\"id\":3,\"name\":\"c\"}').pipe(\n      decodeJsonLines(itemFormat),\n    )\n\n    const exit = await Effect.runPromise(Effect.exit(Stream.runCollect(stream)))\n    expect(Exit.isFailure(exit)).toBe(true)\n  })\n})\n"],"mappings":"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"}
+{"version":3,"file":"StructuredFormat.test.mjs","names":[],"sources":["../../src/structured-format/StructuredFormat.test.ts"],"sourcesContent":["import { Effect, Exit, Filter, Result, Schema, Stream } from \"effect\"\nimport { describe, expect, it } from \"vitest\"\nimport {\n  decodeJsonLines,\n  decodeJsonLinesRecoverable,\n  fromEffectSchema,\n  JsonParseError,\n  StructuredDecodeError,\n} from \"./StructuredFormat.js\"\n\nconst Item = Schema.Struct({ id: Schema.Number, name: Schema.String })\ntype Item = typeof Item.Type\nconst itemFormat = fromEffectSchema(Item, { name: \"Item\" })\n\nconst linesOf = (...xs: ReadonlyArray<string>): Stream.Stream<string> => Stream.fromIterable(xs)\n\nconst collect = <A, E>(s: Stream.Stream<A, E>) =>\n  Effect.runPromise(Stream.runCollect(s).pipe(Effect.map((c) => Array.from(c))))\n\ndescribe(\"decodeJsonLinesRecoverable\", () => {\n  it(\"yields a Success for each well-formed line\", async () => {\n    const out = await collect(\n      linesOf('{\"id\":1,\"name\":\"a\"}', '{\"id\":2,\"name\":\"b\"}').pipe(\n        decodeJsonLinesRecoverable(itemFormat),\n      ),\n    )\n\n    expect(out).toHaveLength(2)\n    expect(Result.isSuccess(out[0]!)).toBe(true)\n    expect(Result.isSuccess(out[1]!)).toBe(true)\n    if (Result.isSuccess(out[0]!) && Result.isSuccess(out[1]!)) {\n      expect(out[0]!.success).toEqual<Item>({ id: 1, name: \"a\" })\n      expect(out[1]!.success).toEqual<Item>({ id: 2, name: \"b\" })\n    }\n  })\n\n  it(\"yields a Failure for a malformed JSON line WITHOUT aborting the stream\", async () => {\n    const out = await collect(\n      linesOf('{\"id\":1,\"name\":\"a\"}', \"not json at all\", '{\"id\":3,\"name\":\"c\"}').pipe(\n        decodeJsonLinesRecoverable(itemFormat),\n      ),\n    )\n\n    expect(out).toHaveLength(3)\n    expect(Result.isSuccess(out[0]!)).toBe(true)\n    expect(Result.isFailure(out[1]!)).toBe(true)\n    expect(Result.isSuccess(out[2]!)).toBe(true)\n    if (Result.isFailure(out[1]!)) {\n      expect(out[1]!.failure).toBeInstanceOf(JsonParseError)\n    }\n  })\n\n  it(\"yields a Failure for a schema-invalid line without aborting\", async () => {\n    const out = await collect(\n      linesOf(\n        '{\"id\":1,\"name\":\"a\"}',\n        '{\"id\":\"not-a-number\",\"name\":\"b\"}', // schema fail\n        '{\"id\":3,\"name\":\"c\"}',\n      ).pipe(decodeJsonLinesRecoverable(itemFormat)),\n    )\n\n    expect(out).toHaveLength(3)\n    expect(Result.isSuccess(out[0]!)).toBe(true)\n    expect(Result.isFailure(out[1]!)).toBe(true)\n    expect(Result.isSuccess(out[2]!)).toBe(true)\n    if (Result.isFailure(out[1]!)) {\n      expect(out[1]!.failure).toBeInstanceOf(StructuredDecodeError)\n    }\n  })\n\n  it(\"propagates upstream errors normally (only DECODE failures are lifted into Result)\", async () => {\n    const boom = new Error(\"upstream broke\")\n    const stream = Stream.concat(linesOf('{\"id\":1,\"name\":\"a\"}'), Stream.fail(boom)).pipe(\n      decodeJsonLinesRecoverable(itemFormat),\n    )\n\n    const exit = await Effect.runPromise(Effect.exit(Stream.runCollect(stream)))\n    expect(Exit.isFailure(exit)).toBe(true)\n  })\n\n  it(\"composes with filter-success / log-and-continue\", async () => {\n    const out = await collect(\n      linesOf('{\"id\":1,\"name\":\"a\"}', \"garbage\", '{\"id\":2,\"name\":\"b\"}').pipe(\n        decodeJsonLinesRecoverable(itemFormat),\n        Stream.filterMap(Filter.fromPredicateOption(Result.getSuccess)),\n      ),\n    )\n\n    expect(out).toEqual<Array<Item>>([\n      { id: 1, name: \"a\" },\n      { id: 2, name: \"b\" },\n    ])\n  })\n})\n\ndescribe(\"decodeJsonLines (fail-fast, sanity)\", () => {\n  it(\"aborts the stream on the first bad line\", async () => {\n    const stream = linesOf('{\"id\":1,\"name\":\"a\"}', \"garbage\", '{\"id\":3,\"name\":\"c\"}').pipe(\n      decodeJsonLines(itemFormat),\n    )\n\n    const exit = await Effect.runPromise(Effect.exit(Stream.runCollect(stream)))\n    expect(Exit.isFailure(exit)).toBe(true)\n  })\n})\n"],"mappings":"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"}