@effect-uai/core 0.13.0 → 0.15.0

package/src/messenger/MessengerAdapter.test.ts

@@ -0,0 +1,179 @@
+import { describe, it } from "@effect/vitest"
+import { Array as Arr, Duration, Effect, Option, Result, Stream } from "effect"
+import { TestClock } from "effect/testing"
+import { expect } from "vitest"
+import * as MockMessenger from "../testing/MockMessenger.js"
+import {
+  ChannelId,
+  type ConversationRef,
+  MessageId,
+  type Outbound,
+  type StreamOptions,
+  inConversation,
+} from "./Messenger.js"
+import { type StreamViaEditsOptions, splitForLimit } from "./MessengerAdapter.js"
+import { MessengerRateLimited } from "./MessengerError.js"
+
+const here: ConversationRef = { channel: ChannelId("c1") }
+
+const bodyOf = (msg: Outbound): string => (msg.body._tag === "Text" ? msg.body.text : "")
+
+const posts = (calls: ReadonlyArray<MockMessenger.Call>) =>
+  Arr.filterMap(calls, (c) =>
+    c._tag === "Post" ? Result.succeed(bodyOf(c.message)) : Result.failVoid,
+  )
+
+const edits = (calls: ReadonlyArray<MockMessenger.Call>) =>
+  Arr.filterMap(calls, (c) =>
+    c._tag === "Edit" ? Result.succeed(bodyOf(c.next)) : Result.failVoid,
+  )
+
+/** Run `deltas` through the mock's `stream` and hand back the call log. */
+const streamed = (
+  deltas: ReadonlyArray<string>,
+  script: MockMessenger.MockMessengerScript = {},
+  streamOptions?: StreamOptions,
+) =>
+  Effect.gen(function* () {
+    const { service, recorder } = MockMessenger.make(script)
+    const id = yield* service.stream(Stream.fromIterable(deltas), streamOptions)
+    const { calls } = yield* recorder
+    return { id, calls }
+  }).pipe(inConversation(here))
+
+const options = (o: StreamViaEditsOptions): MockMessenger.MockMessengerScript => ({
+  streamOptions: o,
+})
+
+// ---------------------------------------------------------------------------
+// splitForLimit
+// ---------------------------------------------------------------------------
+
+describe("splitForLimit", () => {
+  it("prefers a paragraph break, then a line, then a word", () => {
+    expect(splitForLimit("aaa\n\nbbb ccc", 8)).toEqual(["aaa", "bbb ccc"])
+    expect(splitForLimit("aaa\nbbbb ccc", 8)).toEqual(["aaa", "bbbb ccc"])
+    expect(splitForLimit("aaaa bbbb ccc", 9)).toEqual(["aaaa", "bbbb ccc"])
+  })
+
+  it("hard-cuts a run with no boundary inside the limit", () => {
+    expect(splitForLimit("aaaaaaaaaa", 4)).toEqual(["aaaa", "aaaa", "aa"])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// streamViaEdits
+// ---------------------------------------------------------------------------
+
+describe("streamViaEdits", () => {
+  // TestClock keeps wall time frozen, so the `every` gate never opens and
+  // every delta after the first coalesces into the final flush.
+  it.effect("coalesces deltas arriving inside the `every` window", () =>
+    Effect.gen(function* () {
+      const { calls } = yield* streamed(["Hel", "lo ", "the", "re!"])
+
+      expect(posts(calls)).toEqual(["Hel"])
+      expect(edits(calls)).toEqual(["Hello there!"])
+    }),
+  )
+
+  it.effect("waits for `minChars` of growth before spending an edit", () =>
+    Effect.gen(function* () {
+      const { calls } = yield* streamed(
+        ["aaaa", "bbbb", "cccc", "dddd", "eeee", "ffff"],
+        options({ every: 0, minChars: 10 }),
+      )
+
+      // Edits land at 16 chars (12 of growth) and again on the final flush.
+      expect(posts(calls)).toEqual(["aaaa"])
+      expect(edits(calls).map((t) => t.length)).toEqual([16, 24])
+    }),
+  )
+
+  it.effect("skips the final flush when the message already shows the text", () =>
+    Effect.gen(function* () {
+      const { calls } = yield* streamed(
+        ["aaaaa", "bbbbb", "ccccc"],
+        options({ every: 0, minChars: 10 }),
+      )
+
+      // The third delta opens the growth gate, so the tail is already sent.
+      expect(edits(calls)).toEqual(["aaaaabbbbbccccc"])
+    }),
+  )
+
+  it.effect("rolls over to a new message past maxText", () =>
+    Effect.gen(function* () {
+      const { id, calls } = yield* streamed(["aaaa bbbb cccc dddd"], {
+        limits: { maxText: 10, maxCaption: 10 },
+      })
+
+      // Cut on the word boundary, not mid-word, and the id is the last message.
+      expect(posts(calls)).toEqual(["aaaa bbbb", "cccc dddd"])
+      expect(edits(calls)).toEqual([])
+      expect(id).toEqual(Option.some(MessageId("m2")))
+    }),
+  )
+
+  it.effect("quotes the question on the first message only, never on a rollover", () =>
+    Effect.gen(function* () {
+      const { calls } = yield* streamed(
+        ["aaaa bbbb cccc dddd"],
+        { limits: { maxText: 10, maxCaption: 10 } },
+        { replyTo: MessageId("q1") },
+      )
+
+      const replies = Arr.filterMap(calls, (c) =>
+        c._tag === "Post" ? Result.succeed(c.message.replyTo) : Result.failVoid,
+      )
+      expect(replies).toEqual([MessageId("q1"), undefined])
+    }),
+  )
+
+  it.effect("posts nothing for a stream with no text", () =>
+    Effect.gen(function* () {
+      const { id, calls } = yield* streamed(["", ""])
+
+      expect(calls).toEqual([])
+      expect(id).toEqual(Option.none())
+    }),
+  )
+
+  // A model opening a tool-calling turn with a newline, which every platform
+  // rejects as an empty message.
+  it.effect("treats whitespace-only deltas as no text at all", () =>
+    Effect.gen(function* () {
+      const { id, calls } = yield* streamed(["\n", "  ", "\n\n"])
+
+      expect(calls).toEqual([])
+      expect(id).toEqual(Option.none())
+    }),
+  )
+
+  it.live("waits out a rate limit and re-sends the same edit", () =>
+    Effect.gen(function* () {
+      const limited = new MessengerRateLimited({
+        provider: "mock",
+        retryAfter: Duration.millis(10),
+      })
+      const { calls } = yield* streamed(["abc", "defghij"], {
+        ...options({ every: 0, minChars: 1 }),
+        failures: [undefined, limited],
+      })
+
+      expect(posts(calls)).toEqual(["abc"])
+      expect(edits(calls)).toEqual(["abcdefghij", "abcdefghij"])
+    }),
+  )
+
+  it.effect("gives up once the rate-limit budget is spent", () =>
+    Effect.gen(function* () {
+      const limited = new MessengerRateLimited({ provider: "mock", retryAfter: Duration.zero })
+      const failed = yield* Effect.flip(
+        streamed(["abc"], { ...options({ rateLimitRetries: 1 }), failures: [limited, limited] }),
+      )
+
+      expect(failed._tag).toBe("MessengerRateLimited")
+    }).pipe(TestClock.withLive),
+  )
+})

package/src/messenger/MessengerAdapter.ts

@@ -0,0 +1,189 @@
+/**
+ * What an adapter author needs and a recipe author never sees: text
+ * splitting at a platform ceiling, and post-then-edit progressive delivery
+ * for platforms without a native streaming API.
+ */
+import { Array as Arr, Clock, Data, Duration, Effect, Option, Schedule, Stream } from "effect"
+import {
+  CurrentConversation,
+  type MessageId,
+  type MessengerService,
+  type StreamOptions,
+  text,
+} from "./Messenger.js"
+import type * as MessengerError from "./MessengerError.js"
+
+// ---------------------------------------------------------------------------
+// Text splitting
+// ---------------------------------------------------------------------------
+
+// Paragraph break first, then line break, then space.
+const boundaries = ["\n\n", "\n", " "] as const
+
+/** Best split at or before `limit`; a hard cut only for an unbroken run. */
+const cutAt = (body: string, limit: number): readonly [head: string, rest: string] =>
+  body.length <= limit
+    ? [body, ""]
+    : Arr.findFirst(boundaries, (sep) =>
+        Option.map(
+          Option.liftPredicate(body.lastIndexOf(sep, limit - sep.length), (at) => at > 0),
+          (at) => [body.slice(0, at), body.slice(at + sep.length)] as const,
+        ),
+      ).pipe(Option.getOrElse(() => [body.slice(0, limit), body.slice(limit)] as const))
+
+/**
+ * Chunk `body` into pieces no longer than `limit`, breaking on paragraph,
+ * line, then word boundaries. Always yields at least one chunk, so callers
+ * have something to send even for empty input.
+ */
+export const splitForLimit = (body: string, limit: number): Arr.NonEmptyReadonlyArray<string> => {
+  const [head, rest] = cutAt(body, limit)
+  return rest.length === 0 ? [head] : [head, ...splitForLimit(rest, limit)]
+}
+
+// ---------------------------------------------------------------------------
+// streamViaEdits
+// ---------------------------------------------------------------------------
+
+/** The slice of a messenger that {@link streamViaEdits} drives. */
+export type EditableVerbs = Pick<MessengerService, "post" | "edit" | "limits">
+
+export type StreamViaEditsOptions = {
+  /** Minimum wall time between edits. Default 1 second. */
+  readonly every?: Duration.Input
+  /** Minimum growth since the last edit before spending another. Default 40. */
+  readonly minChars?: number
+  /** How often to honour a `MessengerRateLimited` before giving up. Default 3. */
+  readonly rateLimitRetries?: number
+}
+
+const isRateLimited = (e: MessengerError.MessengerError): boolean =>
+  e._tag === "MessengerRateLimited"
+
+// A retry schedule's input is the error, so the delay is the platform's own
+// `retry_after` rather than a guess. Bounded by `recurs`, so an unlucky call
+// eventually surfaces the rate limit instead of stalling behind it.
+const honourRetryAfter = (
+  times: number,
+): Schedule.Schedule<number, MessengerError.MessengerError> =>
+  Schedule.recurs(times).pipe(
+    Schedule.setInputType<MessengerError.MessengerError>(),
+    Schedule.modifyDelay(({ input }) =>
+      Effect.succeed(input._tag === "MessengerRateLimited" ? input.retryAfter : Duration.zero),
+    ),
+  )
+
+/**
+ * The message being filled: not on the platform yet, or posted and edited
+ * since. Only the first draft carries the reply; rollover drafts do not.
+ */
+type Progress = Data.TaggedEnum<{
+  Draft: { readonly pending: string; readonly envelope: StreamOptions }
+  Sent: {
+    readonly id: MessageId
+    /** Text the message shows now. Never resent unchanged. */
+    readonly sent: string
+    /** Text it should show, deltas included. */
+    readonly pending: string
+    readonly lastFlush: number
+  }
+}>
+
+const Progress = Data.taggedEnum<Progress>()
+
+type Sent = Data.TaggedEnum.Value<Progress, "Sent">
+
+const appended = (s: Progress, delta: string): Progress => ({
+  ...s,
+  pending: s.pending + delta,
+})
+
+/**
+ * Progressive delivery as post-then-edit, for adapters with no native
+ * streaming API. Coalesces deltas by time and growth, never resends
+ * unchanged text, waits out `MessengerRateLimited`, rolls over to a fresh
+ * message past `limits.maxText`, and always flushes the tail.
+ *
+ * The first chunk goes out as soon as any text arrives, so the message shows
+ * up immediately and fills in from there. A stream that produced no text
+ * posts nothing and yields `None`.
+ */
+export const streamViaEdits =
+  (verbs: EditableVerbs, options?: StreamViaEditsOptions): MessengerService["stream"] =>
+  (deltas, streamOptions = {}) =>
+    Effect.gen(function* () {
+      const every = Duration.toMillis(options?.every ?? "1 second")
+      const minChars = options?.minChars ?? 40
+      const schedule = honourRetryAfter(options?.rateLimitRetries ?? 3)
+      const conversation = yield* CurrentConversation
+
+      const patiently = <A, R2>(
+        effect: Effect.Effect<A, MessengerError.MessengerError, R2>,
+      ): Effect.Effect<A, MessengerError.MessengerError, R2> =>
+        Effect.retry(effect, { schedule, while: isRateLimited })
+
+      // Post a draft, edit a sent message, and skip an edit that would resend
+      // what the message already shows.
+      const deliver = (
+        s: Progress,
+        body: string,
+        now: number,
+      ): Effect.Effect<Sent, MessengerError.MessengerError, CurrentConversation> =>
+        Progress.$match(s, {
+          Draft: ({ pending, envelope }) =>
+            patiently(verbs.post(text(body, envelope))).pipe(
+              Effect.map((id) => Progress.Sent({ id, sent: body, pending, lastFlush: now })),
+            ),
+          Sent: (sent) =>
+            body === sent.sent
+              ? Effect.succeed(sent)
+              : patiently(verbs.edit({ conversation, id: sent.id }, text(body))).pipe(
+                  Effect.as(Progress.Sent({ ...sent, sent: body, lastFlush: now })),
+                ),
+        })
+
+      // Anything past the ceiling becomes the next message: finish the current
+      // one at a clean boundary, then start a draft on the remainder.
+      const rollover = (
+        s: Progress,
+        now: number,
+      ): Effect.Effect<Progress, MessengerError.MessengerError, CurrentConversation> => {
+        const [head, rest] = cutAt(s.pending, verbs.limits.maxText)
+        return rest.length === 0
+          ? Effect.succeed(s)
+          : deliver(s, head, now).pipe(
+              Effect.flatMap(() => rollover(Progress.Draft({ pending: rest, envelope: {} }), now)),
+            )
+      }
+
+      // A draft lands on its first real text; a sent message waits for both
+      // gates. Blank is not text: a model that opens a tool-calling turn with
+      // a newline would otherwise post it, and platforms reject a message
+      // that is only whitespace.
+      const due = (s: Progress, now: number): boolean =>
+        Progress.$match(s, {
+          Draft: ({ pending }) => pending.trim().length > 0,
+          Sent: ({ sent, pending, lastFlush }) =>
+            now - lastFlush >= every && pending.length - sent.length >= minChars,
+        })
+
+      const step = (before: Progress, delta: string) =>
+        Effect.gen(function* () {
+          const now = yield* Clock.currentTimeMillis
+          const s = yield* rollover(appended(before, delta), now)
+          if (!due(s, now)) return s
+          return yield* deliver(s, s.pending, now)
+        })
+
+      const folded = yield* Stream.runFoldEffect(
+        deltas,
+        () => Progress.Draft({ pending: "", envelope: streamOptions }),
+        step,
+      )
+      const now = yield* Clock.currentTimeMillis
+      const s = yield* rollover(folded, now)
+      // The tail always lands; a draft that never held text is nothing to send.
+      if (s._tag === "Draft" && s.pending.trim().length === 0) return Option.none()
+      const final = yield* deliver(s, s.pending, now)
+      return Option.some(final.id)
+    })

package/src/messenger/MessengerError.ts

@@ -0,0 +1,67 @@
+import { Data, type Duration, Match } from "effect"
+
+// `reason` is required wherever one exists: the platform always says
+// something, and an adapter raising `Unsupported` knows why it did.
+
+/** Transport never came up: bad token, rejected handshake. Raised at layer build. */
+export class MessengerConnectFailed extends Data.TaggedError("MessengerConnectFailed")<{
+  provider: string
+  reason: string
+  raw: unknown
+}> {}
+
+/**
+ * Inbound transport ended for good (reconnect budget spent, fatal close).
+ * Routine reconnects stay inside the adapter and never surface here.
+ */
+export class MessengerTransportClosed extends Data.TaggedError("MessengerTransportClosed")<{
+  provider: string
+  reason: string
+  raw?: unknown
+}> {}
+
+/** Which verb was rejected. */
+export type MessengerOperation = "post" | "edit" | "react" | "typing"
+
+/** An outbound verb was rejected: permission, unknown chat, text too long, no-op edit. */
+export class MessengerRequestFailed extends Data.TaggedError("MessengerRequestFailed")<{
+  provider: string
+  operation: MessengerOperation
+  reason: string
+  raw: unknown
+}> {}
+
+/**
+ * Slow down, for this long. Typed rather than retried blindly so callers -
+ * `streamViaEdits` above all - decide whether waiting is still worth it.
+ */
+export class MessengerRateLimited extends Data.TaggedError("MessengerRateLimited")<{
+  provider: string
+  retryAfter: Duration.Duration
+  raw?: unknown
+}> {}
+
+/** The platform cannot express this at all: off-set reaction emoji, edits on WhatsApp. */
+export class MessengerUnsupported extends Data.TaggedError("MessengerUnsupported")<{
+  provider: string
+  capability: string
+  reason: string
+}> {}
+
+export type MessengerError =
+  | MessengerConnectFailed
+  | MessengerTransportClosed
+  | MessengerRequestFailed
+  | MessengerRateLimited
+  | MessengerUnsupported
+
+/** Human-readable description for logs. Prose, not a contract; branch on `_tag`. */
+export const describe: (e: MessengerError) => string = Match.type<MessengerError>().pipe(
+  Match.discriminatorsExhaustive("_tag")({
+    MessengerConnectFailed: (e) => `the messenger could not connect: ${e.reason}`,
+    MessengerTransportClosed: (e) => `the messenger connection closed: ${e.reason}`,
+    MessengerRequestFailed: (e) => `the ${e.operation} was rejected: ${e.reason}`,
+    MessengerRateLimited: () => "the messenger is rate limited",
+    MessengerUnsupported: (e) => `this messenger does not support ${e.capability}: ${e.reason}`,
+  }),
+)

package/src/streaming/Multipart.ts

@@ -0,0 +1,29 @@
+import { Effect } from "effect"
+import { HttpClientRequest } from "effect/unstable/http"
+
+/**
+ * Multipart body for an `HttpClientRequest`, encoded to bytes.
+ *
+ * Use this over `HttpClientRequest.bodyFormData`: the Undici client
+ * passes the `FormData` object straight to `dispatcher.request`, which
+ * cannot serialise it, so the request is never sent and the effect
+ * hangs with no error. Encoding here produces the same bytes every
+ * other client derives internally, so it works on all of them.
+ *
+ * The failure is whatever `Response.arrayBuffer` rejects with; map it
+ * to your provider's transport error at the call site.
+ */
+export const bodyMultipart = (
+  form: FormData,
+): Effect.Effect<
+  (request: HttpClientRequest.HttpClientRequest) => HttpClientRequest.HttpClientRequest,
+  unknown
+> =>
+  Effect.gen(function* () {
+    const encoded = new Response(form)
+    const buffer = yield* Effect.tryPromise(() => encoded.arrayBuffer())
+    return HttpClientRequest.bodyUint8Array(
+      new Uint8Array(buffer),
+      encoded.headers.get("content-type") ?? "multipart/form-data",
+    )
+  })

package/src/testing/MockMessenger.ts

@@ -0,0 +1,147 @@
+import { Array as Arr, Data, Effect, Layer, Option, Ref, Stream } from "effect"
+import {
+  type ConversationRef,
+  CurrentConversation,
+  type InboundEvent,
+  MessageId,
+  type MessageRef,
+  Messenger,
+  type MessengerLimits,
+  type MessengerService,
+  type Outbound,
+} from "../messenger/Messenger.js"
+import {
+  type StreamViaEditsOptions,
+  splitForLimit,
+  streamViaEdits,
+} from "../messenger/MessengerAdapter.js"
+import * as MessengerError from "../messenger/MessengerError.js"
+
+// ---------------------------------------------------------------------------
+// Call log
+// ---------------------------------------------------------------------------
+
+/**
+ * One entry per outbound call. `Post` is logged once even when the text was
+ * long enough to split, so a caller that rolled over on its own is
+ * distinguishable from one that leaned on `post` to do it.
+ */
+export type Call = Data.TaggedEnum<{
+  Post: { readonly conversation: ConversationRef; readonly message: Outbound }
+  Edit: { readonly message: MessageRef; readonly next: Outbound }
+  React: { readonly message: MessageRef; readonly emoji: string }
+  TypingStart: { readonly conversation: ConversationRef }
+  TypingStop: { readonly conversation: ConversationRef }
+}>
+
+export const Call = Data.taggedEnum<Call>()
+
+export type MockMessengerRecorder = {
+  readonly calls: ReadonlyArray<Call>
+}
+
+// ---------------------------------------------------------------------------
+// Script
+// ---------------------------------------------------------------------------
+
+export type MockMessengerScript = {
+  /** Inbound events to replay. Empty by default. */
+  readonly events?: Stream.Stream<InboundEvent, MessengerError.MessengerError>
+  readonly limits?: MessengerLimits
+  /**
+   * Failures handed back one per `post` / `edit` call, in order; `undefined`
+   * entries succeed, and everything past the end succeeds.
+   */
+  readonly failures?: ReadonlyArray<MessengerError.MessengerError | undefined>
+  /** Passed through to `streamViaEdits`, which backs `stream`. */
+  readonly streamOptions?: StreamViaEditsOptions
+}
+
+const defaultLimits: MessengerLimits = { maxText: 4096, maxCaption: 1024 }
+
+const bodyText = (msg: Outbound): Option.Option<string> =>
+  msg.body._tag === "Text" ? Option.some(msg.body.text) : Option.none()
+
+// ---------------------------------------------------------------------------
+// Service builder
+// ---------------------------------------------------------------------------
+
+const buildService = (
+  script: MockMessengerScript,
+  record: (call: Call) => Effect.Effect<void>,
+  cursor: Ref.Ref<number>,
+  minted: Ref.Ref<number>,
+): MessengerService => {
+  const limits = script.limits ?? defaultLimits
+
+  const nextFailure = Ref.getAndUpdate(cursor, (n) => n + 1).pipe(
+    Effect.flatMap((i) =>
+      Option.match(Option.fromNullishOr((script.failures ?? [])[i]), {
+        onNone: () => Effect.void,
+        onSome: Effect.fail<MessengerError.MessengerError>,
+      }),
+    ),
+  )
+
+  const mint = Ref.updateAndGet(minted, (n) => n + 1).pipe(Effect.map((n) => MessageId(`m${n}`)))
+
+  const post: MessengerService["post"] = (msg) =>
+    Effect.gen(function* () {
+      const conversation = yield* CurrentConversation
+      yield* record(Call.Post({ conversation, message: msg }))
+      yield* nextFailure
+      // One id per chunk, mirroring an adapter that splits at the ceiling.
+      const chunks = Option.match(bodyText(msg), {
+        onNone: () => 1,
+        onSome: (t) => splitForLimit(t, limits.maxText).length,
+      })
+      return yield* Effect.map(
+        Effect.forEach(Arr.range(1, chunks), () => mint),
+        Arr.lastNonEmpty,
+      )
+    })
+
+  const edit: MessengerService["edit"] = (msg, next) =>
+    record(Call.Edit({ message: msg, next })).pipe(Effect.andThen(nextFailure))
+
+  return {
+    events: script.events ?? Stream.empty,
+    post,
+    edit,
+    react: (msg, emoji) => record(Call.React({ message: msg, emoji })),
+    typing: Effect.gen(function* () {
+      const conversation = yield* CurrentConversation
+      yield* record(Call.TypingStart({ conversation }))
+      yield* Effect.addFinalizer(() => record(Call.TypingStop({ conversation })))
+    }),
+    stream: streamViaEdits({ post, edit, limits }, script.streamOptions),
+    limits,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+const makeUnsafe = (script: MockMessengerScript) => {
+  const calls = Ref.makeUnsafe<ReadonlyArray<Call>>([])
+  const service = buildService(
+    script,
+    (call) => Ref.update(calls, Arr.append(call)),
+    Ref.makeUnsafe(0),
+    Ref.makeUnsafe(0),
+  )
+  return {
+    service,
+    recorder: Ref.get(calls).pipe(Effect.map((c): MockMessengerRecorder => ({ calls: c }))),
+  }
+}
+
+/** Layer registering the mock against the `Messenger` tag, plus its recorder. */
+export const layer = (script: MockMessengerScript = {}) => {
+  const { service, recorder } = makeUnsafe(script)
+  return { layer: Layer.succeed(Messenger, service), recorder }
+}
+
+/** Bare service value + recorder. Use with `Effect.provideService`. */
+export const make = (script: MockMessengerScript = {}) => makeUnsafe(script)

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

@@ -1,59 +0,0 @@
-import { i as MediaUrl, n as MediaBytes, r as MediaSource, t as MediaBase64 } from "./Media-DwgpifPD.mjs";
-import { Schema } from "effect";
-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 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-BK8-4H6s.d.mts.map

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

@@ -1 +0,0 @@
-{"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-SfUabNuB.d.mts.map

@@ -1 +0,0 @@
-{"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"}