@effect-uai/core 0.12.0 → 0.12.1

package/dist/{AiError-Bf1pq4BB.d.mts → AiError-eLV9t1lU.d.mts}

@@ -1,13 +1,9 @@
 import { Duration } from "effect";
-import * as _$effect_Cause0 from "effect/Cause";
-import * as _$effect_Types0 from "effect/Types";
-
-//#region src/domain/AiError.d.ts
 declare namespace AiError_d_exports {
   export { AiError, AuthFailed, AuthSubtype, Cancelled, ContentFiltered, ContextLengthExceeded, GenerationFailed, IncompleteTurn, InvalidRequest, RateLimited, Scope$1 as Scope, Timeout, Unavailable, Unsupported, describe };
 }
 type Scope$1 = "rpm" | "tpm" | "rpd" | "tpd";
-declare const RateLimited_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const RateLimited_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "RateLimited";
 } & Readonly<A>;
 declare class RateLimited extends RateLimited_base<{
@@ -17,7 +13,7 @@ declare class RateLimited extends RateLimited_base<{
   requestId?: string;
   raw: unknown;
 }> {}
-declare const Unavailable_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const Unavailable_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "Unavailable";
 } & Readonly<A>;
 declare class Unavailable extends Unavailable_base<{
@@ -27,7 +23,7 @@ declare class Unavailable extends Unavailable_base<{
   requestId?: string;
   raw: unknown;
 }> {}
-declare const Timeout_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const Timeout_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "Timeout";
 } & Readonly<A>;
 declare class Timeout extends Timeout_base<{
@@ -35,7 +31,7 @@ declare class Timeout extends Timeout_base<{
   requestId?: string;
   raw: unknown;
 }> {}
-declare const ContentFiltered_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const ContentFiltered_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "ContentFiltered";
 } & Readonly<A>;
 declare class ContentFiltered extends ContentFiltered_base<{
@@ -44,7 +40,7 @@ declare class ContentFiltered extends ContentFiltered_base<{
   requestId?: string;
   raw: unknown;
 }> {}
-declare const ContextLengthExceeded_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const ContextLengthExceeded_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "ContextLengthExceeded";
 } & Readonly<A>;
 declare class ContextLengthExceeded extends ContextLengthExceeded_base<{
@@ -53,7 +49,7 @@ declare class ContextLengthExceeded extends ContextLengthExceeded_base<{
   requested?: number;
   raw: unknown;
 }> {}
-declare const InvalidRequest_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const InvalidRequest_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "InvalidRequest";
 } & Readonly<A>;
 declare class InvalidRequest extends InvalidRequest_base<{
@@ -63,7 +59,7 @@ declare class InvalidRequest extends InvalidRequest_base<{
   raw: unknown;
 }> {}
 type AuthSubtype = "auth" | "permission" | "billing" | "quota";
-declare const AuthFailed_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const AuthFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "AuthFailed";
 } & Readonly<A>;
 declare class AuthFailed extends AuthFailed_base<{
@@ -71,13 +67,13 @@ declare class AuthFailed extends AuthFailed_base<{
   subtype: AuthSubtype;
   raw: unknown;
 }> {}
-declare const Cancelled_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const Cancelled_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "Cancelled";
 } & Readonly<A>;
 declare class Cancelled extends Cancelled_base<{
   provider: string;
 }> {}
-declare const GenerationFailed_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const GenerationFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "GenerationFailed";
 } & Readonly<A>;
 /**
@@ -93,7 +89,7 @@ declare class GenerationFailed extends GenerationFailed_base<{
   requestId?: string;
   raw: unknown;
 }> {}
-declare const IncompleteTurn_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const IncompleteTurn_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "IncompleteTurn";
 } & Readonly<A>;
 /**
@@ -104,7 +100,7 @@ declare const IncompleteTurn_base: new <A extends Record<string, any> = {}>(args
 declare class IncompleteTurn extends IncompleteTurn_base<{
   raw?: unknown;
 }> {}
-declare const Unsupported_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const Unsupported_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "Unsupported";
 } & Readonly<A>;
 /**
@@ -134,4 +130,4 @@ type AiError = RateLimited | Unavailable | Timeout | ContentFiltered | ContextLe
 declare const describe: (e: AiError) => string;
 //#endregion
 export { Cancelled as a, GenerationFailed as c, RateLimited as d, Scope$1 as f, describe as g, Unsupported as h, AuthSubtype as i, IncompleteTurn as l, Unavailable as m, AiError_d_exports as n, ContentFiltered as o, Timeout as p, AuthFailed as r, ContextLengthExceeded as s, AiError as t, InvalidRequest as u };
-//# sourceMappingURL=AiError-Bf1pq4BB.d.mts.map
+//# sourceMappingURL=AiError-eLV9t1lU.d.mts.map

package/dist/AiError-eLV9t1lU.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AiError-eLV9t1lU.d.mts","names":[],"sources":["../src/domain/AiError.ts"],"mappings":";;;;KAEY;;;;cAEC,oBAAoB;EAC/B;EACA,aAAa,SAAS;EACtB,QAAQ;EACR;EACA;;;;;cAGW,oBAAoB;EAC/B;EACA,aAAa,SAAS;EACtB;EACA;EACA;;;;;cAGW,gBAAgB;EAC3B;EACA;EACA;;;;;cAGW,wBAAwB;EACnC;EACA;EACA;EACA;;;;;cAGW,8BAA8B;EACzC;EACA;EACA;EACA;;;;;cAGW,uBAAuB;EAClC;EACA;EACA;EACA;;KAGU;;;;cAEC,mBAAmB;EAC9B;EACA,SAAS;EACT;;;;;cAGW,kBAAkB;EAC7B;;;;;;;;;;;cASW,yBAAyB;EACpC;EACA;EACA;EACA;EACA;;;;;;;;;;cAQW,uBAAuB;EAClC;;;;;;;;;;;;;;;;;;;cAiBW,oBAAoB;EAC/B;EACA;EACA;;KAGU,UACR,cACA,cACA,UACA,kBACA,wBACA,iBACA,aACA,YACA,iBACA,mBACA;;;;;cASS,WAAW,GAAG"}

package/dist/{Audio-CR7CSljJ.d.mts → Audio-60lKKHxS.d.mts}

@@ -1,7 +1,5 @@
-import { i as MediaUrl, n as MediaBytes, t as MediaBase64 } from "./Media-D_CpcM1Z.mjs";
+import { i as MediaUrl, n as MediaBytes, t as MediaBase64 } from "./Media-DwgpifPD.mjs";
 import { Duration } from "effect";
-
-//#region src/domain/Audio.d.ts
 declare namespace Audio_d_exports {
   export { AudioBlob, AudioChunk, AudioFormat, AudioMimeType, AudioSource, isAudioBase64, isAudioBytes, isAudioUrl };
 }
@@ -36,7 +34,8 @@ declare const isAudioBytes: (s: AudioSource) => s is MediaBytes<AudioMimeType>;
 type AudioFormat = {
   readonly container: "mp3" | "wav" | "ogg" | "opus" | "flac" | "aac" | "webm" | "raw";
   readonly encoding: "pcm_s16le" | "pcm_f32le" | "pcm_mulaw" | "pcm_alaw" | "mp3" | "opus" | "vorbis" | "flac" | "aac";
-  readonly sampleRate: 8000 | 16000 | 22050 | 24000 | 32000 | 44100 | 48000; /** mp3 / opus only. */
+  readonly sampleRate: 8000 | 16000 | 22050 | 24000 | 32000 | 44100 | 48000;
+  /** mp3 / opus only. */
   readonly bitRate?: number;
   readonly channels?: 1 | 2;
 };
@@ -59,4 +58,4 @@ type AudioBlob = {
 };
 //#endregion
 export { AudioSource as a, isAudioBytes as c, AudioMimeType as i, isAudioUrl as l, AudioChunk as n, Audio_d_exports as o, AudioFormat as r, isAudioBase64 as s, AudioBlob as t };
-//# sourceMappingURL=Audio-CR7CSljJ.d.mts.map
+//# sourceMappingURL=Audio-60lKKHxS.d.mts.map

package/dist/Audio-60lKKHxS.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Audio-60lKKHxS.d.mts","names":[],"sources":["../src/domain/Audio.ts"],"mappings":";;;;;;;;;;;;;KAWY;;;;;;;;;;KA0BA,cACR,SAAS,iBACT,YAAY,iBACZ,WAAW;cAEF,aAAU,GAAO,gBAAc,KAAK,SAAS;cAC7C,gBAAa,GAAO,gBAAc,KAAK,YAAY;cAEnD,eAAY,GAAO,gBAAc,KAAK,WAAW;;;;;;;KAQlD;WACD;WACA;WAUA;;WAEA;WACA;;;;;;;KAQC;WACD,OAAO;;;;;;KAON;WACD,QAAQ;WACR,OAAO;WACP,WAAW,SAAS"}

package/dist/{Image-C4vuBmu0.d.mts → Image-BK8-4H6s.d.mts}

@@ -1,7 +1,5 @@
-import { i as MediaUrl, n as MediaBytes, r as MediaSource, t as MediaBase64 } from "./Media-D_CpcM1Z.mjs";
+import { i as MediaUrl, n as MediaBytes, r as MediaSource, t as MediaBase64 } from "./Media-DwgpifPD.mjs";
 import { Schema } from "effect";
-
-//#region src/domain/Image.d.ts
 declare namespace Image_d_exports {
   export { ImageBase64Source, ImageBytesSource, ImageMimeType, ImageSource, ImageUrlSource, imageBase64, imageBytes, imageUrl, isImageBase64, isImageBytes, isImageUrl };
 }
@@ -46,16 +44,16 @@ declare const isImageUrl: <I>(input: I) => input is I & {
   readonly url: string;
   readonly mimeType?: ImageMimeType | undefined;
 };
-declare const isImageBase64: <I>(input: I) => input is I & Schema.Struct.ReadonlySide<{
-  readonly _tag: Schema.tag<"base64">;
-  readonly base64: Schema.String;
-  readonly mimeType: Schema.Schema<ImageMimeType>;
-}, "Type">;
-declare const isImageBytes: <I>(input: I) => input is I & Schema.Struct.ReadonlySide<{
-  readonly _tag: Schema.tag<"bytes">;
-  readonly bytes: Schema.Uint8Array;
-  readonly mimeType: Schema.Schema<ImageMimeType>;
-}, "Type">;
+declare const isImageBase64: <I>(input: I) => input is I & {
+  readonly _tag: "base64";
+  readonly base64: string;
+  readonly mimeType: ImageMimeType;
+};
+declare const isImageBytes: <I>(input: I) => input is I & {
+  readonly _tag: "bytes";
+  readonly bytes: Uint8Array<ArrayBufferLike>;
+  readonly mimeType: ImageMimeType;
+};
 //#endregion
 export { ImageUrlSource as a, imageBytes as c, isImageBytes as d, isImageUrl as f, ImageSource as i, imageUrl as l, ImageBytesSource as n, Image_d_exports as o, ImageMimeType as r, imageBase64 as s, ImageBase64Source as t, isImageBase64 as u };
-//# sourceMappingURL=Image-C4vuBmu0.d.mts.map
+//# sourceMappingURL=Image-BK8-4H6s.d.mts.map

package/dist/Image-BK8-4H6s.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Image-BK8-4H6s.d.mts","names":[],"sources":["../src/domain/Image.ts"],"mappings":";;;;;;;;;;;;;KAWY;KAYA,iBAAiB,SAAS;KAC1B,oBAAoB,YAAY;KAChC,mBAAmB,WAAW;;;;;;;;KAS9B,cAAc,YAAY;cAEzB,gBAAc,OAAA;;;;cAKd,mBAAiB,OAAA;;;;cAKjB,kBAAgB,OAAA;;;;cAKhB,aAAa,OAAO,OAAO;cAM3B,WAAQ,aAAe,WAAa,kBAAgB;cAGpD,cAAW,gBAAkB,UAAY,kBAAgB;cAMzD,aAAU,OAAW,YAAU,UAAY,kBAAgB;cAM3D,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;cACV,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;;cACb,eAAY,GAAA,OAAA,MAAA,SAAA"}

package/dist/{Items-BKQgqJ8A.d.mts → Items-SfUabNuB.d.mts}

@@ -1,7 +1,5 @@
-import { i as ImageSource } from "./Image-C4vuBmu0.mjs";
+import { i as ImageSource } from "./Image-BK8-4H6s.mjs";
 import { Schema } from "effect";
-
-//#region src/domain/Items.d.ts
 declare namespace Items_d_exports {
   export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, HistoryItem, InputImage, InputText, InputTokensDetails, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, ToolCall, ToolCallOutput, UrlCitation, Usage, assistantText, isContainerFileCitation, isFileCitation, isFilePath, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isToolCall, isToolCallOutput, isUrlCitation, systemText, toolCallOutput, userText };
 }
@@ -94,23 +92,23 @@ declare const isUrlCitation: <I>(input: I) => input is I & {
   readonly cited_text?: string | undefined;
   readonly marker?: number | undefined;
 };
-declare const isFileCitation: <I>(input: I) => input is I & Schema.Struct.ReadonlySide<{
-  readonly type: Schema.Literal<"file_citation">;
-  readonly file_id: Schema.String;
-  readonly index: Schema.Number;
-}, "Type">;
-declare const isContainerFileCitation: <I>(input: I) => input is I & Schema.Struct.ReadonlySide<{
-  readonly type: Schema.Literal<"container_file_citation">;
-  readonly container_id: Schema.String;
-  readonly file_id: Schema.String;
-  readonly start_index: Schema.Number;
-  readonly end_index: Schema.Number;
-}, "Type">;
-declare const isFilePath: <I>(input: I) => input is I & Schema.Struct.ReadonlySide<{
-  readonly type: Schema.Literal<"file_path">;
-  readonly file_id: Schema.String;
-  readonly index: Schema.Number;
-}, "Type">;
+declare const isFileCitation: <I>(input: I) => input is I & {
+  readonly type: "file_citation";
+  readonly file_id: string;
+  readonly index: number;
+};
+declare const isContainerFileCitation: <I>(input: I) => input is I & {
+  readonly type: "container_file_citation";
+  readonly container_id: string;
+  readonly file_id: string;
+  readonly start_index: number;
+  readonly end_index: number;
+};
+declare const isFilePath: <I>(input: I) => input is I & {
+  readonly type: "file_path";
+  readonly file_id: string;
+  readonly index: number;
+};
 declare const OutputText: Schema.Struct<{
   readonly type: Schema.Literal<"output_text">;
   readonly text: Schema.String;
@@ -319,14 +317,14 @@ declare const HistoryItem: Schema.Union<readonly [Schema.Struct<{
   readonly providerData: Schema.optional<Schema.Unknown>;
 }>]>;
 type HistoryItem = typeof HistoryItem.Type;
-declare const isInputText: <I>(input: I) => input is I & Schema.Struct.ReadonlySide<{
-  readonly type: Schema.Literal<"input_text">;
-  readonly text: Schema.String;
-}, "Type">;
-declare const isInputImage: <I>(input: I) => input is I & Schema.Struct.ReadonlySide<{
-  readonly type: Schema.Literal<"input_image">;
-  readonly source: Schema.Schema<ImageSource>;
-}, "Type">;
+declare const isInputText: <I>(input: I) => input is I & {
+  readonly type: "input_text";
+  readonly text: string;
+};
+declare const isInputImage: <I>(input: I) => input is I & {
+  readonly type: "input_image";
+  readonly source: ImageSource;
+};
 declare const isOutputText: <I>(input: I) => input is I & {
   readonly type: "output_text";
   readonly text: string;
@@ -338,35 +336,36 @@ declare const isOutputText: <I>(input: I) => input is I & {
     readonly end_index?: number | undefined;
     readonly cited_text?: string | undefined;
     readonly marker?: number | undefined;
-  } | Schema.Struct.ReadonlySide<{
-    readonly type: Schema.Literal<"file_citation">;
-    readonly file_id: Schema.String;
-    readonly index: Schema.Number;
-  }, "Type"> | Schema.Struct.ReadonlySide<{
-    readonly type: Schema.Literal<"container_file_citation">;
-    readonly container_id: Schema.String;
-    readonly file_id: Schema.String;
-    readonly start_index: Schema.Number;
-    readonly end_index: Schema.Number;
-  }, "Type"> | Schema.Struct.ReadonlySide<{
-    readonly type: Schema.Literal<"file_path">;
-    readonly file_id: Schema.String;
-    readonly index: Schema.Number;
-  }, "Type">)[] | undefined;
+  } | {
+    readonly type: "file_citation";
+    readonly file_id: string;
+    readonly index: number;
+  } | {
+    readonly type: "container_file_citation";
+    readonly container_id: string;
+    readonly file_id: string;
+    readonly start_index: number;
+    readonly end_index: number;
+  } | {
+    readonly type: "file_path";
+    readonly file_id: string;
+    readonly index: number;
+  })[] | undefined;
+};
+declare const isRefusal: <I>(input: I) => input is I & {
+  readonly type: "refusal";
+  readonly text: string;
 };
-declare const isRefusal: <I>(input: I) => input is I & Schema.Struct.ReadonlySide<{
-  readonly type: Schema.Literal<"refusal">;
-  readonly text: Schema.String;
-}, "Type">;
 declare const isMessage: <I>(input: I) => input is I & {
   readonly type: "message";
-  readonly content: readonly (Schema.Struct.ReadonlySide<{
-    readonly type: Schema.Literal<"input_text">;
-    readonly text: Schema.String;
-  }, "Type"> | Schema.Struct.ReadonlySide<{
-    readonly type: Schema.Literal<"input_image">;
-    readonly source: Schema.Schema<ImageSource>;
-  }, "Type"> | {
+  readonly role: "assistant" | "system" | "user";
+  readonly content: readonly ({
+    readonly type: "input_text";
+    readonly text: string;
+  } | {
+    readonly type: "input_image";
+    readonly source: ImageSource;
+  } | {
     readonly type: "output_text";
     readonly text: string;
     readonly annotations?: readonly ({
@@ -377,26 +376,25 @@ declare const isMessage: <I>(input: I) => input is I & {
       readonly end_index?: number | undefined;
       readonly cited_text?: string | undefined;
       readonly marker?: number | undefined;
-    } | Schema.Struct.ReadonlySide<{
-      readonly type: Schema.Literal<"file_citation">;
-      readonly file_id: Schema.String;
-      readonly index: Schema.Number;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-      readonly type: Schema.Literal<"container_file_citation">;
-      readonly container_id: Schema.String;
-      readonly file_id: Schema.String;
-      readonly start_index: Schema.Number;
-      readonly end_index: Schema.Number;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-      readonly type: Schema.Literal<"file_path">;
-      readonly file_id: Schema.String;
-      readonly index: Schema.Number;
-    }, "Type">)[] | undefined;
-  } | Schema.Struct.ReadonlySide<{
-    readonly type: Schema.Literal<"refusal">;
-    readonly text: Schema.String;
-  }, "Type">)[];
-  readonly role: "user" | "assistant" | "system";
+    } | {
+      readonly type: "file_citation";
+      readonly file_id: string;
+      readonly index: number;
+    } | {
+      readonly type: "container_file_citation";
+      readonly container_id: string;
+      readonly file_id: string;
+      readonly start_index: number;
+      readonly end_index: number;
+    } | {
+      readonly type: "file_path";
+      readonly file_id: string;
+      readonly index: number;
+    })[] | undefined;
+  } | {
+    readonly type: "refusal";
+    readonly text: string;
+  })[];
   readonly providerData?: unknown;
 };
 declare const isToolCall: <I>(input: I) => input is I & {
@@ -415,9 +413,9 @@ declare const isToolCallOutput: <I>(input: I) => input is I & {
 declare const isReasoning: <I>(input: I) => input is I & {
   readonly type: "reasoning";
   readonly id?: string | undefined;
-  readonly providerData?: unknown;
   readonly summary?: string | undefined;
   readonly signature?: string | undefined;
+  readonly providerData?: unknown;
 };
 /**
  * Prompt-cache token breakdown. `cached_tokens` is cache reads;
@@ -460,4 +458,4 @@ declare const assistantText: (text: string) => Message;
 declare const toolCallOutput: (call_id: string, output: string) => ToolCallOutput;
 //#endregion
 export { isReasoning as A, isContainerFileCitation as C, isInputText as D, isInputImage as E, systemText as F, toolCallOutput as I, userText as L, isToolCall as M, isToolCallOutput as N, isMessage as O, isUrlCitation as P, assistantText as S, isFilePath as T, StopReason as _, FilePath as a, UrlCitation as b, InputText as c, Message as d, OutputText as f, Role as g, Refusal as h, FileCitation as i, isRefusal as j, isOutputText as k, InputTokensDetails as l, Reasoning as m, ContainerFileCitation as n, HistoryItem as o, OutputTokensDetails as p, ContentBlock as r, InputImage as s, Annotation as t, Items_d_exports as u, ToolCall as v, isFileCitation as w, Usage as x, ToolCallOutput as y };
-//# sourceMappingURL=Items-BKQgqJ8A.d.mts.map
+//# sourceMappingURL=Items-SfUabNuB.d.mts.map

package/dist/Items-SfUabNuB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Items-SfUabNuB.d.mts","names":[],"sources":["../src/domain/Items.ts"],"mappings":";;;;;cAOa,WAAS,OAAA;;;;KAIV,mBAAmB,UAAU;;;;;;;;;cAU5B,YAAU,OAAA;;;;KAIX,oBAAoB,WAAW;;;;;;;;;cAgB9B,aAAW,OAAA;;;;;;;;;KASZ,qBAAqB,YAAY;cAEhC,cAAY,OAAA;;;;;KAKb,sBAAsB,aAAa;cAElC,uBAAqB,OAAA;;;;;;;KAOtB,+BAA+B,sBAAsB;cAEpD,UAAQ,OAAA;;;;;KAKT,kBAAkB,SAAS;cAE1B,YAAU,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;KACX,oBAAoB,WAAW;cAE9B,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;;;;;;cACb,iBAAc,GAAA,OAAA,MAAA,SAAA;;;;;cACd,0BAAuB,GAAA,OAAA,MAAA,SAAA;;;;;;;cACvB,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;cAEV,YAAU,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKX,oBAAoB,WAAW;;;;;;;cAQ9B,SAAO,OAAA;;;;KAIR,iBAAiB,QAAQ;cAExB,cAAY,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACb,sBAAsB,aAAa;cAElC,MAAI,OAAA;KACL,cAAc,KAAK;cAqBlB,SAAO,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMR,iBAAiB,QAAQ;cAExB,UAAQ,OAAA;;;;;;;KAQT,kBAAkB,SAAS;cAE1B,gBAAc,OAAA;;;;;;KAMf,wBAAwB,eAAe;;;;;;;cAQtC,WAAS,OAAA;;;;;;;KAOV,mBAAmB,UAAU;cAE5B,aAAW,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KACZ,qBAAqB,YAAY;cAMhC,cAAW,GAAA,OAAA,MAAA,SAAA;;;;cACX,eAAY,GAAA,OAAA,MAAA,SAAA;;;;cACZ,eAAY,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cACZ,YAAS,GAAA,OAAA,MAAA,SAAA;;;;cAET,YAAS,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cACT,aAAU,GAAA,OAAA,MAAA,SAAA;;;;;;;cACV,mBAAgB,GAAA,OAAA,MAAA,SAAA;;;;;;cAChB,cAAW,GAAA,OAAA,MAAA,SAAA;;;;;;;;;;;;;;;;;;cAiBX,oBAAkB,OAAA;;;;KAInB,4BAA4B,mBAAmB;cAE9C,qBAAmB,OAAA;;;KAGpB,6BAA6B,oBAAoB;cAEhD,OAAK,OAAA;;;;;;;;;;;;KAON,eAAe,MAAM;cAEpB,YAAU,OAAA;KAUX,oBAAoB,WAAW;cAM9B,WAAQ,iBAAmB;cAM3B,aAAU,iBAAmB;cAM7B,gBAAa,iBAAmB;cAMhC,iBAAc,iBAAmB,mBAAmB"}

package/dist/{Loop-D8nWpowc.d.mts → Loop-B54AB1ME.d.mts}

@@ -1,8 +1,6 @@
-import { l as IncompleteTurn } from "./AiError-Bf1pq4BB.mjs";
+import { l as IncompleteTurn } from "./AiError-eLV9t1lU.mjs";
 import { Turn, TurnEvent } from "./domain/Turn.mjs";
 import { Data, Effect, Stream, SubscriptionRef } from "effect";
-
-//#region src/loop/Loop.d.ts
 declare namespace Loop_d_exports {
   export { Next, Step, Stop, StopWith, Value, loop, loopOver, loopWithState, next, onTurnComplete, stop, value };
 }
@@ -41,23 +39,23 @@ type Step<A, S> = Data.TaggedEnum<{
  * single-element-stream wrapping for `next` / `stop`.
  */
 declare const Value: <A, B>(args: {
-    readonly value: A;
-  }) => {
-    readonly _tag: "Value";
-    readonly value: A;
-  }, Next: <A, B>(args: {
-    readonly state: B;
-  }) => {
-    readonly _tag: "Next";
-    readonly state: B;
-  }, Stop: <A, B>(args: void) => {
-    readonly _tag: "Stop";
-  }, StopWith: <A, B>(args: {
-    readonly state: B;
-  }) => {
-    readonly _tag: "StopWith";
-    readonly state: B;
-  };
+  readonly value: A;
+}) => {
+  readonly _tag: "Value";
+  readonly value: A;
+}, Next: <A, B>(args: {
+  readonly state: B;
+}) => {
+  readonly _tag: "Next";
+  readonly state: B;
+}, Stop: <A, B>(args: void) => {
+  readonly _tag: "Stop";
+}, StopWith: <A, B>(args: {
+  readonly state: B;
+}) => {
+  readonly _tag: "StopWith";
+  readonly state: B;
+};
 /** Wrap a value so it flows through the loop to downstream consumers. */
 declare const value: <A>(a: A) => Step<A, never>;
 /**
@@ -170,4 +168,4 @@ declare const loopWithState: <S, A, E, R>(initial: S, body: LoopBody<S, A, E, R>
 }>;
 //#endregion
 export { StopWith as a, loopOver as c, onTurnComplete as d, stop as f, Stop as i, loopWithState as l, Next as n, Value as o, value as p, Step as r, loop as s, Loop_d_exports as t, next as u };
-//# sourceMappingURL=Loop-D8nWpowc.d.mts.map
+//# sourceMappingURL=Loop-B54AB1ME.d.mts.map

package/dist/Loop-B54AB1ME.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Loop-B54AB1ME.d.mts","names":[],"sources":["../src/loop/Loop.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;KAwDY,KAAK,GAAG,KAAK,KAAK;EAC5B;aAAkB,OAAO;;EACzB;aAAiB,OAAO;;EACxB;EACA;aAAqB,OAAO;;;;;;;;;;;cAiBf,QAAK,GAAA,GAAA;;;;;GAAE,OAAI,GAAA,GAAA;;;;;GAAE,OAAI,GAAA,GAAA;;GAAE,WAAQ,GAAA,GAAA;;;;;;;cAG7B,QAAS,GAAC,GAAK,MAAI,KAAK;;;;;;cAOxB,OAAQ,GAAC,OAAS,MAAI,OAAO,OAAO,YAAY;;;;;;;;cAUhD,OAAQ,WAAS,QAAU,MAAI,OAAO,OAAO,YAAY;;;;;;;;;;;;;;;;;;;;;;;;KA8BjE,iBAAiB,GAAG,GAAG,IAAI,MAC5B,OAAO,OAAO,KAAK,GAAG,IAAI,IAAI,MAC9B,OAAO,OAAO,OAAO,OAAO,KAAK,GAAG,IAAI,IAAI,KAAK,IAAI;cAE5C;GACV,GAAG,GAAG,YAAY,YACjB,OAAO,MAAM,SAAS,iBAAiB,GAAG,GAAG,IAAI,OAC/C,GAAG,GACL,QAAQ,OAAO,OAAO,WAAW,GAAG,OACjC,OAAO,OAAO,KAAK,YAAY,GAAG,IAAI,IAAI,KAAK,gBAAgB,IAAI;GACvE,GAAG,GAAG,GAAG,GAAG,YAAY,YACvB,QAAQ,OAAO,OAAO,WAAW,GAAG,IACpC,OAAO,MAAM,SAAS,iBAAiB,GAAG,GAAG,IAAI,MAChD,OAAO,OAAO,KAAK,YAAY,GAAG,IAAI,IAAI,KAAK,gBAAgB,IAAI;;KA2EnE,SAAS,GAAG,GAAG,GAAG,MACrB,OAAO,MACJ,OAAO,OAAO,KAAK,GAAG,IAAI,GAAG,KAAK,OAAO,OAAO,OAAO,OAAO,KAAK,GAAG,IAAI,GAAG,IAAI,GAAG;;;;;;;;;;cAW5E;GACV,GAAG,GAAG,GAAG,GAAG,MAAM,SAAS,GAAG,GAAG,GAAG,MAAM,SAAS,MAAM,OAAO,OAAO,GAAG,GAAG;GAC7E,GAAG,GAAG,GAAG,GAAG,SAAS,GAAG,MAAM,SAAS,GAAG,GAAG,GAAG,KAAK,OAAO,OAAO,GAAG,GAAG;;KA2FvE,aAAa,GAAG,GAAG,GAAG,GAAG,MAC5B,OAAO,GACP,OAAO,MACJ,OAAO,OAAO,KAAK,GAAG,IAAI,GAAG,KAAK,OAAO,OAAO,OAAO,OAAO,KAAK,GAAG,IAAI,GAAG,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;cAyB5E;GACV,GAAG,GAAG,GAAG,GAAG,GACX,SAAS,GACT,MAAM,aAAa,GAAG,GAAG,GAAG,GAAG,MAC7B,IAAI,IAAI,OAAO,OAAO,OAAO,GAAG,IAAI,QAAQ,OAAO,OAAO,GAAG,IAAI,IAAI,IAAI;GAC5E,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,IAClB,OAAO,OAAO,OAAO,GAAG,IAAI,KAC5B,SAAS,GACT,MAAM,aAAa,GAAG,GAAG,GAAG,GAAG,KAC9B,OAAO,OAAO,GAAG,IAAI,IAAI,IAAI;;;;;;;;;;;;;;;;;;;;;;cAmErB,gBAAiB,GAAG,GAAG,GAAG,GAAC,SAC7B,GAAC,MACJ,SAAS,GAAG,GAAG,GAAG,OACvB,OAAO;WACC,QAAQ,OAAO,OAAO,GAAG,GAAG;WAC5B,OAAO,gBAAgB,gBAAgB"}

package/dist/{Media-D_CpcM1Z.d.mts → Media-DwgpifPD.d.mts}

@@ -54,4 +54,4 @@ declare const isMediaBase64: <M extends string>(s: MediaSource<M>) => s is Media
 declare const isMediaBytes: <M extends string>(s: MediaSource<M>) => s is MediaBytes<M>;
 //#endregion
 export { Media_d_exports as a, isMediaUrl as c, MediaUrl as i, MediaBytes as n, isMediaBase64 as o, MediaSource as r, isMediaBytes as s, MediaBase64 as t };
-//# sourceMappingURL=Media-D_CpcM1Z.d.mts.map
+//# sourceMappingURL=Media-DwgpifPD.d.mts.map

package/dist/Media-DwgpifPD.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Media-DwgpifPD.d.mts","names":[],"sources":["../src/domain/Media.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiCY,SAAS;WACV;WACA;WACA,WAAW;;KAGV,YAAY;WACb;WACA;WACA,UAAU;;KAGT,WAAW;WACZ;WACA,OAAO;WACP,UAAU;;KAGT,YAAY,6BAA6B,SAAS,KAAK,YAAY,KAAK,WAAW;cAElF,aAAc,kBAAgB,GAAK,YAAY,OAAK,KAAK,SAAS;cAGlE,gBAAiB,kBAAgB,GAAK,YAAY,OAAK,KAAK,YAAY;cAGxE,eAAgB,kBAAgB,GAAK,YAAY,OAAK,KAAK,WAAW"}

package/dist/{SandboxError-CIrVDOMV.d.mts → SandboxError-BN8b28Bh.d.mts}

@@ -1,12 +1,8 @@
 import { Duration } from "effect";
-import * as _$effect_Cause0 from "effect/Cause";
-import * as _$effect_Types0 from "effect/Types";
-
-//#region src/sandbox/SandboxError.d.ts
 declare namespace SandboxError_d_exports {
   export { SandboxAlreadyExists, SandboxAuthFailed, SandboxAuthSubtype, SandboxCreateFailed, SandboxError, SandboxExecFailed, SandboxInvalidRequest, SandboxNetworkPolicyDenied, SandboxNotFound, SandboxQuotaExceeded, SandboxTimeout, SandboxUnsupported };
 }
-declare const SandboxCreateFailed_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const SandboxCreateFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "SandboxCreateFailed";
 } & Readonly<A>;
 /**
@@ -20,7 +16,7 @@ declare class SandboxCreateFailed extends SandboxCreateFailed_base<{
   reason?: string;
   raw: unknown;
 }> {}
-declare const SandboxNotFound_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const SandboxNotFound_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "SandboxNotFound";
 } & Readonly<A>;
 /**
@@ -32,7 +28,7 @@ declare class SandboxNotFound extends SandboxNotFound_base<{
   provider: string;
   id: string;
 }> {}
-declare const SandboxAlreadyExists_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const SandboxAlreadyExists_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "SandboxAlreadyExists";
 } & Readonly<A>;
 /**
@@ -45,7 +41,7 @@ declare class SandboxAlreadyExists extends SandboxAlreadyExists_base<{
   provider: string;
   id: string;
 }> {}
-declare const SandboxExecFailed_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const SandboxExecFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "SandboxExecFailed";
 } & Readonly<A>;
 /**
@@ -59,7 +55,7 @@ declare class SandboxExecFailed extends SandboxExecFailed_base<{
   reason?: string;
   raw: unknown;
 }> {}
-declare const SandboxTimeout_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const SandboxTimeout_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "SandboxTimeout";
 } & Readonly<A>;
 /**
@@ -72,7 +68,7 @@ declare class SandboxTimeout extends SandboxTimeout_base<{
   budget?: Duration.Duration;
   raw?: unknown;
 }> {}
-declare const SandboxNetworkPolicyDenied_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const SandboxNetworkPolicyDenied_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "SandboxNetworkPolicyDenied";
 } & Readonly<A>;
 /**
@@ -89,7 +85,7 @@ declare class SandboxNetworkPolicyDenied extends SandboxNetworkPolicyDenied_base
   reason?: string;
   raw: unknown;
 }> {}
-declare const SandboxQuotaExceeded_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const SandboxQuotaExceeded_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "SandboxQuotaExceeded";
 } & Readonly<A>;
 /**
@@ -102,7 +98,7 @@ declare class SandboxQuotaExceeded extends SandboxQuotaExceeded_base<{
   reason?: string;
   raw: unknown;
 }> {}
-declare const SandboxInvalidRequest_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const SandboxInvalidRequest_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "SandboxInvalidRequest";
 } & Readonly<A>;
 /**
@@ -123,7 +119,7 @@ declare class SandboxInvalidRequest extends SandboxInvalidRequest_base<{
  * mirrors the model-side `AiError.AuthFailed` shape for consistency.
  */
 type SandboxAuthSubtype = "auth" | "permission" | "billing" | "quota";
-declare const SandboxAuthFailed_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const SandboxAuthFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "SandboxAuthFailed";
 } & Readonly<A>;
 declare class SandboxAuthFailed extends SandboxAuthFailed_base<{
@@ -131,7 +127,7 @@ declare class SandboxAuthFailed extends SandboxAuthFailed_base<{
   subtype: SandboxAuthSubtype;
   raw: unknown;
 }> {}
-declare const SandboxUnsupported_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const SandboxUnsupported_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "SandboxUnsupported";
 } & Readonly<A>;
 /**
@@ -155,4 +151,4 @@ declare class SandboxUnsupported extends SandboxUnsupported_base<{
 type SandboxError = SandboxCreateFailed | SandboxNotFound | SandboxAlreadyExists | SandboxExecFailed | SandboxTimeout | SandboxNetworkPolicyDenied | SandboxQuotaExceeded | SandboxInvalidRequest | SandboxAuthFailed | SandboxUnsupported;
 //#endregion
 export { SandboxError as a, SandboxInvalidRequest as c, SandboxQuotaExceeded as d, SandboxTimeout as f, SandboxCreateFailed as i, SandboxNetworkPolicyDenied as l, SandboxAuthFailed as n, SandboxError_d_exports as o, SandboxUnsupported as p, SandboxAuthSubtype as r, SandboxExecFailed as s, SandboxAlreadyExists as t, SandboxNotFound as u };
-//# sourceMappingURL=SandboxError-CIrVDOMV.d.mts.map
+//# sourceMappingURL=SandboxError-BN8b28Bh.d.mts.map

package/dist/SandboxError-BN8b28Bh.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxError-BN8b28Bh.d.mts","names":[],"sources":["../src/sandbox/SandboxError.ts"],"mappings":";;;;;;;;;;;;;cAQa,4BAA4B;EACvC;EACA;EACA;;;;;;;;;;cAQW,wBAAwB;EACnC;EACA;;;;;;;;;;;cASW,6BAA6B;EACxC;EACA;;;;;;;;;;;cASW,0BAA0B;EACrC;EACA;EACA;;;;;;;;;cAOW,uBAAuB;EAClC;EACA;EACA,SAAS,SAAS;EAClB;;;;;;;;;;;;;cAWW,mCAAmC;EAC9C;EACA;EACA;EACA;;;;;;;;;;cAQW,6BAA6B;EACxC;EACA;EACA;;;;;;;;;;;;cAUW,8BAA8B;EACzC;EACA;EACA;EACA;;;;;;KAOU;;;;cAEC,0BAA0B;EACrC;EACA,SAAS;EACT;;;;;;;;;;;;;;;;;;cAgBW,2BAA2B;EACtC;EACA;EACA;;KAGU,eACR,sBACA,kBACA,uBACA,oBACA,iBACA,6BACA,uBACA,wBACA,oBACA"}

package/dist/{StructuredFormat-DHaUJBdd.d.mts → StructuredFormat-BlZhyOsi.d.mts}

@@ -1,9 +1,5 @@
 import { Effect, Result, Schema, Stream } from "effect";
-import * as _$effect_Cause0 from "effect/Cause";
-import * as _$effect_Types0 from "effect/Types";
 import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
-
-//#region src/structured-format/StructuredFormat.d.ts
 declare namespace StructuredFormat_d_exports {
   export { DecodeIssue, JsonParseError, StructuredDecodeError, StructuredFormat, StructuredSchema, decode, decodeJsonLines, decodeJsonLinesRecoverable, fromEffectSchema, parseJson };
 }
@@ -34,7 +30,7 @@ type DecodeIssue = {
   readonly path: ReadonlyArray<string | number>;
   readonly message: string;
 };
-declare const StructuredDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const StructuredDecodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "StructuredDecodeError";
 } & Readonly<A>;
 /**
@@ -45,7 +41,7 @@ declare class StructuredDecodeError extends StructuredDecodeError_base<{
   readonly raw: string;
   readonly issues: ReadonlyArray<DecodeIssue>;
 }> {}
-declare const JsonParseError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+declare const JsonParseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
   readonly _tag: "StructuredJsonParseError";
 } & Readonly<A>;
 /**
@@ -92,4 +88,4 @@ declare const decodeJsonLines: <A>(format: StructuredFormat<A>) => <E, R>(self:
 declare const decodeJsonLinesRecoverable: <A>(format: StructuredFormat<A>) => <E, R>(self: Stream.Stream<string, E, R>) => Stream.Stream<Result.Result<A, JsonParseError | StructuredDecodeError>, E, R>;
 //#endregion
 export { StructuredFormat_d_exports as a, decodeJsonLines as c, parseJson as d, StructuredFormat as i, decodeJsonLinesRecoverable as l, JsonParseError as n, StructuredSchema as o, StructuredDecodeError as r, decode as s, DecodeIssue as t, fromEffectSchema as u };
-//# sourceMappingURL=StructuredFormat-DHaUJBdd.d.mts.map
+//# sourceMappingURL=StructuredFormat-BlZhyOsi.d.mts.map

package/dist/StructuredFormat-BlZhyOsi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StructuredFormat-BlZhyOsi.d.mts","names":[],"sources":["../src/structured-format/StructuredFormat.ts"],"mappings":";;;;;;;;;;;KAaY,iBAAiB,oBAAoB,0BAA0B,UACzE,8BAA8B;;;;;;KAOpB,iBAAiB;WAClB;WACA;WACA,QAAQ,iBAAiB;;;;;WAKzB;;;KAIC;WACD,MAAM;WACN;;;;;;;;;cAWE,8BAA8B;WAChC;WACA,QAAQ,cAAc;;;;;;;;;cAOpB,uBAAuB;WACzB;WACA;;;;;;;cAYE,mBAAoB,UAAU,OAAO,6BAA2B,QACnE,GAAC;WAEE;WACA;WACA;MAEV,iBAAiB;;;;;;cAyCP,SACV,GAAC,QAAU,iBAAiB,QAAE,iBACf,OAAO,OAAO,GAAG;;;;;;cAoBtB,YACV,GAAC,QAAU,iBAAiB,QAAE,gBAChB,OAAO,OAAO,GAAG,iBAAiB;;;;;cAiBtC,kBACV,GAAC,QAAU,iBAAiB,QAC5B,GAAG,GAAC,MACG,OAAO,eAAe,GAAG,OAC9B,OAAO,OAAO,GAAG,IAAI,iBAAiB,uBAAuB;;;;;;;cASrD,6BACV,GAAC,QAAU,iBAAiB,QAC5B,GAAG,GAAC,MACG,OAAO,eAAe,GAAG,OAC9B,OAAO,OAAO,OAAO,OAAO,GAAG,iBAAiB,wBAAwB,GAAG"}