@effect-uai/core 0.2.0 → 0.3.0

package/README.md

@@ -10,7 +10,7 @@ This package exposes:
 
 - **Domain types** - `Items`, `Turn`, `AiError`
 - **Provider contract** - `LanguageModel`
-- **Loop primitive** - `Loop` (`loop`, `value`, `next`, `stop`, `nextAfter`, `nextAfterFold`, `streamUntilComplete`)
+- **Loop primitive** - `Loop` (`loop`, `loopWithState`, `value`, `next`, `stop`, `nextAfter`, `nextAfterFold`, `onTurnComplete`)
 - **Tools** - `Tool`, `Toolkit`, `Outcome`, `ToolEvent`, `Resolvers`, `HistoryCheck`
 - **Streaming codecs** - `SSE`, `JSONL`, `Lines`
 - **Structured output** - `StructuredFormat`

package/dist/{AiError-CqmYjXyx.d.mts → AiError-CBuPHVKA.d.mts}

@@ -107,4 +107,4 @@ declare class IncompleteTurn extends IncompleteTurn_base<{
 type AiError = RateLimited | Unavailable | Timeout | ContentFiltered | ContextLengthExceeded | InvalidRequest | AuthFailed | Cancelled | IncompleteTurn | GenerationFailed;
 //#endregion
 export { Cancelled as a, GenerationFailed as c, RateLimited as d, Scope$1 as f, 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-CqmYjXyx.d.mts.map
+//# sourceMappingURL=AiError-CBuPHVKA.d.mts.map

package/dist/{AiError-CqmYjXyx.d.mts.map → AiError-CBuPHVKA.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"AiError-CqmYjXyx.d.mts","names":[],"sources":["../src/domain/AiError.ts"],"mappings":";;;;;;;;KAEY,OAAA;AAAA,cAAqC,gBAAA;;;cAEpC,WAAA,SAAoB,gBAAA;EAC/B,QAAA;EACA,UAAA,GAAa,QAAA,CAAS,QAAA;EACtB,KAAA,GAAQ,OAAA;EACR,SAAA;EACA,GAAA;AAAA;AAAA,cACG,gBAAA;;;cAEQ,WAAA,SAAoB,gBAAA;EAC/B,QAAA;EACA,UAAA,GAAa,QAAA,CAAS,QAAA;EACtB,MAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,YAAA;;;cAEQ,OAAA,SAAgB,YAAA;EAC3B,QAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,oBAAA;;;cAEQ,eAAA,SAAwB,oBAAA;EACnC,QAAA;EACA,MAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,0BAAA;;;cAEQ,qBAAA,SAA8B,0BAAA;EACzC,QAAA;EACA,UAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,mBAAA;;;cAEQ,cAAA,SAAuB,mBAAA;EAClC,QAAA;EACA,KAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,KAGU,WAAA;AAAA,cAAyD,eAAA;;;cAExD,UAAA,SAAmB,eAAA;EAC9B,QAAA;EACA,OAAA,EAAS,WAAA;EACT,GAAA;AAAA;AAAA,cACG,cAAA;;;cAEQ,SAAA,SAAkB,cAAA;EAC7B,QAAA;AAAA;AAAA,cACG,qBAAA;;;;;;;;;cAQQ,gBAAA,SAAyB,qBAAA;EACpC,QAAA;EACA,IAAA;EACA,OAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,mBAAA;;;;;;;;cAOQ,cAAA,SAAuB,mBAAA;EAClC,GAAA;AAAA;AAAA,KAGU,OAAA,GACR,WAAA,GACA,WAAA,GACA,OAAA,GACA,eAAA,GACA,qBAAA,GACA,cAAA,GACA,UAAA,GACA,SAAA,GACA,cAAA,GACA,gBAAA"}
+{"version":3,"file":"AiError-CBuPHVKA.d.mts","names":[],"sources":["../src/domain/AiError.ts"],"mappings":";;;;;;;;KAEY,OAAA;AAAA,cAAqC,gBAAA;;;cAEpC,WAAA,SAAoB,gBAAA;EAC/B,QAAA;EACA,UAAA,GAAa,QAAA,CAAS,QAAA;EACtB,KAAA,GAAQ,OAAA;EACR,SAAA;EACA,GAAA;AAAA;AAAA,cACG,gBAAA;;;cAEQ,WAAA,SAAoB,gBAAA;EAC/B,QAAA;EACA,UAAA,GAAa,QAAA,CAAS,QAAA;EACtB,MAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,YAAA;;;cAEQ,OAAA,SAAgB,YAAA;EAC3B,QAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,oBAAA;;;cAEQ,eAAA,SAAwB,oBAAA;EACnC,QAAA;EACA,MAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,0BAAA;;;cAEQ,qBAAA,SAA8B,0BAAA;EACzC,QAAA;EACA,UAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,mBAAA;;;cAEQ,cAAA,SAAuB,mBAAA;EAClC,QAAA;EACA,KAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,KAGU,WAAA;AAAA,cAAyD,eAAA;;;cAExD,UAAA,SAAmB,eAAA;EAC9B,QAAA;EACA,OAAA,EAAS,WAAA;EACT,GAAA;AAAA;AAAA,cACG,cAAA;;;cAEQ,SAAA,SAAkB,cAAA;EAC7B,QAAA;AAAA;AAAA,cACG,qBAAA;;;;;;;;;cAQQ,gBAAA,SAAyB,qBAAA;EACpC,QAAA;EACA,IAAA;EACA,OAAA;EACA,SAAA;EACA,GAAA;AAAA;AAAA,cACG,mBAAA;;;;;;;;cAOQ,cAAA,SAAuB,mBAAA;EAClC,GAAA;AAAA;AAAA,KAGU,OAAA,GACR,WAAA,GACA,WAAA,GACA,OAAA,GACA,eAAA,GACA,qBAAA,GACA,cAAA,GACA,UAAA,GACA,SAAA,GACA,cAAA,GACA,gBAAA"}

package/dist/Image-BZmKfIdq.d.mts

@@ -0,0 +1,61 @@
+import { i as MediaUrl, n as MediaBytes, r as MediaSource, t as MediaBase64 } from "./Media-D_CpcM1Z.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 };
+}
+/**
+ * Image MIME types AI providers typically accept. The first four are the
+ * universal subset (Cohere v4, Voyage multimodal, Jina v4, Google
+ * `gemini-embedding-2`); HEIC / HEIF are Google-specific. The
+ * `(string & {})` tail keeps autocomplete on the literals while still
+ * accepting any string, so a newly-supported format works without an
+ * SDK update.
+ */
+type ImageMimeType = "image/png" | "image/jpeg" | "image/webp" | "image/gif" | "image/heic" | "image/heif" | (string & {});
+type ImageUrlSource = MediaUrl<ImageMimeType>;
+type ImageBase64Source = MediaBase64<ImageMimeType>;
+type ImageBytesSource = MediaBytes<ImageMimeType>;
+/**
+ * Where an image lives. Provider layers normalize across these:
+ * `bytes` becomes a base64 data URI for OpenAI / Anthropic, an
+ * `inlineData` part for Gemini, and a separate field for Cohere /
+ * Voyage. URL constraints (must be HTTPS, must be public, …) are
+ * provider-specific and validated at the layer, not in the type.
+ */
+type ImageSource = MediaSource<ImageMimeType>;
+declare const ImageUrlSource: Schema.TaggedStruct<"url", {
+  readonly url: Schema.String;
+  readonly mimeType: Schema.optional<Schema.Schema<ImageMimeType>>;
+}>;
+declare const ImageBase64Source: Schema.TaggedStruct<"base64", {
+  readonly base64: Schema.String;
+  readonly mimeType: Schema.Schema<ImageMimeType>;
+}>;
+declare const ImageBytesSource: Schema.TaggedStruct<"bytes", {
+  readonly bytes: Schema.Uint8Array;
+  readonly mimeType: Schema.Schema<ImageMimeType>;
+}>;
+declare const ImageSource: Schema.Schema<ImageSource>;
+declare const imageUrl: (url: string, mimeType?: ImageMimeType) => ImageUrlSource;
+declare const imageBase64: (base64: string, mimeType: ImageMimeType) => ImageBase64Source;
+declare const imageBytes: (bytes: Uint8Array, mimeType: ImageMimeType) => ImageBytesSource;
+declare const isImageUrl: <I>(input: I) => input is I & {
+  readonly _tag: "url";
+  readonly url: string;
+  readonly mimeType?: ImageMimeType | undefined;
+};
+declare const isImageBase64: <I>(input: I) => input is I & {
+  readonly _tag: "base64";
+  readonly mimeType: ImageMimeType;
+  readonly base64: string;
+};
+declare const isImageBytes: <I>(input: I) => input is I & {
+  readonly _tag: "bytes";
+  readonly mimeType: ImageMimeType;
+  readonly bytes: Uint8Array<ArrayBufferLike>;
+};
+//#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-BZmKfIdq.d.mts.map

package/dist/Image-BZmKfIdq.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Image-BZmKfIdq.d.mts","names":[],"sources":["../src/domain/Image.ts"],"mappings":";;;;;;;;;;;;;;;KAWY,aAAA;AAAA,KAYA,cAAA,GAAiB,QAAA,CAAS,aAAA;AAAA,KAC1B,iBAAA,GAAoB,WAAA,CAAY,aAAA;AAAA,KAChC,gBAAA,GAAmB,UAAA,CAAW,aAAA;;;;;AAd1C;;;KAuBY,WAAA,GAAc,WAAA,CAAY,aAAA;AAAA,cAEzB,cAAA,EAAc,MAAA,CAAA,YAAA;EAAA;;;cAKd,iBAAA,EAAiB,MAAA,CAAA,YAAA;EAAA;;;cAKjB,gBAAA,EAAgB,MAAA,CAAA,YAAA;EAAA;;;cAKhB,WAAA,EAAa,MAAA,CAAO,MAAA,CAAO,WAAA;AAAA,cAM3B,QAAA,GAAY,GAAA,UAAa,QAAA,GAAW,aAAA,KAAgB,cAAA;AAAA,cAGpD,WAAA,GAAe,MAAA,UAAgB,QAAA,EAAU,aAAA,KAAgB,iBAAA;AAAA,cAMzD,UAAA,GAAc,KAAA,EAAO,UAAA,EAAY,QAAA,EAAU,aAAA,KAAgB,gBAAA;AAAA,cAM3D,UAAA,MAAU,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;cACV,aAAA,MAAa,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA;;;;cACb,YAAA,MAAY,KAAA,EAAA,CAAA,KAAA,KAAA,IAAA,CAAA;EAAA"}

package/dist/{Items-D1C2686t.d.mts → Items-CB8Bo3FI.d.mts}

@@ -1,61 +1,26 @@
+import { i as ImageSource } from "./Image-BZmKfIdq.mjs";
 import { Schema } from "effect";
 
 //#region src/domain/Items.d.ts
 declare namespace Items_d_exports {
-  export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, FunctionCall, FunctionCallOutput, ImageBase64Source, ImageSource, ImageUrlSource, InputImage, InputText, InputTokensDetails, Item, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, UrlCitation, Usage, assistantText, functionCallOutput, isContainerFileCitation, isFileCitation, isFilePath, isFunctionCall, isFunctionCallOutput, isImageBase64Source, isImageUrlSource, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isUrlCitation, systemText, userText };
+  export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, FunctionCall, FunctionCallOutput, InputImage, InputText, InputTokensDetails, Item, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, UrlCitation, Usage, assistantText, functionCallOutput, isContainerFileCitation, isFileCitation, isFilePath, isFunctionCall, isFunctionCallOutput, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isUrlCitation, systemText, userText };
 }
 declare const InputText: Schema.Struct<{
   readonly type: Schema.Literal<"input_text">;
   readonly text: Schema.String;
 }>;
 type InputText = typeof InputText.Type;
-/**
- * Where an image lives. `url` covers HTTP(S) URLs (the model fetches
- * them); `base64` covers inline bytes embedded in the request. Provider
- * encoders dispatch on `_tag`. File-id / uploaded-asset references are
- * provider-specific and stay out of this union for now.
- */
-declare const ImageUrlSource: Schema.Struct<{
-  readonly _tag: Schema.Literal<"url">;
-  readonly url: Schema.String;
-}>;
-type ImageUrlSource = typeof ImageUrlSource.Type;
-/**
- * Inline image bytes. `data` is **already base64-encoded** (matches what
- * the wire formats expect; no double-encoding needed downstream).
- * `media_type` is the MIME type, e.g. `"image/png"`.
- */
-declare const ImageBase64Source: Schema.Struct<{
-  readonly _tag: Schema.Literal<"base64">;
-  readonly media_type: Schema.String;
-  readonly data: Schema.String;
-}>;
-type ImageBase64Source = typeof ImageBase64Source.Type;
-declare const ImageSource: Schema.Union<readonly [Schema.Struct<{
-  readonly _tag: Schema.Literal<"url">;
-  readonly url: Schema.String;
-}>, Schema.Struct<{
-  readonly _tag: Schema.Literal<"base64">;
-  readonly media_type: Schema.String;
-  readonly data: Schema.String;
-}>]>;
-type ImageSource = typeof ImageSource.Type;
-declare const isImageUrlSource: (s: ImageSource) => s is ImageUrlSource;
-declare const isImageBase64Source: (s: ImageSource) => s is ImageBase64Source;
 /**
  * User-provided image content block. Pair with `InputText` inside a
  * `Message.content` array to ask "what's in this image?" style questions.
+ *
+ * `source` is the cross-modality `ImageSource` from `domain/Image.ts` -
+ * url, base64, or raw bytes. Provider codecs encode bytes to whatever
+ * wire format the provider wants.
  */
 declare const InputImage: Schema.Struct<{
   readonly type: Schema.Literal<"input_image">;
-  readonly source: Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.Literal<"url">;
-    readonly url: Schema.String;
-  }>, Schema.Struct<{
-    readonly _tag: Schema.Literal<"base64">;
-    readonly media_type: Schema.String;
-    readonly data: Schema.String;
-  }>]>;
+  readonly source: Schema.Schema<ImageSource>;
 }>;
 type InputImage = typeof InputImage.Type;
 declare const UrlCitation: Schema.Struct<{
@@ -108,10 +73,30 @@ declare const Annotation: Schema.Union<readonly [Schema.Struct<{
   readonly index: Schema.Number;
 }>]>;
 type Annotation = typeof Annotation.Type;
-declare const isUrlCitation: (a: Annotation) => a is UrlCitation;
-declare const isFileCitation: (a: Annotation) => a is FileCitation;
-declare const isContainerFileCitation: (a: Annotation) => a is ContainerFileCitation;
-declare const isFilePath: (a: Annotation) => a is FilePath;
+declare const isUrlCitation: <I>(input: I) => input is I & {
+  readonly type: "url_citation";
+  readonly url: string;
+  readonly start_index: number;
+  readonly end_index: number;
+  readonly title: string;
+};
+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 start_index: number;
+  readonly end_index: number;
+  readonly file_id: string;
+  readonly container_id: string;
+};
+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;
@@ -154,14 +139,7 @@ declare const ContentBlock: Schema.Union<readonly [Schema.Struct<{
   readonly text: Schema.String;
 }>, Schema.Struct<{
   readonly type: Schema.Literal<"input_image">;
-  readonly source: Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.Literal<"url">;
-    readonly url: Schema.String;
-  }>, Schema.Struct<{
-    readonly _tag: Schema.Literal<"base64">;
-    readonly media_type: Schema.String;
-    readonly data: Schema.String;
-  }>]>;
+  readonly source: Schema.Schema<ImageSource>;
 }>, Schema.Struct<{
   readonly type: Schema.Literal<"output_text">;
   readonly text: Schema.String;
@@ -201,14 +179,7 @@ declare const Message: Schema.Struct<{
     readonly text: Schema.String;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"input_image">;
-    readonly source: Schema.Union<readonly [Schema.Struct<{
-      readonly _tag: Schema.Literal<"url">;
-      readonly url: Schema.String;
-    }>, Schema.Struct<{
-      readonly _tag: Schema.Literal<"base64">;
-      readonly media_type: Schema.String;
-      readonly data: Schema.String;
-    }>]>;
+    readonly source: Schema.Schema<ImageSource>;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"output_text">;
     readonly text: Schema.String;
@@ -277,14 +248,7 @@ declare const Item: Schema.Union<readonly [Schema.Struct<{
     readonly text: Schema.String;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"input_image">;
-    readonly source: Schema.Union<readonly [Schema.Struct<{
-      readonly _tag: Schema.Literal<"url">;
-      readonly url: Schema.String;
-    }>, Schema.Struct<{
-      readonly _tag: Schema.Literal<"base64">;
-      readonly media_type: Schema.String;
-      readonly data: Schema.String;
-    }>]>;
+    readonly source: Schema.Schema<ImageSource>;
   }>, Schema.Struct<{
     readonly type: Schema.Literal<"output_text">;
     readonly text: Schema.String;
@@ -333,14 +297,102 @@ declare const Item: Schema.Union<readonly [Schema.Struct<{
   readonly providerData: Schema.optional<Schema.Unknown>;
 }>]>;
 type Item = typeof Item.Type;
-declare const isInputText: (block: ContentBlock) => block is InputText;
-declare const isInputImage: (block: ContentBlock) => block is InputImage;
-declare const isOutputText: (block: ContentBlock) => block is OutputText;
-declare const isRefusal: (block: ContentBlock) => block is Refusal;
-declare const isMessage: (item: Item) => item is Message;
-declare const isFunctionCall: (item: Item) => item is FunctionCall;
-declare const isFunctionCallOutput: (item: Item) => item is FunctionCallOutput;
-declare const isReasoning: (item: Item) => item is Reasoning;
+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;
+  readonly annotations?: readonly ({
+    readonly type: "url_citation";
+    readonly url: string;
+    readonly start_index: number;
+    readonly end_index: number;
+    readonly title: string;
+  } | {
+    readonly type: "file_citation";
+    readonly file_id: string;
+    readonly index: number;
+  } | {
+    readonly type: "container_file_citation";
+    readonly start_index: number;
+    readonly end_index: number;
+    readonly file_id: string;
+    readonly container_id: string;
+  } | {
+    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 isMessage: <I>(input: I) => input is I & {
+  readonly type: "message";
+  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 ({
+      readonly type: "url_citation";
+      readonly url: string;
+      readonly start_index: number;
+      readonly end_index: number;
+      readonly title: string;
+    } | {
+      readonly type: "file_citation";
+      readonly file_id: string;
+      readonly index: number;
+    } | {
+      readonly type: "container_file_citation";
+      readonly start_index: number;
+      readonly end_index: number;
+      readonly file_id: string;
+      readonly container_id: string;
+    } | {
+      readonly type: "file_path";
+      readonly file_id: string;
+      readonly index: number;
+    })[] | undefined;
+  } | {
+    readonly type: "refusal";
+    readonly text: string;
+  })[];
+  readonly role: "user" | "assistant" | "system";
+  readonly providerData?: unknown;
+};
+declare const isFunctionCall: <I>(input: I) => input is I & {
+  readonly type: "function_call";
+  readonly call_id: string;
+  readonly name: string;
+  readonly arguments: string;
+  readonly providerData?: unknown;
+};
+declare const isFunctionCallOutput: <I>(input: I) => input is I & {
+  readonly type: "function_call_output";
+  readonly call_id: string;
+  readonly output: string;
+  readonly providerData?: unknown;
+};
+declare const isReasoning: <I>(input: I) => input is I & {
+  readonly type: "reasoning";
+  readonly providerData?: unknown;
+  readonly id?: string | undefined;
+  readonly summary?: string | undefined;
+  readonly signature?: string | undefined;
+};
 declare const InputTokensDetails: Schema.Struct<{
   readonly cached_tokens: Schema.optional<Schema.Number>;
 }>;
@@ -368,5 +420,5 @@ declare const systemText: (text: string) => Message;
 declare const assistantText: (text: string) => Message;
 declare const functionCallOutput: (call_id: string, output: string) => FunctionCallOutput;
 //#endregion
-export { isFunctionCall as A, isUrlCitation as B, UrlCitation as C, isContainerFileCitation as D, functionCallOutput as E, isInputText as F, userText as H, isMessage as I, isOutputText as L, isImageBase64Source as M, isImageUrlSource as N, isFileCitation as O, isInputImage as P, isReasoning as R, StopReason as S, assistantText as T, systemText as V, OutputText as _, FilePath as a, Refusal as b, ImageBase64Source as c, InputImage as d, InputText as f, Message as g, Items_d_exports as h, FileCitation as i, isFunctionCallOutput as j, isFilePath as k, ImageSource as l, Item as m, ContainerFileCitation as n, FunctionCall as o, InputTokensDetails as p, ContentBlock as r, FunctionCallOutput as s, Annotation as t, ImageUrlSource as u, OutputTokensDetails as v, Usage as w, Role as x, Reasoning as y, isRefusal as z };
-//# sourceMappingURL=Items-D1C2686t.d.mts.map
+export { isInputText as A, functionCallOutput as C, isFunctionCall as D, isFilePath as E, isUrlCitation as F, systemText as I, userText as L, isOutputText as M, isReasoning as N, isFunctionCallOutput as O, isRefusal as P, assistantText as S, isFileCitation as T, Refusal as _, FilePath as a, UrlCitation as b, InputImage as c, Item as d, Items_d_exports as f, Reasoning as g, OutputTokensDetails as h, FileCitation as i, isMessage as j, isInputImage as k, InputText as l, OutputText as m, ContainerFileCitation as n, FunctionCall as o, Message as p, ContentBlock as r, FunctionCallOutput as s, Annotation as t, InputTokensDetails as u, Role as v, isContainerFileCitation as w, Usage as x, StopReason as y };
+//# sourceMappingURL=Items-CB8Bo3FI.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Items-CB8Bo3FI.d.mts","names":[],"sources":["../src/domain/Items.ts"],"mappings":"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"}

package/dist/Media-D_CpcM1Z.d.mts

@@ -0,0 +1,57 @@
+declare namespace Media_d_exports {
+  export { MediaBase64, MediaBytes, MediaSource, MediaUrl, isMediaBase64, isMediaBytes, isMediaUrl };
+}
+/**
+ * Cross-modality media reference shape.
+ *
+ * Every "media at rest" reference - image, audio, video, document - is one
+ * of three variants:
+ *
+ *   - `url`    : a remote address (HTTP, GCS, etc.). The model fetches it.
+ *               `mimeType` is optional - servers usually set Content-Type.
+ *               Some providers (Gemini `fileData`) want it explicit.
+ *
+ *   - `base64` : an inline base64-encoded payload. Always carries a
+ *               `mimeType` so the consumer knows how to decode.
+ *
+ *   - `bytes`  : raw `Uint8Array`. Provider layers normalize to base64 or
+ *               multipart upload at the wire boundary - users don't need
+ *               to encode themselves.
+ *
+ * Per-modality files (`Image.ts`, future `Audio.ts` / `Video.ts` /
+ * `Document.ts`) instantiate this shape with their typed MIME union to
+ * get autocomplete on common formats while keeping the structural type
+ * uniform across modalities.
+ *
+ * Streaming media (live mic feed, streaming TTS playback) is *not*
+ * modeled here. Streams carry effect parameters (`Stream<A, E, R>`) and
+ * lifecycle (Scope, cancellation) that don't apply to media at rest. The
+ * complementary type lives alongside this one as `*Stream` in each
+ * per-modality file when those modalities land.
+ *
+ * Provider-uploaded asset references (OpenAI Files `file_id`, Gemini
+ * Files API URIs, Anthropic file IDs) are also out of scope here -
+ * they're a separate union (`FileRef`) added when needed.
+ */
+type MediaUrl<M extends string = string> = {
+  readonly _tag: "url";
+  readonly url: string;
+  readonly mimeType?: M;
+};
+type MediaBase64<M extends string = string> = {
+  readonly _tag: "base64";
+  readonly base64: string;
+  readonly mimeType: M;
+};
+type MediaBytes<M extends string = string> = {
+  readonly _tag: "bytes";
+  readonly bytes: Uint8Array;
+  readonly mimeType: M;
+};
+type MediaSource<M extends string = string> = MediaUrl<M> | MediaBase64<M> | MediaBytes<M>;
+declare const isMediaUrl: <M extends string>(s: MediaSource<M>) => s is MediaUrl<M>;
+declare const isMediaBase64: <M extends string>(s: MediaSource<M>) => s is MediaBase64<M>;
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Media-D_CpcM1Z.d.mts","names":[],"sources":["../src/domain/Media.ts"],"mappings":";;;;;;;;;;;;;;;AAiCA;;;;;;;;;;;AAMA;;;;;;;;;KANY,QAAA;EAAA,SACD,IAAA;EAAA,SACA,GAAA;EAAA,SACA,QAAA,GAAW,CAAA;AAAA;AAAA,KAGV,WAAA;EAAA,SACD,IAAA;EAAA,SACA,MAAA;EAAA,SACA,QAAA,EAAU,CAAA;AAAA;AAAA,KAGT,UAAA;EAAA,SACD,IAAA;EAAA,SACA,KAAA,EAAO,UAAA;EAAA,SACP,QAAA,EAAU,CAAA;AAAA;AAAA,KAGT,WAAA,8BAAyC,QAAA,CAAS,CAAA,IAAK,WAAA,CAAY,CAAA,IAAK,UAAA,CAAW,CAAA;AAAA,cAElF,UAAA,qBAAgC,CAAA,EAAG,WAAA,CAAY,CAAA,MAAK,CAAA,IAAK,QAAA,CAAS,CAAA;AAAA,cAGlE,aAAA,qBAAmC,CAAA,EAAG,WAAA,CAAY,CAAA,MAAK,CAAA,IAAK,WAAA,CAAY,CAAA;AAAA,cAGxE,YAAA,qBAAkC,CAAA,EAAG,WAAA,CAAY,CAAA,MAAK,CAAA,IAAK,UAAA,CAAW,CAAA"}

package/dist/{StructuredFormat-B5ueioNr.d.mts → StructuredFormat-BWq5Hd1O.d.mts}

@@ -19,7 +19,7 @@ type StructuredSchema<Output = unknown> = StandardSchemaV1<unknown, Output> & St
  * cross-validator schema with metadata providers need (name, description,
  * strict-mode flag).
  */
-interface StructuredFormat<A> {
+type StructuredFormat<A> = {
   readonly name: string;
   readonly description?: string;
   readonly schema: StructuredSchema<A>;
@@ -28,12 +28,12 @@ interface StructuredFormat<A> {
    * (constrained decoding); other providers ignore.
    */
   readonly strict?: boolean;
-}
+};
 /** A single path-scoped validation problem. Library-agnostic shape. */
-interface DecodeIssue {
+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 & {
   readonly _tag: "StructuredDecodeError";
 } & Readonly<A>;
@@ -85,4 +85,4 @@ declare const parseJson: <A>(format: StructuredFormat<A>) => (raw: string) => Ef
 declare const decodeJsonLines: <A>(format: StructuredFormat<A>) => <E, R>(self: Stream.Stream<string, E, R>) => Stream.Stream<A, E | JsonParseError | StructuredDecodeError, R>;
 //#endregion
 export { StructuredFormat_d_exports as a, decodeJsonLines as c, StructuredFormat as i, fromEffectSchema as l, JsonParseError as n, StructuredSchema as o, StructuredDecodeError as r, decode as s, DecodeIssue as t, parseJson as u };
-//# sourceMappingURL=StructuredFormat-B5ueioNr.d.mts.map
+//# sourceMappingURL=StructuredFormat-BWq5Hd1O.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StructuredFormat-BWq5Hd1O.d.mts","names":[],"sources":["../src/structured-format/StructuredFormat.ts"],"mappings":";;;;;;;;;;;;;;;KAaY,gBAAA,qBAAqC,gBAAA,UAA0B,MAAA,IACzE,oBAAA,UAA8B,MAAA;;;;;;KAOpB,gBAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA;EAAA,SACA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;EAXxB;;;;EAAA,SAgBD,MAAA;AAAA;;KAIC,WAAA;EAAA,SACD,IAAA,EAAM,aAAA;EAAA,SACN,OAAA;AAAA;AAAA,cACV,0BAAA;;;;;AAfD;;cAyBa,qBAAA,SAA8B,0BAAA;EAAA,SAChC,GAAA;EAAA,SACA,MAAA,EAAQ,aAAA,CAAc,WAAA;AAAA;AAAA,cAC5B,mBAAA;;;;;;AAhBL;cAsBa,cAAA,SAAuB,mBAAA;EAAA,SACzB,GAAA;EAAA,SACA,KAAA;AAAA;;;;AArBV;;cAiCY,gBAAA,aAA8B,MAAA,CAAO,KAAA,wBAChD,MAAA,EAAQ,CAAA,EACR,OAAA;EAAA,SACW,IAAA;EAAA,SACA,WAAA;EAAA,SACA,MAAA;AAAA,MAEV,gBAAA,CAAiB,CAAA;;;;;;cAyCP,MAAA,MACP,MAAA,EAAQ,gBAAA,CAAiB,CAAA,OAC5B,GAAA,cAAe,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,qBAAA;;;;;;cAoBtB,SAAA,MACP,MAAA,EAAQ,gBAAA,CAAiB,CAAA,OAC5B,GAAA,aAAc,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,cAAA,GAAiB,qBAAA;;;;;cAatC,eAAA,MACP,MAAA,EAAQ,gBAAA,CAAiB,CAAA,aAE3B,IAAA,EAAM,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA,MAC9B,MAAA,CAAO,MAAA,CAAO,CAAA,EAAG,CAAA,GAAI,cAAA,GAAiB,qBAAA,EAAuB,CAAA"}

package/dist/{Tool-5wxOCuOh.d.mts → Tool-DjVufH7i.d.mts}

@@ -1,4 +1,4 @@
-import { o as FunctionCall, s as FunctionCallOutput } from "./Items-D1C2686t.mjs";
+import { o as FunctionCall, s as FunctionCallOutput } from "./Items-CB8Bo3FI.mjs";
 import { Effect, Schema, Stream } from "effect";
 import * as _$effect_Cause0 from "effect/Cause";
 import { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
@@ -30,7 +30,7 @@ type ToolInputSchema<Input = unknown> = StandardSchemaV1<unknown, Input> & Stand
  * can be used as a `Tool.inputSchema`.
  */
 declare const fromEffectSchema: <S extends Schema.Codec<any, any, never, any>>(schema: S) => S & ToolInputSchema<S["Type"]>;
-interface Tool<Name extends string, Input, Output, R = never> {
+type Tool<Name extends string, Input, Output, R = never> = {
   readonly name: Name;
   readonly description: string;
   readonly inputSchema: ToolInputSchema<Input>;
@@ -42,20 +42,20 @@ interface Tool<Name extends string, Input, Output, R = never> {
    * compatible, the provider returns an error.
    */
   readonly strict?: boolean;
-}
+};
 /**
  * Provider-agnostic tool descriptor. Each provider maps `inputSchema`
  * to its own wire field (OpenAI → `parameters`, Anthropic →
  * `input_schema`). Built from a `Tool` by `Toolkit.toDescriptors`.
  */
-interface ToolDescriptor {
+type ToolDescriptor = {
   readonly name: string;
   readonly description: string;
   readonly inputSchema: Record<string, unknown>;
   readonly strict?: boolean;
-}
+};
 declare const make: <Name extends string, Input, Output, R = never>(spec: Tool<Name, Input, Output, R>) => Tool<Name, Input, Output, R>;
-interface StreamingTool<Name extends string, Input, Event, Output, R = never> {
+type StreamingTool<Name extends string, Input, Event, Output, R = never> = {
   readonly _kind: "streaming";
   readonly name: Name;
   readonly description: string;
@@ -63,18 +63,18 @@ interface StreamingTool<Name extends string, Input, Event, Output, R = never> {
   readonly run: (input: Input) => Stream.Stream<Event, unknown, R>;
   readonly finalize: (events: ReadonlyArray<Event>) => Output;
   readonly strict?: boolean;
-}
+};
 declare const streaming: <Name extends string, Input, Event, Output, R = never>(spec: Omit<StreamingTool<Name, Input, Event, Output, R>, "_kind">) => StreamingTool<Name, Input, Event, Output, R>;
-type AnyStreamingTool = StreamingTool<string, any, any, any, never>;
-type AnyPlainTool = Tool<string, any, any, never>;
-type AnyKindTool = AnyStreamingTool | AnyPlainTool;
-declare const isStreamingTool: (t: AnyKindTool) => t is AnyStreamingTool;
+type AnyStreamingTool<R = any> = StreamingTool<string, any, any, any, R>;
+type AnyPlainTool<R = any> = Tool<string, any, any, R>;
+type AnyKindTool<R = any> = AnyStreamingTool<R> | AnyPlainTool<R>;
+declare const isStreamingTool: <R>(t: AnyKindTool<R>) => t is AnyStreamingTool<R>;
 /**
  * Render any-kind tools (mixed plain and streaming) to provider-agnostic
  * descriptors. Mirrors `Toolkit.toDescriptors` but accepts the union type
  * so a single list can carry both kinds.
  */
-declare const toDescriptors: (tools: ReadonlyArray<AnyKindTool>) => ReadonlyArray<ToolDescriptor>;
+declare const toDescriptors: <R>(tools: ReadonlyArray<AnyKindTool<R>>) => ReadonlyArray<ToolDescriptor>;
 /**
  * Decode and validate the JSON arguments of a function_call against the
  * tool's input schema, run the tool, and serialize the output into a
@@ -83,4 +83,4 @@ declare const toDescriptors: (tools: ReadonlyArray<AnyKindTool>) => ReadonlyArra
 declare const execute: <Name extends string, Input, Output, R>(tool: Tool<Name, Input, Output, R>, call: FunctionCall) => Effect.Effect<FunctionCallOutput, ToolError, R>;
 //#endregion
 export { Tool as a, ToolInputSchema as c, fromEffectSchema as d, isStreamingTool as f, toDescriptors as h, StreamingTool as i, Tool_d_exports as l, streaming as m, AnyPlainTool as n, ToolDescriptor as o, make as p, AnyStreamingTool as r, ToolError as s, AnyKindTool as t, execute as u };
-//# sourceMappingURL=Tool-5wxOCuOh.d.mts.map
+//# sourceMappingURL=Tool-DjVufH7i.d.mts.map

package/dist/Tool-DjVufH7i.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tool-DjVufH7i.d.mts","names":[],"sources":["../src/tool/Tool.ts"],"mappings":";;;;;;;;;cAE0E,cAAA;;;;;;cAG7D,SAAA,SAAkB,cAAA;;;;;;;;;;KAmBnB,eAAA,oBAAmC,gBAAA,UAA0B,KAAA,IACvE,oBAAA,UAA8B,KAAA;;;AAvB0C;;;cA8B7D,gBAAA,aAA8B,MAAA,CAAO,KAAA,wBAChD,MAAA,EAAQ,CAAA,KACP,CAAA,GAAI,eAAA,CAAgB,CAAA;AAAA,KAIX,IAAA;EAAA,SACD,IAAA,EAAM,IAAA;EAAA,SACN,WAAA;EAAA,SACA,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,GAAA,GAAM,KAAA,EAAO,KAAA,KAAU,MAAA,CAAO,MAAA,CAAO,MAAA,WAAiB,CAAA;;;;;;;WAOtD,MAAA;AAAA;;;;;;KAQC,cAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA,EAAa,MAAA;EAAA,SACb,MAAA;AAAA;AAAA,cAGE,IAAA,kDACX,IAAA,EAAM,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA,MAC/B,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA;AAAA,KAWjB,aAAA;EAAA,SACD,KAAA;EAAA,SACA,IAAA,EAAM,IAAA;EAAA,SACN,WAAA;EAAA,SACA,WAAA,EAAa,eAAA,CAAgB,KAAA;EAAA,SAC7B,GAAA,GAAM,KAAA,EAAO,KAAA,KAAU,MAAA,CAAO,MAAA,CAAO,KAAA,WAAgB,CAAA;EAAA,SACrD,QAAA,GAAW,MAAA,EAAQ,aAAA,CAAc,KAAA,MAAW,MAAA;EAAA,SAC5C,MAAA;AAAA;AAAA,cAGE,SAAA,yDACX,IAAA,EAAM,IAAA,CAAK,aAAA,CAAc,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,CAAA,gBACpD,aAAA,CAAc,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,CAAA;AAAA,KAEjC,gBAAA,YAA4B,aAAA,wBAAqC,CAAA;AAAA,KACjE,YAAA,YAAwB,IAAA,mBAAuB,CAAA;AAAA,KAC/C,WAAA,YAAuB,gBAAA,CAAiB,CAAA,IAAK,YAAA,CAAa,CAAA;AAAA,cAEzD,eAAA,MAAsB,CAAA,EAAG,WAAA,CAAY,CAAA,MAAK,CAAA,IAAK,gBAAA,CAAiB,CAAA;;;;;;cAQhE,aAAA,MACX,KAAA,EAAO,aAAA,CAAc,WAAA,CAAY,CAAA,OAChC,aAAA,CAAc,cAAA;;;;;;cAkBJ,OAAA,0CACX,IAAA,EAAM,IAAA,CAAK,IAAA,EAAM,KAAA,EAAO,MAAA,EAAQ,CAAA,GAChC,IAAA,EAAM,YAAA,KACL,MAAA,CAAO,MAAA,CAAO,kBAAA,EAAoB,SAAA,EAAW,CAAA"}

package/dist/{Turn-Bi83du4I.d.mts → Turn-OPaILVIB.d.mts}

@@ -1,5 +1,6 @@
-import { g as Message, m as Item, o as FunctionCall, s as FunctionCallOutput, w as Usage, y as Reasoning } from "./Items-D1C2686t.mjs";
-import { i as StructuredFormat, n as JsonParseError, r as StructuredDecodeError } from "./StructuredFormat-B5ueioNr.mjs";
+import { i as ImageSource } from "./Image-BZmKfIdq.mjs";
+import { d as Item, g as Reasoning, o as FunctionCall, p as Message, s as FunctionCallOutput, x as Usage } from "./Items-CB8Bo3FI.mjs";
+import { i as StructuredFormat, n as JsonParseError, r as StructuredDecodeError } from "./StructuredFormat-BWq5Hd1O.mjs";
 import { Effect, Schema, Stream } from "effect";
 import * as _$effect_Types0 from "effect/Types";
 import * as _$effect_Cause0 from "effect/Cause";
@@ -22,14 +23,7 @@ declare const Turn: Schema.Struct<{
       readonly text: Schema.String;
     }>, Schema.Struct<{
       readonly type: Schema.Literal<"input_image">;
-      readonly source: Schema.Union<readonly [Schema.Struct<{
-        readonly _tag: Schema.Literal<"url">;
-        readonly url: Schema.String;
-      }>, Schema.Struct<{
-        readonly _tag: Schema.Literal<"base64">;
-        readonly media_type: Schema.String;
-        readonly data: Schema.String;
-      }>]>;
+      readonly source: Schema.Schema<ImageSource>;
     }>, Schema.Struct<{
       readonly type: Schema.Literal<"output_text">;
       readonly text: Schema.String;
@@ -197,4 +191,4 @@ declare class RefusalRejected extends RefusalRejected_base<{
 declare const toStructured: <A>(turn: Turn, format: StructuredFormat<A>) => Effect.Effect<A, RefusalRejected | JsonParseError | StructuredDecodeError>;
 //#endregion
 export { Turn_d_exports as a, functionCalls as c, textDeltas as d, toStructured as f, TurnEvent as i, isTurnComplete as l, RefusalRejected as n, appendTurn as o, Turn as r, assistantMessages as s, InteractionEvent as t, reasonings as u };
-//# sourceMappingURL=Turn-Bi83du4I.d.mts.map
+//# sourceMappingURL=Turn-OPaILVIB.d.mts.map

package/dist/Turn-OPaILVIB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Turn-OPaILVIB.d.mts","names":[],"sources":["../src/domain/Turn.ts"],"mappings":";;;;;;;;;;;;;;;;cAmBa,IAAA,EAAI,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKL,IAAA,UAAc,IAAA,CAAK,IAAA;;;;;;;KAQnB,SAAA;EAAA,SACG,IAAA;EAAA,SAA6B,IAAA;AAAA;EAAA,SAE7B,IAAA;EAAA,SACA,IAAA;;;;;;;;WAQA,IAAA;AAAA;;;;;;;;;WASA,IAAA;EAAA,SAAgC,IAAA;AAAA;EAAA,SAChC,IAAA;EAAA,SAAkC,OAAA;EAAA,SAA0B,IAAA;AAAA;EAAA,SAC5D,IAAA;EAAA,SAAuC,OAAA;EAAA,SAA0B,KAAA;AAAA;;;;;;;;;;WASjE,IAAA;EAAA,SAA+B,KAAA,EAAO,KAAA;AAAA;EAAA,SACtC,IAAA;EAAA,SAAgC,IAAA,EAAM,IAAA;AAAA;;;;;;;KAQzC,gBAAA,GAAmB,SAAA,GAAY,kBAAA;AAAA,cAE9B,cAAA,GAAkB,CAAA,EAAG,SAAA,KAAY,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;AAAA,cAG3D,aAAA,GAAiB,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,YAAA;AAAA,cAG5C,UAAA,GAAc,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,SAAA;AAAA,cAGzC,iBAAA,GAAqB,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,OAAA;;;;;;cAQhD,UAAA;EAAA,SAAmC,OAAA,EAAS,aAAA,CAAc,IAAA;AAAA,GACrE,KAAA,EAAO,CAAA,EACP,IAAA,EAAM,IAAA,EACN,KAAA,GAAO,aAAA,CAAc,IAAA,MACpB,CAAA;;;;;;cAcU,UAAA,SACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACjC,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA;AAAA,cAKzB,oBAAA;;;;;;;;cAWU,eAAA,SAAwB,oBAAA;EAAA,SAC1B,IAAA,EAAM,IAAA;AAAA;;;;;;;;;;;cAyBJ,YAAA,MACX,IAAA,EAAM,IAAA,EACN,MAAA,EAAQ,gBAAA,CAAkC,CAAA,MACzC,MAAA,CAAO,MAAA,CACR,CAAA,EACA,eAAA,GAAkB,cAAA,GAAkC,qBAAA"}

package/dist/{chunk-CfYAbeIz.mjs → chunk-uyGKjUfl.mjs}

@@ -1,5 +1,6 @@
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -10,4 +11,4 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-export { __exportAll as t };
+export { __exportAll as n, __commonJSMin as t };