@effect-uai/core 0.5.1 → 0.6.0

package/dist/retry/Retry.mjs

@@ -0,0 +1,69 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Data, Effect, Stream } from "effect";
+//#region src/retry/Retry.ts
+var Retry_exports = /* @__PURE__ */ __exportAll({
+	Retryable: () => Retryable,
+	effect: () => effect,
+	isRetryable: () => isRetryable,
+	stream: () => stream
+});
+/**
+* Subset-aware retry helpers for `AiError`.
+*
+* Effect's own `Effect.retry` / `Stream.retry` apply the schedule to
+* every failure. For AI calls that's the wrong policy — replaying a
+* `ContentFiltered` or `InvalidRequest` won't change the outcome and
+* just wastes quota. These helpers gate the schedule on the
+* {@link Retryable} subset (rate limits, transport hiccups, timeouts);
+* everything else propagates unchanged.
+*
+* Two carriers:
+* - {@link stream} — for `Stream<A, AiError, R>` (e.g. `streamTurn`,
+*   `streamSynthesis`, `streamTranscriptionFrom`). Caveat: the entire
+*   stream re-runs on retry, so deltas before the failure replay on
+*   the next attempt.
+* - {@link effect} — for `Effect<A, AiError, R>` (e.g. `turn`, `embed`,
+*   `embedMany`, `synthesize`, `transcribe`). At-most-once.
+*
+* Composes with `Stream.retry` / `Effect.retry` directly (no naming
+* collision since these live under the `Retry` namespace).
+*/
+/**
+* Wrapper around the retryable subset of `AiError`. Internal to the
+* lift/retry/unlift dance — exported so callers can build their own
+* variants if needed (e.g. a custom schedule that observes `cause`).
+*/
+var Retryable = class extends Data.TaggedError("RetryableAi") {};
+/** Type-narrowing predicate for the retryable subset. */
+const isRetryable = (e) => e._tag === "RateLimited" || e._tag === "Unavailable" || e._tag === "Timeout";
+/**
+* Retry a `Stream<A, AiError, R>` on the retryable subset. Other
+* failures bypass the schedule and propagate unchanged. The whole
+* stream replays on each attempt — deltas emitted before the failure
+* are re-emitted on the next try.
+*/
+const stream = (schedule) => (s) => s.pipe(Stream.map((value) => ({
+	_tag: "Item",
+	value
+})), Stream.catchIf(isRetryable, (cause) => Stream.fail(new Retryable({ cause })), (cause) => Stream.succeed({
+	_tag: "Terminal",
+	cause
+})), Stream.retry(schedule), Stream.catchTag("RetryableAi", (e) => Stream.fail(e.cause)), Stream.flatMap((item) => item._tag === "Item" ? Stream.succeed(item.value) : Stream.fail(item.cause)));
+/**
+* Retry an `Effect<A, AiError, R>` on the retryable subset. Other
+* failures bypass the schedule and propagate unchanged. At-most-once
+* — the underlying call only re-runs if the previous attempt failed
+* with a retryable tag.
+*
+* Skips the lift/unlift dance the Stream variant needs: `Effect.retry`
+* exposes a `while:` predicate so the error channel stays a plain
+* `AiError` throughout.
+*/
+const effect = (schedule) => (eff) => Effect.retry(eff, {
+	schedule,
+	while: isRetryable
+});
+//#endregion
+export { Retryable, effect, isRetryable, stream, Retry_exports as t };
+
+//# sourceMappingURL=Retry.mjs.map

package/dist/retry/Retry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Retry.mjs","names":[],"sources":["../../src/retry/Retry.ts"],"sourcesContent":["import { Data, Effect, type Schedule, Stream } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\n\n/**\n * Subset-aware retry helpers for `AiError`.\n *\n * Effect's own `Effect.retry` / `Stream.retry` apply the schedule to\n * every failure. For AI calls that's the wrong policy — replaying a\n * `ContentFiltered` or `InvalidRequest` won't change the outcome and\n * just wastes quota. These helpers gate the schedule on the\n * {@link Retryable} subset (rate limits, transport hiccups, timeouts);\n * everything else propagates unchanged.\n *\n * Two carriers:\n * - {@link stream} — for `Stream<A, AiError, R>` (e.g. `streamTurn`,\n *   `streamSynthesis`, `streamTranscriptionFrom`). Caveat: the entire\n *   stream re-runs on retry, so deltas before the failure replay on\n *   the next attempt.\n * - {@link effect} — for `Effect<A, AiError, R>` (e.g. `turn`, `embed`,\n *   `embedMany`, `synthesize`, `transcribe`). At-most-once.\n *\n * Composes with `Stream.retry` / `Effect.retry` directly (no naming\n * collision since these live under the `Retry` namespace).\n */\n\n/**\n * Wrapper around the retryable subset of `AiError`. Internal to the\n * lift/retry/unlift dance — exported so callers can build their own\n * variants if needed (e.g. a custom schedule that observes `cause`).\n */\nexport class Retryable extends Data.TaggedError(\"RetryableAi\")<{\n  readonly cause: AiError.RateLimited | AiError.Unavailable | AiError.Timeout\n}> {}\n\n/** Type-narrowing predicate for the retryable subset. */\nexport const isRetryable = (\n  e: AiError.AiError,\n): e is AiError.RateLimited | AiError.Unavailable | AiError.Timeout =>\n  e._tag === \"RateLimited\" || e._tag === \"Unavailable\" || e._tag === \"Timeout\"\n\n// Lift events to Items, non-retryable failures to Terminal values\n// (escape retry), retryable failures to wrapped errors (only thing\n// retry sees).\ntype Lifted<A> =\n  | { readonly _tag: \"Item\"; readonly value: A }\n  | { readonly _tag: \"Terminal\"; readonly cause: AiError.AiError }\n\n/**\n * Retry a `Stream<A, AiError, R>` on the retryable subset. Other\n * failures bypass the schedule and propagate unchanged. The whole\n * stream replays on each attempt — deltas emitted before the failure\n * are re-emitted on the next try.\n */\nexport const stream =\n  <Out>(schedule: Schedule.Schedule<Out, Retryable>) =>\n  <A, R>(s: Stream.Stream<A, AiError.AiError, R>): Stream.Stream<A, AiError.AiError, R> =>\n    s.pipe(\n      Stream.map((value): Lifted<A> => ({ _tag: \"Item\", value })),\n      Stream.catchIf(\n        isRetryable,\n        (cause) => Stream.fail(new Retryable({ cause })),\n        (cause) => Stream.succeed<Lifted<A>>({ _tag: \"Terminal\", cause }),\n      ),\n      Stream.retry(schedule),\n      Stream.catchTag(\"RetryableAi\", (e) => Stream.fail<AiError.AiError>(e.cause)),\n      Stream.flatMap((item) =>\n        item._tag === \"Item\" ? Stream.succeed(item.value) : Stream.fail(item.cause),\n      ),\n    )\n\n/**\n * Retry an `Effect<A, AiError, R>` on the retryable subset. Other\n * failures bypass the schedule and propagate unchanged. At-most-once\n * — the underlying call only re-runs if the previous attempt failed\n * with a retryable tag.\n *\n * Skips the lift/unlift dance the Stream variant needs: `Effect.retry`\n * exposes a `while:` predicate so the error channel stays a plain\n * `AiError` throughout.\n */\nexport const effect =\n  <Out>(schedule: Schedule.Schedule<Out, AiError.AiError>) =>\n  <A, R>(eff: Effect.Effect<A, AiError.AiError, R>): Effect.Effect<A, AiError.AiError, R> =>\n    Effect.retry(eff, { schedule, while: isRetryable })\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,YAAb,cAA+B,KAAK,YAAY,cAAc,CAE3D;;AAGH,MAAa,eACX,MAEA,EAAE,SAAS,iBAAiB,EAAE,SAAS,iBAAiB,EAAE,SAAS;;;;;;;AAerE,MAAa,UACL,cACC,MACL,EAAE,KACA,OAAO,KAAK,WAAsB;CAAE,MAAM;CAAQ;CAAO,EAAE,EAC3D,OAAO,QACL,cACC,UAAU,OAAO,KAAK,IAAI,UAAU,EAAE,OAAO,CAAC,CAAC,GAC/C,UAAU,OAAO,QAAmB;CAAE,MAAM;CAAY;CAAO,CAAC,CAClE,EACD,OAAO,MAAM,SAAS,EACtB,OAAO,SAAS,gBAAgB,MAAM,OAAO,KAAsB,EAAE,MAAM,CAAC,EAC5E,OAAO,SAAS,SACd,KAAK,SAAS,SAAS,OAAO,QAAQ,KAAK,MAAM,GAAG,OAAO,KAAK,KAAK,MAAM,CAC5E,CACF;;;;;;;;;;;AAYL,MAAa,UACL,cACC,QACL,OAAO,MAAM,KAAK;CAAE;CAAU,OAAO;CAAa,CAAC"}

package/dist/retry/Retry.test.mjs

@@ -0,0 +1,142 @@
+import { ContentFiltered, RateLimited, Timeout, Unavailable } from "../domain/AiError.mjs";
+import { effect, stream } from "./Retry.mjs";
+import { i as it, n as globalExpect, r as describe } from "../dist-DV5ISja1.mjs";
+import { Cause, Effect, Exit, Option, Ref, Schedule, Stream } from "effect";
+//#region src/retry/Retry.test.ts
+const planned = (attempts, plan) => Stream.unwrap(Ref.getAndUpdate(attempts, (n) => n + 1).pipe(Effect.map((n) => plan[Math.min(n, plan.length - 1)])));
+const plannedEffect = (attempts, plan) => Ref.getAndUpdate(attempts, (n) => n + 1).pipe(Effect.flatMap((n) => plan[Math.min(n, plan.length - 1)]));
+describe("Retry.stream", () => {
+	it("retries on RateLimited and yields success on the next attempt", async () => {
+		const program = Effect.gen(function* () {
+			const attempts = yield* Ref.make(0);
+			const s = planned(attempts, [Stream.fail(new RateLimited({
+				provider: "mock",
+				raw: null
+			})), Stream.fromIterable(["a", "b"])]).pipe(stream(Schedule.recurs(3)));
+			const out = yield* Stream.runCollect(s);
+			const count = yield* Ref.get(attempts);
+			return {
+				out: Array.from(out),
+				count
+			};
+		});
+		const { out, count } = await Effect.runPromise(program);
+		globalExpect(count).toBe(2);
+		globalExpect(out).toEqual(["a", "b"]);
+	});
+	it("surfaces the underlying retryable failure when retries are exhausted", async () => {
+		const cause = new Unavailable({
+			provider: "mock",
+			raw: null
+		});
+		const s = Stream.fail(cause).pipe(stream(Schedule.recurs(2)));
+		const exit = await Effect.runPromise(Effect.exit(Stream.runCollect(s)));
+		globalExpect(Exit.isFailure(exit)).toBe(true);
+		if (Exit.isFailure(exit)) globalExpect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause));
+	});
+	it("bypasses retry for non-retryable AiError (ContentFiltered)", async () => {
+		const program = Effect.gen(function* () {
+			const attempts = yield* Ref.make(0);
+			const cause = new ContentFiltered({
+				provider: "mock",
+				raw: null
+			});
+			const s = planned(attempts, [Stream.fail(cause)]).pipe(stream(Schedule.recurs(5)));
+			return {
+				exit: yield* Effect.exit(Stream.runCollect(s)),
+				count: yield* Ref.get(attempts),
+				cause
+			};
+		});
+		const { exit, count, cause } = await Effect.runPromise(program);
+		globalExpect(count).toBe(1);
+		globalExpect(Exit.isFailure(exit)).toBe(true);
+		if (Exit.isFailure(exit)) globalExpect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause));
+	});
+	it("preserves items emitted before a retryable failure (and replays on retry)", async () => {
+		const program = Effect.gen(function* () {
+			const s = planned(yield* Ref.make(0), [Stream.concat(Stream.succeed("partial"), Stream.fail(new Timeout({
+				provider: "mock",
+				raw: null
+			}))), Stream.fromIterable(["partial", "done"])]).pipe(stream(Schedule.recurs(1)));
+			const out = yield* Stream.runCollect(s);
+			return Array.from(out);
+		});
+		globalExpect(await Effect.runPromise(program)).toEqual([
+			"partial",
+			"partial",
+			"done"
+		]);
+	});
+});
+describe("Retry.effect", () => {
+	it("retries on RateLimited and yields success on the next attempt", async () => {
+		const program = Effect.gen(function* () {
+			const attempts = yield* Ref.make(0);
+			return {
+				value: yield* plannedEffect(attempts, [Effect.fail(new RateLimited({
+					provider: "mock",
+					raw: null
+				})), Effect.succeed("ok")]).pipe(effect(Schedule.recurs(3))),
+				count: yield* Ref.get(attempts)
+			};
+		});
+		const { value, count } = await Effect.runPromise(program);
+		globalExpect(count).toBe(2);
+		globalExpect(value).toBe("ok");
+	});
+	it("surfaces the underlying retryable failure when retries are exhausted", async () => {
+		const cause = new Unavailable({
+			provider: "mock",
+			raw: null
+		});
+		const eff = Effect.fail(cause).pipe(effect(Schedule.recurs(2)));
+		const exit = await Effect.runPromise(Effect.exit(eff));
+		globalExpect(Exit.isFailure(exit)).toBe(true);
+		if (Exit.isFailure(exit)) globalExpect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause));
+	});
+	it("bypasses retry for non-retryable AiError (ContentFiltered)", async () => {
+		const program = Effect.gen(function* () {
+			const attempts = yield* Ref.make(0);
+			const cause = new ContentFiltered({
+				provider: "mock",
+				raw: null
+			});
+			return {
+				exit: yield* Effect.exit(plannedEffect(attempts, [Effect.fail(cause)]).pipe(effect(Schedule.recurs(5)))),
+				count: yield* Ref.get(attempts),
+				cause
+			};
+		});
+		const { exit, count, cause } = await Effect.runPromise(program);
+		globalExpect(count).toBe(1);
+		globalExpect(Exit.isFailure(exit)).toBe(true);
+		if (Exit.isFailure(exit)) globalExpect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause));
+	});
+	it("does NOT replay successful prior work — at-most-once semantics", async () => {
+		const program = Effect.gen(function* () {
+			const attempts = yield* Ref.make(0);
+			return {
+				value: yield* plannedEffect(attempts, [
+					Effect.fail(new Timeout({
+						provider: "mock",
+						raw: null
+					})),
+					Effect.fail(new Timeout({
+						provider: "mock",
+						raw: null
+					})),
+					Effect.succeed("done")
+				]).pipe(effect(Schedule.recurs(5))),
+				count: yield* Ref.get(attempts)
+			};
+		});
+		const { value, count } = await Effect.runPromise(program);
+		globalExpect(count).toBe(3);
+		globalExpect(value).toBe("done");
+	});
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=Retry.test.mjs.map

package/dist/retry/Retry.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Retry.test.mjs","names":["AiError.RateLimited","Retry.stream","AiError.Unavailable","AiError.ContentFiltered","AiError.Timeout","Retry.effect"],"sources":["../../src/retry/Retry.test.ts"],"sourcesContent":["import { Cause, Effect, Exit, Option, Ref, Schedule, Stream } from \"effect\"\nimport { describe, expect, it } from \"vitest\"\nimport * as AiError from \"../domain/AiError.js\"\nimport * as Retry from \"./Retry.js\"\n\n// Each call pulls the next plan entry; the last entry repeats forever\n// (so \"succeed on attempt N\" plans naturally re-yield success after).\nconst planned = <A, E>(\n  attempts: Ref.Ref<number>,\n  plan: ReadonlyArray<Stream.Stream<A, E>>,\n): Stream.Stream<A, E> =>\n  Stream.unwrap(\n    Ref.getAndUpdate(attempts, (n) => n + 1).pipe(\n      Effect.map((n) => plan[Math.min(n, plan.length - 1)]!),\n    ),\n  )\n\nconst plannedEffect = <A, E>(\n  attempts: Ref.Ref<number>,\n  plan: ReadonlyArray<Effect.Effect<A, E>>,\n): Effect.Effect<A, E> =>\n  Ref.getAndUpdate(attempts, (n) => n + 1).pipe(\n    Effect.flatMap((n) => plan[Math.min(n, plan.length - 1)]!),\n  )\n\ndescribe(\"Retry.stream\", () => {\n  it(\"retries on RateLimited and yields success on the next attempt\", async () => {\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const s = planned(attempts, [\n        Stream.fail<AiError.AiError>(new AiError.RateLimited({ provider: \"mock\", raw: null })),\n        Stream.fromIterable([\"a\", \"b\"]),\n      ]).pipe(Retry.stream(Schedule.recurs(3)))\n      const out = yield* Stream.runCollect(s)\n      const count = yield* Ref.get(attempts)\n      return { out: Array.from(out), count }\n    })\n\n    const { out, count } = await Effect.runPromise(program)\n    expect(count).toBe(2)\n    expect(out).toEqual([\"a\", \"b\"])\n  })\n\n  it(\"surfaces the underlying retryable failure when retries are exhausted\", async () => {\n    const cause = new AiError.Unavailable({ provider: \"mock\", raw: null })\n    const s = Stream.fail<AiError.AiError>(cause).pipe(Retry.stream(Schedule.recurs(2)))\n\n    const exit = await Effect.runPromise(Effect.exit(Stream.runCollect(s)))\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))\n    }\n  })\n\n  it(\"bypasses retry for non-retryable AiError (ContentFiltered)\", async () => {\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const cause = new AiError.ContentFiltered({ provider: \"mock\", raw: null })\n      const s = planned(attempts, [Stream.fail<AiError.AiError>(cause)]).pipe(\n        Retry.stream(Schedule.recurs(5)),\n      )\n      const exit = yield* Effect.exit(Stream.runCollect(s))\n      const count = yield* Ref.get(attempts)\n      return { exit, count, cause }\n    })\n\n    const { exit, count, cause } = await Effect.runPromise(program)\n    expect(count).toBe(1)\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))\n    }\n  })\n\n  it(\"preserves items emitted before a retryable failure (and replays on retry)\", async () => {\n    // Documents the 'replays on retry' caveat: the entire stream re-runs.\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const s = planned(attempts, [\n        Stream.concat(\n          Stream.succeed(\"partial\"),\n          Stream.fail<AiError.AiError>(new AiError.Timeout({ provider: \"mock\", raw: null })),\n        ),\n        Stream.fromIterable([\"partial\", \"done\"]),\n      ]).pipe(Retry.stream(Schedule.recurs(1)))\n      const out = yield* Stream.runCollect(s)\n      return Array.from(out)\n    })\n\n    const out = await Effect.runPromise(program)\n    expect(out).toEqual([\"partial\", \"partial\", \"done\"])\n  })\n})\n\ndescribe(\"Retry.effect\", () => {\n  it(\"retries on RateLimited and yields success on the next attempt\", async () => {\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const value = yield* plannedEffect(attempts, [\n        Effect.fail<AiError.AiError>(new AiError.RateLimited({ provider: \"mock\", raw: null })),\n        Effect.succeed(\"ok\"),\n      ]).pipe(Retry.effect(Schedule.recurs(3)))\n      const count = yield* Ref.get(attempts)\n      return { value, count }\n    })\n\n    const { value, count } = await Effect.runPromise(program)\n    expect(count).toBe(2)\n    expect(value).toBe(\"ok\")\n  })\n\n  it(\"surfaces the underlying retryable failure when retries are exhausted\", async () => {\n    const cause = new AiError.Unavailable({ provider: \"mock\", raw: null })\n    const eff = Effect.fail<AiError.AiError>(cause).pipe(Retry.effect(Schedule.recurs(2)))\n\n    const exit = await Effect.runPromise(Effect.exit(eff))\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))\n    }\n  })\n\n  it(\"bypasses retry for non-retryable AiError (ContentFiltered)\", async () => {\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const cause = new AiError.ContentFiltered({ provider: \"mock\", raw: null })\n      const exit = yield* Effect.exit(\n        plannedEffect(attempts, [Effect.fail<AiError.AiError>(cause)]).pipe(\n          Retry.effect(Schedule.recurs(5)),\n        ),\n      )\n      const count = yield* Ref.get(attempts)\n      return { exit, count, cause }\n    })\n\n    const { exit, count, cause } = await Effect.runPromise(program)\n    expect(count).toBe(1)\n    expect(Exit.isFailure(exit)).toBe(true)\n    if (Exit.isFailure(exit)) {\n      expect(Cause.findErrorOption(exit.cause)).toEqual(Option.some(cause))\n    }\n  })\n\n  it(\"does NOT replay successful prior work — at-most-once semantics\", async () => {\n    // Contrast with Retry.stream: an Effect.retry only re-invokes the\n    // failing computation. No replay of work done before the failure\n    // (there's nothing to replay — Effects are single-shot).\n    const program = Effect.gen(function* () {\n      const attempts = yield* Ref.make(0)\n      const value = yield* plannedEffect(attempts, [\n        Effect.fail<AiError.AiError>(new AiError.Timeout({ provider: \"mock\", raw: null })),\n        Effect.fail<AiError.AiError>(new AiError.Timeout({ provider: \"mock\", raw: null })),\n        Effect.succeed(\"done\"),\n      ]).pipe(Retry.effect(Schedule.recurs(5)))\n      const count = yield* Ref.get(attempts)\n      return { value, count }\n    })\n\n    const { value, count } = await Effect.runPromise(program)\n    expect(count).toBe(3)\n    expect(value).toBe(\"done\")\n  })\n})\n"],"mappings":"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"}

package/dist/sandbox/Memory.d.mts

@@ -0,0 +1,53 @@
+import { Brand } from "effect";
+
+//#region src/sandbox/Memory.d.ts
+declare namespace Memory_d_exports {
+  export { Input, Memory, bytes, fromInputUnsafe, gb, gib, kb, kib, mb, mib, toBytes };
+}
+/**
+ * A memory / data size, always represented internally as a number of
+ * bytes. Mirrors the `Duration` shape from `effect` — a branded value
+ * type with a wider `Input` union for ergonomic construction at call
+ * sites.
+ *
+ * `effect` itself has no byte-count primitive (only `Duration`), so we
+ * own this here rather than leak provider-specific shapes (Deno's
+ * template-literal `Memory`, Vercel's `mb`, Modal's `gpuMemory`, …)
+ * through the cross-provider `Sandbox` request types.
+ *
+ * @example
+ * ```ts
+ * import * as Memory from "@effect-uai/core/Memory"
+ *
+ * Memory.gib(2)                        // 2 GiB → 2_147_483_648 bytes
+ * Memory.fromInputUnsafe("1.5 GiB")    // human-string parsing
+ * Memory.fromInputUnsafe(1_280_000_000) // raw bytes
+ * Memory.toBytes(m)                    // unwrap
+ * ```
+ */
+type Memory = Brand.Branded<number, "Memory">;
+type Input = number | Memory | string;
+/**
+ * Coerce a {@link Input} to a {@link Memory}. Throws on malformed
+ * strings or non-finite numbers. Mirrors `Duration.fromInputUnsafe`.
+ */
+declare const fromInputUnsafe: (input: Input) => Memory;
+/** Return the underlying byte count. */
+declare const toBytes: (m: Memory | Input) => number;
+/** N bytes. */
+declare const bytes: (n: number) => Memory;
+/** N KiB (binary kibibytes, `n * 1024`). */
+declare const kib: (n: number) => Memory;
+/** N MiB (binary mebibytes, `n * 1024^2`). */
+declare const mib: (n: number) => Memory;
+/** N GiB (binary gibibytes, `n * 1024^3`). */
+declare const gib: (n: number) => Memory;
+/** N kB (decimal kilobytes, `n * 1000`). */
+declare const kb: (n: number) => Memory;
+/** N MB (decimal megabytes, `n * 1_000_000`). */
+declare const mb: (n: number) => Memory;
+/** N GB (decimal gigabytes, `n * 1_000_000_000`). */
+declare const gb: (n: number) => Memory;
+//#endregion
+export { Input, Memory, bytes, fromInputUnsafe, gb, gib, kb, kib, mb, mib, Memory_d_exports as t, toBytes };
+//# sourceMappingURL=Memory.d.mts.map

package/dist/sandbox/Memory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Memory.d.mts","names":[],"sources":["../../src/sandbox/Memory.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;KAAY,MAAA,GAAS,KAAA,CAAM,OAAA;AAAA,KAuBf,KAAA,YAAiB,MAAA;;;;AAqC7B;cAAa,eAAA,GAAmB,KAAA,EAAO,KAAA,KAAQ,MAAA;;cAelC,OAAA,GAAW,CAAA,EAAG,MAAA,GAAS,KAAA;;cAUvB,KAAA,GAAS,CAAA,aAAY,MAAA;;cAGrB,GAAA,GAAO,CAAA,aAAY,MAAA;;cAGnB,GAAA,GAAO,CAAA,aAAY,MAAA;;cAGnB,GAAA,GAAO,CAAA,aAAY,MAAA;;cAGnB,EAAA,GAAM,CAAA,aAAY,MAAA;;cAGlB,EAAA,GAAM,CAAA,aAAY,MAAA;;cAGlB,EAAA,GAAM,CAAA,aAAY,MAAA"}

package/dist/sandbox/Memory.mjs

@@ -0,0 +1,68 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Brand } from "effect";
+//#region src/sandbox/Memory.ts
+var Memory_exports = /* @__PURE__ */ __exportAll({
+	bytes: () => bytes,
+	fromInputUnsafe: () => fromInputUnsafe,
+	gb: () => gb,
+	gib: () => gib,
+	kb: () => kb,
+	kib: () => kib,
+	mb: () => mb,
+	mib: () => mib,
+	toBytes: () => toBytes
+});
+const make = Brand.nominal();
+const UNIT_BYTES = {
+	b: 1,
+	kb: 1e3,
+	mb: 1e6,
+	gb: 1e9,
+	tb: 0xe8d4a51000,
+	kib: 1024,
+	mib: 1024 * 1024,
+	gib: 1024 * 1024 * 1024,
+	tib: 1024 * 1024 * 1024 * 1024
+};
+const PARSE_RE = /^\s*(\d+(?:\.\d+)?)\s*([a-zA-Z]*)\s*$/;
+const parseString = (s) => {
+	const m = PARSE_RE.exec(s);
+	if (m === null) throw new Error(`Memory: cannot parse "${s}" — expected forms like "1024", "10 MB", "1GiB"`);
+	const value = Number(m[1]);
+	const unit = (m[2] ?? "").toLowerCase();
+	if (unit === "") return value;
+	const factor = UNIT_BYTES[unit];
+	if (factor === void 0) throw new Error(`Memory: unknown unit "${m[2]}" in "${s}" — supported: ${Object.keys(UNIT_BYTES).join(", ")}`);
+	return value * factor;
+};
+/**
+* Coerce a {@link Input} to a {@link Memory}. Throws on malformed
+* strings or non-finite numbers. Mirrors `Duration.fromInputUnsafe`.
+*/
+const fromInputUnsafe = (input) => {
+	if (typeof input === "number") {
+		if (!Number.isFinite(input) || input < 0) throw new Error(`Memory: bytes must be a non-negative finite number, got ${input}`);
+		return make(Math.floor(input));
+	}
+	return make(Math.floor(parseString(input)));
+};
+/** Return the underlying byte count. */
+const toBytes = (m) => typeof m === "number" && m === Math.floor(m) && m >= 0 ? m : fromInputUnsafe(m);
+/** N bytes. */
+const bytes = (n) => make(Math.floor(n));
+/** N KiB (binary kibibytes, `n * 1024`). */
+const kib = (n) => make(Math.floor(n * 1024));
+/** N MiB (binary mebibytes, `n * 1024^2`). */
+const mib = (n) => make(Math.floor(n * 1024 * 1024));
+/** N GiB (binary gibibytes, `n * 1024^3`). */
+const gib = (n) => make(Math.floor(n * 1024 * 1024 * 1024));
+/** N kB (decimal kilobytes, `n * 1000`). */
+const kb = (n) => make(Math.floor(n * 1e3));
+/** N MB (decimal megabytes, `n * 1_000_000`). */
+const mb = (n) => make(Math.floor(n * 1e6));
+/** N GB (decimal gigabytes, `n * 1_000_000_000`). */
+const gb = (n) => make(Math.floor(n * 1e9));
+//#endregion
+export { bytes, fromInputUnsafe, gb, gib, kb, kib, mb, mib, Memory_exports as t, toBytes };
+
+//# sourceMappingURL=Memory.mjs.map

package/dist/sandbox/Memory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Memory.mjs","names":[],"sources":["../../src/sandbox/Memory.ts"],"sourcesContent":["import { Brand } from \"effect\"\n\n/**\n * A memory / data size, always represented internally as a number of\n * bytes. Mirrors the `Duration` shape from `effect` — a branded value\n * type with a wider `Input` union for ergonomic construction at call\n * sites.\n *\n * `effect` itself has no byte-count primitive (only `Duration`), so we\n * own this here rather than leak provider-specific shapes (Deno's\n * template-literal `Memory`, Vercel's `mb`, Modal's `gpuMemory`, …)\n * through the cross-provider `Sandbox` request types.\n *\n * @example\n * ```ts\n * import * as Memory from \"@effect-uai/core/Memory\"\n *\n * Memory.gib(2)                        // 2 GiB → 2_147_483_648 bytes\n * Memory.fromInputUnsafe(\"1.5 GiB\")    // human-string parsing\n * Memory.fromInputUnsafe(1_280_000_000) // raw bytes\n * Memory.toBytes(m)                    // unwrap\n * ```\n */\n\nexport type Memory = Brand.Branded<number, \"Memory\">\n\nconst make = Brand.nominal<Memory>()\n\n// ---------------------------------------------------------------------------\n// Input — what the public APIs accept.\n//\n// Supported string forms (case-insensitive on the unit, whitespace\n// optional between number and unit):\n//\n//   \"<n>\"       bytes (no unit)\n//   \"<n> B\"     bytes\n//   \"<n> kB\"   1_000 bytes      (decimal)\n//   \"<n> MB\"   1_000_000        (decimal)\n//   \"<n> GB\"   1_000_000_000    (decimal)\n//   \"<n> KiB\"  1_024            (binary)\n//   \"<n> MiB\"  1_048_576        (binary)\n//   \"<n> GiB\"  1_073_741_824    (binary)\n//\n// Decimal vs binary follows the SI / IEC convention (`MB` = 10^6,\n// `MiB` = 2^20). When in doubt, prefer the binary `*iB` units.\n// ---------------------------------------------------------------------------\n\nexport type Input = number | Memory | string\n\nconst UNIT_BYTES: Record<string, number> = {\n  b: 1,\n  kb: 1_000,\n  mb: 1_000_000,\n  gb: 1_000_000_000,\n  tb: 1_000_000_000_000,\n  kib: 1_024,\n  mib: 1_024 * 1_024,\n  gib: 1_024 * 1_024 * 1_024,\n  tib: 1_024 * 1_024 * 1_024 * 1_024,\n}\n\nconst PARSE_RE = /^\\s*(\\d+(?:\\.\\d+)?)\\s*([a-zA-Z]*)\\s*$/\n\nconst parseString = (s: string): number => {\n  const m = PARSE_RE.exec(s)\n  if (m === null) {\n    throw new Error(`Memory: cannot parse \"${s}\" — expected forms like \"1024\", \"10 MB\", \"1GiB\"`)\n  }\n  const value = Number(m[1])\n  const unit = (m[2] ?? \"\").toLowerCase()\n  if (unit === \"\") return value\n  const factor = UNIT_BYTES[unit]\n  if (factor === undefined) {\n    throw new Error(\n      `Memory: unknown unit \"${m[2]}\" in \"${s}\" — supported: ${Object.keys(UNIT_BYTES).join(\", \")}`,\n    )\n  }\n  return value * factor\n}\n\n/**\n * Coerce a {@link Input} to a {@link Memory}. Throws on malformed\n * strings or non-finite numbers. Mirrors `Duration.fromInputUnsafe`.\n */\nexport const fromInputUnsafe = (input: Input): Memory => {\n  if (typeof input === \"number\") {\n    if (!Number.isFinite(input) || input < 0) {\n      throw new Error(`Memory: bytes must be a non-negative finite number, got ${input}`)\n    }\n    return make(Math.floor(input))\n  }\n  return make(Math.floor(parseString(input)))\n}\n\n// ---------------------------------------------------------------------------\n// Unwrap\n// ---------------------------------------------------------------------------\n\n/** Return the underlying byte count. */\nexport const toBytes = (m: Memory | Input): number =>\n  typeof m === \"number\" && (m as number) === Math.floor(m as number) && (m as number) >= 0\n    ? (m as number)\n    : (fromInputUnsafe(m) as unknown as number)\n\n// ---------------------------------------------------------------------------\n// Unit constructors — terse for use at call sites.\n// ---------------------------------------------------------------------------\n\n/** N bytes. */\nexport const bytes = (n: number): Memory => make(Math.floor(n))\n\n/** N KiB (binary kibibytes, `n * 1024`). */\nexport const kib = (n: number): Memory => make(Math.floor(n * 1_024))\n\n/** N MiB (binary mebibytes, `n * 1024^2`). */\nexport const mib = (n: number): Memory => make(Math.floor(n * 1_024 * 1_024))\n\n/** N GiB (binary gibibytes, `n * 1024^3`). */\nexport const gib = (n: number): Memory => make(Math.floor(n * 1_024 * 1_024 * 1_024))\n\n/** N kB (decimal kilobytes, `n * 1000`). */\nexport const kb = (n: number): Memory => make(Math.floor(n * 1_000))\n\n/** N MB (decimal megabytes, `n * 1_000_000`). */\nexport const mb = (n: number): Memory => make(Math.floor(n * 1_000_000))\n\n/** N GB (decimal gigabytes, `n * 1_000_000_000`). */\nexport const gb = (n: number): Memory => make(Math.floor(n * 1_000_000_000))\n"],"mappings":";;;;;;;;;;;;;;AA0BA,MAAM,OAAO,MAAM,SAAiB;AAuBpC,MAAM,aAAqC;CACzC,GAAG;CACH,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,IAAI;CACJ,KAAK;CACL,KAAK,OAAQ;CACb,KAAK,OAAQ,OAAQ;CACrB,KAAK,OAAQ,OAAQ,OAAQ;CAC9B;AAED,MAAM,WAAW;AAEjB,MAAM,eAAe,MAAsB;CACzC,MAAM,IAAI,SAAS,KAAK,EAAE;AAC1B,KAAI,MAAM,KACR,OAAM,IAAI,MAAM,yBAAyB,EAAE,iDAAiD;CAE9F,MAAM,QAAQ,OAAO,EAAE,GAAG;CAC1B,MAAM,QAAQ,EAAE,MAAM,IAAI,aAAa;AACvC,KAAI,SAAS,GAAI,QAAO;CACxB,MAAM,SAAS,WAAW;AAC1B,KAAI,WAAW,KAAA,EACb,OAAM,IAAI,MACR,yBAAyB,EAAE,GAAG,QAAQ,EAAE,iBAAiB,OAAO,KAAK,WAAW,CAAC,KAAK,KAAK,GAC5F;AAEH,QAAO,QAAQ;;;;;;AAOjB,MAAa,mBAAmB,UAAyB;AACvD,KAAI,OAAO,UAAU,UAAU;AAC7B,MAAI,CAAC,OAAO,SAAS,MAAM,IAAI,QAAQ,EACrC,OAAM,IAAI,MAAM,2DAA2D,QAAQ;AAErF,SAAO,KAAK,KAAK,MAAM,MAAM,CAAC;;AAEhC,QAAO,KAAK,KAAK,MAAM,YAAY,MAAM,CAAC,CAAC;;;AAQ7C,MAAa,WAAW,MACtB,OAAO,MAAM,YAAa,MAAiB,KAAK,MAAM,EAAY,IAAK,KAAgB,IAClF,IACA,gBAAgB,EAAE;;AAOzB,MAAa,SAAS,MAAsB,KAAK,KAAK,MAAM,EAAE,CAAC;;AAG/D,MAAa,OAAO,MAAsB,KAAK,KAAK,MAAM,IAAI,KAAM,CAAC;;AAGrE,MAAa,OAAO,MAAsB,KAAK,KAAK,MAAM,IAAI,OAAQ,KAAM,CAAC;;AAG7E,MAAa,OAAO,MAAsB,KAAK,KAAK,MAAM,IAAI,OAAQ,OAAQ,KAAM,CAAC;;AAGrF,MAAa,MAAM,MAAsB,KAAK,KAAK,MAAM,IAAI,IAAM,CAAC;;AAGpE,MAAa,MAAM,MAAsB,KAAK,KAAK,MAAM,IAAI,IAAU,CAAC;;AAGxE,MAAa,MAAM,MAAsB,KAAK,KAAK,MAAM,IAAI,IAAc,CAAC"}