@effect-uai/core 0.2.0 → 0.4.0

package/src/transcriber/Transcriber.test.ts

@@ -0,0 +1,125 @@
+import { Effect, Stream } from "effect"
+import { describe, expect, expectTypeOf, it } from "vitest"
+import type * as AiError from "../domain/AiError.js"
+import type { TranscriptEvent, TranscriptResult } from "../domain/Transcript.js"
+import * as MockTranscriber from "../testing/MockTranscriber.js"
+import * as Transcriber from "./Transcriber.js"
+
+describe("Transcriber.transcribe", () => {
+  it("returns the scripted TranscriptResult", async () => {
+    const mock = MockTranscriber.layer({
+      transcripts: [{ text: "hello world", durationSeconds: 1.23 }],
+    })
+    const program = Transcriber.transcribe({
+      audio: { _tag: "bytes", bytes: new Uint8Array([0]), mimeType: "audio/wav" },
+      model: "mock-stt",
+    })
+    const result = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
+    expect(result.text).toBe("hello world")
+    expect(result.durationSeconds).toBe(1.23)
+  })
+
+  it("records each transcribe call", async () => {
+    const mock = MockTranscriber.layer({
+      transcripts: [{ text: "a" }, { text: "b" }],
+    })
+    const program = Effect.gen(function* () {
+      yield* Transcriber.transcribe({
+        audio: { _tag: "bytes", bytes: new Uint8Array([1]), mimeType: "audio/wav" },
+        model: "m1",
+      })
+      yield* Transcriber.transcribe({
+        audio: { _tag: "bytes", bytes: new Uint8Array([2]), mimeType: "audio/wav" },
+        model: "m2",
+      })
+      return yield* mock.recorder
+    })
+    const rec = await Effect.runPromise(program.pipe(Effect.provide(mock.layer)))
+    expect(rec.transcribeCalls.map((c) => c.model)).toEqual(["m1", "m2"])
+  })
+})
+
+describe("Transcriber capability marker (compile-time)", () => {
+  const sttReq: Transcriber.CommonStreamTranscribeRequest = {
+    model: "mock-stt",
+    inputFormat: { container: "raw", encoding: "pcm_s16le", sampleRate: 16000 },
+  }
+
+  it("requires `SttStreaming` on the R channel of streamTranscriptionFrom", () => {
+    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])
+    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))
+    expectTypeOf(events).toEqualTypeOf<
+      Stream.Stream<
+        TranscriptEvent,
+        AiError.AiError,
+        Transcriber.Transcriber | Transcriber.SttStreaming
+      >
+    >()
+  })
+
+  it("does NOT require `SttStreaming` for sync `transcribe`", () => {
+    const eff = Transcriber.transcribe({
+      audio: { _tag: "bytes", bytes: new Uint8Array([0]), mimeType: "audio/wav" },
+      model: "m",
+    })
+    expectTypeOf(eff).toEqualTypeOf<
+      Effect.Effect<TranscriptResult, AiError.AiError, Transcriber.Transcriber>
+    >()
+  })
+
+  it("a sync-only layer leaves `SttStreaming` unsatisfied in R", () => {
+    const syncOnly = MockTranscriber.layerSyncOnly({})
+    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])
+    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))
+    const program = Stream.runDrain(events).pipe(Effect.provide(syncOnly.layer))
+    // `Transcriber` is provided by syncOnly.layer; `SttStreaming` is not.
+    expectTypeOf(program).toEqualTypeOf<
+      Effect.Effect<void, AiError.AiError, Transcriber.SttStreaming>
+    >()
+  })
+
+  it("a full layer (with marker) clears R to never", () => {
+    const fullMock = MockTranscriber.layer({ streams: [[]] })
+    const audio: Stream.Stream<Uint8Array> = Stream.fromIterable([new Uint8Array([0])])
+    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))
+    const program = Stream.runDrain(events).pipe(Effect.provide(fullMock.layer))
+    expectTypeOf(program).toEqualTypeOf<Effect.Effect<void, AiError.AiError, never>>()
+  })
+})
+
+describe("Transcriber.streamTranscriptionFrom", () => {
+  const sttReq: Transcriber.CommonStreamTranscribeRequest = {
+    model: "mock-stt",
+    inputFormat: { container: "raw", encoding: "pcm_s16le", sampleRate: 16000 },
+  }
+
+  it("emits scripted events after draining the input audio stream", async () => {
+    const mock = MockTranscriber.layer({
+      streams: [
+        [
+          { _tag: "partial", text: "hello" },
+          { _tag: "final", text: "hello world" },
+        ],
+      ],
+    })
+    const audio = Stream.fromIterable([new Uint8Array([0, 1, 2]), new Uint8Array([3, 4, 5])])
+    const events = audio.pipe(Transcriber.streamTranscriptionFrom(sttReq))
+    const collected = await Effect.runPromise(
+      Stream.runCollect(events).pipe(Effect.provide(mock.layer)),
+    )
+    expect(collected).toEqual([
+      { _tag: "partial", text: "hello" },
+      { _tag: "final", text: "hello world" },
+    ])
+  })
+
+  it("works data-first (direct call) as well as pipeable (data-last)", async () => {
+    const mock = MockTranscriber.layer({
+      streams: [[{ _tag: "final", text: "x" }]],
+    })
+    const audio = Stream.fromIterable([new Uint8Array([0])])
+    const events = Transcriber.streamTranscriptionFrom(audio, sttReq)
+    const out = await Effect.runPromise(Stream.runCollect(events).pipe(Effect.provide(mock.layer)))
+    expect(out).toEqual([{ _tag: "final", text: "x" }])
+  })
+})

package/src/transcriber/Transcriber.ts

@@ -0,0 +1,127 @@
+import { Context, Effect, Function, Stream } from "effect"
+import * as AiError from "../domain/AiError.js"
+import type { AudioFormat, AudioSource } from "../domain/Audio.js"
+import type { TranscriptEvent, TranscriptResult } from "../domain/Transcript.js"
+
+/**
+ * Cross-provider sync transcription request. Provider-specific
+ * extensions (Deepgram `keyterm[]`, ElevenLabs `diarize`, Google
+ * `adaptation`, …) live on each provider's typed request which extends
+ * this and narrows `model`.
+ */
+export type CommonTranscribeRequest = {
+  readonly audio: AudioSource
+  /** Model identifier. Each provider narrows to its typed literal union. */
+  readonly model: string
+  /** ISO-639-1 / BCP-47. Omit for autodetection (where supported). */
+  readonly language?: string
+  /**
+   * Vocab biasing. Single-string covers OpenAI/Whisper-style prompts;
+   * `terms[]` covers Deepgram `keyterm`, Google adaptation phrases, AWS
+   * `vocabularyName`. Providers ignore what they don't support.
+   */
+  readonly prompt?: string | { readonly terms: ReadonlyArray<string> }
+  readonly diarization?: boolean
+  readonly wordTimestamps?: boolean
+}
+
+/**
+ * Streaming-transcription request. `inputFormat` declares what the
+ * bytes in the input stream will look like — providers reject
+ * mismatches at stream startup with `AiError.InvalidRequest`.
+ */
+export type CommonStreamTranscribeRequest = Omit<CommonTranscribeRequest, "audio"> & {
+  readonly inputFormat: AudioFormat
+  readonly interimResults?: boolean
+  readonly vadEvents?: boolean
+}
+
+export type TranscriberService = {
+  /**
+   * One-shot transcription. Universal — AWS Transcribe (which has no
+   * native sync endpoint) emulates this by draining a streaming session
+   * internally.
+   */
+  readonly transcribe: (
+    request: CommonTranscribeRequest,
+  ) => Effect.Effect<TranscriptResult, AiError.AiError>
+  /**
+   * Live transcription as a Stream transformer. Consumes audio bytes
+   * from `audioIn`; emits `TranscriptEvent`s as they arrive. The
+   * underlying WS / gRPC connection is acquired on first pull and
+   * released when the output stream is finalized (success, failure, or
+   * interruption) via `Stream.scoped` — no explicit Scope handling at
+   * the call site.
+   *
+   * Gated by the `SttStreaming` capability marker on the top-level
+   * helper — providers without streaming-STT support don't ship the
+   * marker, so calls fail at `Effect.provide` with a type error.
+   */
+  readonly streamTranscriptionFrom: <E, R>(
+    audioIn: Stream.Stream<Uint8Array, E, R>,
+    request: CommonStreamTranscribeRequest,
+  ) => Stream.Stream<TranscriptEvent, AiError.AiError | E, R>
+}
+
+export class Transcriber extends Context.Service<Transcriber, TranscriberService>()(
+  "@betalyra/effect-uai/Transcriber",
+) {}
+
+/**
+ * Capability marker — provided by provider layers whose
+ * `streamTranscriptionFrom` is wired up at the wire level. Azure does
+ * not ship it (streaming-STT is SDK-internal). Calling
+ * `streamTranscriptionFrom` while only Azure's Layer is in scope fails
+ * at `Effect.provide` with a type error, not at runtime.
+ *
+ * Phantom — the value is `void`; providers register with
+ * `Layer.succeed(SttStreaming, undefined)`.
+ */
+export class SttStreaming extends Context.Service<SttStreaming, void>()(
+  "@betalyra/effect-uai/capability/SttStreaming",
+) {}
+
+/** One-shot transcription. */
+export const transcribe = (
+  request: CommonTranscribeRequest,
+): Effect.Effect<TranscriptResult, AiError.AiError, Transcriber> =>
+  Effect.flatMap(Transcriber.asEffect(), (t) => t.transcribe(request))
+
+/**
+ * Live transcription. Dual-arity: pipeable (data-last) and direct
+ * (data-first). Requires `SttStreaming` in R — providers without
+ * streaming support are a type error at provide time.
+ *
+ * @example
+ * ```ts
+ * // Pipeable — composes with other Stream operators
+ * mic.frames.pipe(
+ *   Transcriber.streamTranscriptionFrom(req),
+ *   Stream.filter((e) => e._tag === "final"),
+ * )
+ *
+ * // Direct
+ * Transcriber.streamTranscriptionFrom(mic.frames, req)
+ * ```
+ */
+export const streamTranscriptionFrom: {
+  (
+    request: CommonStreamTranscribeRequest,
+  ): <E, R>(
+    audioIn: Stream.Stream<Uint8Array, E, R>,
+  ) => Stream.Stream<TranscriptEvent, AiError.AiError | E, R | Transcriber | SttStreaming>
+  <E, R>(
+    audioIn: Stream.Stream<Uint8Array, E, R>,
+    request: CommonStreamTranscribeRequest,
+  ): Stream.Stream<TranscriptEvent, AiError.AiError | E, R | Transcriber | SttStreaming>
+} = Function.dual(
+  2,
+  <E, R>(audioIn: Stream.Stream<Uint8Array, E, R>, request: CommonStreamTranscribeRequest) =>
+    Stream.unwrap(
+      Effect.gen(function* () {
+        const t = yield* Transcriber.asEffect()
+        yield* SttStreaming.asEffect()
+        return t.streamTranscriptionFrom(audioIn, request)
+      }),
+    ),
+)

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

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

package/dist/Outcome-GiaNvt7i.d.mts

@@ -1,32 +0,0 @@
-import { o as FunctionCall, s as FunctionCallOutput } from "./Items-D1C2686t.mjs";
-
-//#region src/tool/Outcome.d.ts
-type ToolResult = {
-  readonly _tag: "Value";
-  readonly call_id: string;
-  readonly tool: string;
-  readonly value: unknown;
-} | {
-  readonly _tag: "Failure";
-  readonly call_id: string;
-  readonly tool: string;
-  readonly kind: string;
-  readonly reason?: string;
-};
-declare const isValue: (r: ToolResult) => r is Extract<ToolResult, {
-  _tag: "Value";
-}>;
-declare const isFailure: (r: ToolResult) => r is Extract<ToolResult, {
-  _tag: "Failure";
-}>;
-declare const rejected: (call: FunctionCall, kind: string, reason?: string) => ToolResult;
-/** Explicit user/policy rejection. */
-declare const denied: (call: FunctionCall, reason?: string) => ToolResult;
-/** Implicit non-answer (follow-up, inactivity, abort). */
-declare const cancelled: (call: FunctionCall, reason?: string) => ToolResult;
-/** Tool's own execution failed (parse error, schema, runtime crash). */
-declare const executionError: (call: FunctionCall, reason: string) => ToolResult;
-declare const toFunctionCallOutput: (r: ToolResult) => FunctionCallOutput;
-//#endregion
-export { isFailure as a, toFunctionCallOutput as c, executionError as i, cancelled as n, isValue as o, denied as r, rejected as s, ToolResult as t };
-//# sourceMappingURL=Outcome-GiaNvt7i.d.mts.map

package/dist/Outcome-GiaNvt7i.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Outcome-GiaNvt7i.d.mts","names":[],"sources":["../src/tool/Outcome.ts"],"mappings":";;;KAqBY,UAAA;EAAA,SAEG,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA;AAAA;AAAA,cAGF,OAAA,GAAW,CAAA,EAAG,UAAA,KAAa,CAAA,IAAK,OAAA,CAAQ,UAAA;EAAc,IAAA;AAAA;AAAA,cAGtD,SAAA,GAAa,CAAA,EAAG,UAAA,KAAa,CAAA,IAAK,OAAA,CAAQ,UAAA;EAAc,IAAA;AAAA;AAAA,cAOxD,QAAA,GACX,IAAA,EAAM,YAAA,EACN,IAAA,UACA,MAAA,cACC,UAAA;;cASU,MAAA,GAAU,IAAA,EAAM,YAAA,EAAc,MAAA,cAAkB,UAAA;;cAIhD,SAAA,GAAa,IAAA,EAAM,YAAA,EAAc,MAAA,cAAkB,UAAA;;cAInD,cAAA,GAAkB,IAAA,EAAM,YAAA,EAAc,MAAA,aAAiB,UAAA;AAAA,cAOvD,oBAAA,GAAwB,CAAA,EAAG,UAAA,KAAa,kBAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"StructuredFormat-B5ueioNr.d.mts","names":[],"sources":["../src/structured-format/StructuredFormat.ts"],"mappings":";;;;;;;;;;;;;;;KAaY,gBAAA,qBAAqC,gBAAA,UAA0B,MAAA,IACzE,oBAAA,UAA8B,MAAA;;;;;;UAOf,gBAAA;EAAA,SACN,IAAA;EAAA,SACA,WAAA;EAAA,SACA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;EAXxB;;;;EAAA,SAgBD,MAAA;AAAA;;UAIM,WAAA;EAAA,SACN,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.map

@@ -1 +0,0 @@
-{"version":3,"file":"Tool-5wxOCuOh.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,UAIN,IAAA;EAAA,SACN,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;;;;;;UAQM,cAAA;EAAA,SACN,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,UAWZ,aAAA;EAAA,SACN,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,GAAmB,aAAA;AAAA,KACnB,YAAA,GAAe,IAAA;AAAA,KACf,WAAA,GAAc,gBAAA,GAAmB,YAAA;AAAA,cAEhC,eAAA,GAAmB,CAAA,EAAG,WAAA,KAAc,CAAA,IAAK,gBAAA;;;;;;cAQzC,aAAA,GACX,KAAA,EAAO,aAAA,CAAc,WAAA,MACpB,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/ToolEvent-wTMgb2GO.d.mts

@@ -1,29 +0,0 @@
-import { t as ToolResult } from "./Outcome-GiaNvt7i.mjs";
-
-//#region src/tool/ToolEvent.d.ts
-type ToolEvent = {
-  readonly _tag: "ApprovalRequested";
-  readonly call_id: string;
-  readonly tool: string;
-  readonly arguments: string;
-} | {
-  readonly _tag: "Intermediate";
-  readonly call_id: string;
-  readonly tool: string;
-  readonly data: unknown;
-} | {
-  readonly _tag: "Output";
-  readonly result: ToolResult;
-};
-declare const isApprovalRequested: (e: ToolEvent) => e is Extract<ToolEvent, {
-  _tag: "ApprovalRequested";
-}>;
-declare const isIntermediate: (e: ToolEvent) => e is Extract<ToolEvent, {
-  _tag: "Intermediate";
-}>;
-declare const isOutput: (e: ToolEvent) => e is Extract<ToolEvent, {
-  _tag: "Output";
-}>;
-//#endregion
-export { isOutput as i, isApprovalRequested as n, isIntermediate as r, ToolEvent as t };
-//# sourceMappingURL=ToolEvent-wTMgb2GO.d.mts.map

package/dist/ToolEvent-wTMgb2GO.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ToolEvent-wTMgb2GO.d.mts","names":[],"sources":["../src/tool/ToolEvent.ts"],"mappings":";;;KAYY,SAAA;EAAA,SAEG,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,SAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;AAAA;EAAA,SAEA,IAAA;EAAA,SAAyB,MAAA,EAAQ,UAAA;AAAA;AAAA,cAEnC,mBAAA,GACX,CAAA,EAAG,SAAA,KACF,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;AAAA,cAEhB,cAAA,GACX,CAAA,EAAG,SAAA,KACF,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA;AAAA,cAEhB,QAAA,GAAY,CAAA,EAAG,SAAA,KAAY,CAAA,IAAK,OAAA,CAAQ,SAAA;EAAa,IAAA;AAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"Turn-Bi83du4I.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/match/Match.d.mts

@@ -1,16 +0,0 @@
-import { Match } from "effect";
-
-//#region src/match/Match.d.ts
-declare namespace Match_d_exports {
-  export { matchType };
-}
-/**
- * Dispatch on the `type` discriminator of a tagged union. Equivalent to
- * `Match.discriminator("type")`, exposed as a named helper because the
- * `type` field is the framework's convention for `Item`, `TurnEvent`,
- * `ContentBlock`, and most provider wire types.
- */
-declare const matchType: <R, P extends Match.Types.Tags<"type", R> & string, Ret, Fn extends (_: Extract<R, Record<"type", P>>) => Ret>(...pattern: [first: P, ...values: P[], f: Fn]) => <I, F, A, Pr>(self: Match.Matcher<I, F, R, A, Pr, Ret>) => Match.Matcher<I, Match.Types.AddWithout<F, Extract<R, Record<"type", P>>>, Match.Types.ApplyFilters<I, Match.Types.AddWithout<F, Extract<R, Record<"type", P>>>>, A | ReturnType<Fn>, Pr, Ret>;
-//#endregion
-export { matchType, Match_d_exports as t };
-//# sourceMappingURL=Match.d.mts.map

package/dist/match/Match.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Match.d.mts","names":[],"sources":["../../src/match/Match.ts"],"mappings":";;;;;;;;;;AAQA;;cAAa,SAAA,gBAAS,KAAA,CAAA,KAAA,CAAA,IAAA,SAAA,CAAA,6BAAA,CAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,SAAA,CAAA,OAAA,GAAA,KAAA,OAAA,GAAA,KAAA,EAAA,CAAA,KAAA,MAAA,EAAA,CAAA,IAAA,CAAA,EAAA,EAAA,oBAAA,IAAA,EAAA,KAAA,CAAA,OAAA,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,EAAA,EAAA,GAAA,MAAA,KAAA,CAAA,OAAA,CAAA,CAAA,EAAA,KAAA,CAAA,KAAA,CAAA,UAAA,CAAA,CAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,SAAA,CAAA,KAAA,KAAA,CAAA,KAAA,CAAA,YAAA,CAAA,CAAA,EAAA,KAAA,CAAA,KAAA,CAAA,UAAA,CAAA,CAAA,EAAA,OAAA,CAAA,CAAA,EAAA,MAAA,SAAA,CAAA,MAAA,CAAA,GAAA,UAAA,CAAA,EAAA,GAAA,EAAA,EAAA,GAAA"}

package/dist/match/Match.mjs

@@ -1,15 +0,0 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
-import { Match } from "effect";
-//#region src/match/Match.ts
-var Match_exports = /* @__PURE__ */ __exportAll({ matchType: () => matchType });
-/**
-* Dispatch on the `type` discriminator of a tagged union. Equivalent to
-* `Match.discriminator("type")`, exposed as a named helper because the
-* `type` field is the framework's convention for `Item`, `TurnEvent`,
-* `ContentBlock`, and most provider wire types.
-*/
-const matchType = Match.discriminator("type");
-//#endregion
-export { matchType, Match_exports as t };
-
-//# sourceMappingURL=Match.mjs.map

package/dist/match/Match.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Match.mjs","names":[],"sources":["../../src/match/Match.ts"],"sourcesContent":["import { Match } from \"effect\"\n\n/**\n * Dispatch on the `type` discriminator of a tagged union. Equivalent to\n * `Match.discriminator(\"type\")`, exposed as a named helper because the\n * `type` field is the framework's convention for `Item`, `TurnEvent`,\n * `ContentBlock`, and most provider wire types.\n */\nexport const matchType = Match.discriminator(\"type\")\n"],"mappings":";;;;;;;;;;AAQA,MAAa,YAAY,MAAM,cAAc,OAAO"}

package/src/match/Match.ts

@@ -1,9 +0,0 @@
-import { Match } from "effect"
-
-/**
- * Dispatch on the `type` discriminator of a tagged union. Equivalent to
- * `Match.discriminator("type")`, exposed as a named helper because the
- * `type` field is the framework's convention for `Item`, `TurnEvent`,
- * `ContentBlock`, and most provider wire types.
- */
-export const matchType = Match.discriminator("type")