@effect-uai/ui 0.0.0-stage → 0.17.0

package/src/Atoms.ts

@@ -0,0 +1,355 @@
+/**
+ * Framework-neutral state over a transport, built on `effect/reactivity`.
+ * Per-run transports: `make` takes any fold (`initial` + `step`), `thread`
+ * is the `Thread` preset. Session transports: `session` and
+ * `sessionThread`, likewise. React reads them with `@effect/atom-react` (`useAtomValue`,
+ * `useAtomSet`), Vue and Solid with their official bindings, plain JS with
+ * `AtomRegistry.subscribe`.
+ *
+ * With a `UiContract`, every envelope is decoded once on arrival, so the
+ * state holds decoded payloads and is typed by the contract.
+ */
+import { Effect, Exit, Option, type Schema, Stream } from "effect"
+import type { SecureRandom } from "effect/crypto"
+import { Atom } from "effect/reactivity"
+import * as Input from "./Input.js"
+import type { Envelope, Payloads, StreamId, Untyped } from "./RunEvent.js"
+import * as Thread from "./Thread.js"
+import type * as Transport from "./Transport.js"
+import type { UiContract } from "./UiContract.js"
+
+/**
+ * What `submit` does while a run is in flight. `"block"` ignores the new
+ * input; `"stop-then-submit"` abandons the current run locally and starts
+ * the new one (in durable mode the server-side run keeps going).
+ */
+export type Busy = "block" | "stop-then-submit"
+
+/**
+ * The atoms' runtime: the transport's services plus `SecureRandom` for
+ * input ids, e.g. `Atom.runtime(Layer.mergeAll(FetchHttpClient.layer,
+ * SecureRandom.layerWebCrypto))`. A test provides a seeded one.
+ */
+export type Runtime<R, ER> = Atom.AtomRuntime<R | SecureRandom.SecureRandom, ER>
+
+/** Turns a wire envelope into what `step` folds (a contract's `decode`). */
+export type Decode<D> = (envelope: Envelope) => Effect.Effect<D, Schema.SchemaError>
+
+// `decode` may be left out only when `step` folds wire envelopes.
+type WithDecode<D> = [Envelope] extends [D]
+  ? { readonly decode?: Decode<D> }
+  : { readonly decode: Decode<D> }
+
+/**
+ * `I` is the app's input type. `submit` takes a draft of it (`id` optional);
+ * the transport receives it with the id assigned (`Input.Sent<I>`, a UUIDv7
+ * from `SecureRandom`). `D` is the envelope `step` folds: the wire envelope,
+ * or a contract's decoded one (then pass `decode`).
+ */
+type BaseOptions<I, S, E, R, ER, D> = {
+  readonly runtime: Runtime<R, ER>
+  readonly transport: Transport.Transport<Input.Sent<I>, S, E, R>
+  readonly initial: S
+  readonly step: (state: S, envelope: D) => S
+  readonly busy: Busy
+  readonly isBusy?: (state: S) => boolean
+  /** Optimistic update applied before the request goes out. */
+  readonly submitted?: (state: S, input: Input.Sent<I>) => S
+  /** Applied when a run's stream ends without its terminal. */
+  readonly ended?: (state: S, reason: "stopped" | "disconnected") => S
+}
+
+export type Options<I, S, E, R, ER, D = Envelope> = BaseOptions<I, S, E, R, ER, D> & WithDecode<D>
+
+const identity: Decode<Envelope> = Effect.succeed
+
+const build = <I, S, E, R, ER, D>(
+  options: BaseOptions<I, S, E, R, ER, D> & { readonly decode: Decode<D> },
+) => {
+  const state = Atom.make(options.initial).pipe(Atom.keepAlive)
+  const streamId = Atom.make<StreamId | null>(null).pipe(Atom.keepAlive)
+
+  const follow = (envelopes: Stream.Stream<Envelope, E, R>) =>
+    envelopes.pipe(
+      Stream.runForEach((envelope) =>
+        options
+          .decode(envelope)
+          .pipe(
+            Effect.flatMap((decoded) =>
+              Atom.set(streamId, envelope.streamId).pipe(
+                Effect.andThen(Atom.update(state, (s) => options.step(s, decoded))),
+              ),
+            ),
+          ),
+      ),
+      Effect.onExit((exit) => {
+        const ended = options.ended
+        if (Exit.isSuccess(exit) || ended === undefined) return Effect.void
+        const reason = Exit.hasInterrupts(exit) ? "stopped" : "disconnected"
+        return Atom.update(state, (s) => ended(s, reason))
+      }),
+    )
+
+  // Writing to a non-concurrent `Atom.fn` interrupts its previous run, so the
+  // streaming lives in `run` and `submit` is a concurrent gate that applies
+  // the busy policy before anything is interrupted. Every fn atom is kept
+  // alive: an unobserved one is disposed, which interrupts its fiber.
+  const run = options.runtime
+    .fn<Input.Sent<I>>()((input) =>
+      Effect.gen(function* () {
+        const submitted = options.submitted
+        if (submitted !== undefined) yield* Atom.update(state, (s) => submitted(s, input))
+        yield* follow(options.transport.start(input, yield* Atom.get(state)))
+      }),
+    )
+    .pipe(Atom.keepAlive)
+
+  const submit = options.runtime
+    .fn<Input.Draft<I>>()(
+      (draft) =>
+        Effect.gen(function* () {
+          const blocked =
+            options.busy === "block" && options.isBusy?.(yield* Atom.get(state)) === true
+          if (blocked) return
+          const input = yield* Input.withId(draft)
+          yield* Atom.set(run, input)
+        }),
+      { concurrent: true },
+    )
+    .pipe(Atom.keepAlive)
+
+  // Durable: ask the server (its `run-stopped` arrives on the stream).
+  // Direct: interrupt the request; `ended` settles the run locally.
+  const stop = options.runtime
+    .fn<void>()(() =>
+      Effect.gen(function* () {
+        const id = yield* Atom.get(streamId)
+        const serverStop = options.transport.stop
+        if (serverStop !== undefined && id !== null) return yield* serverStop(id)
+        yield* Atom.set(run, Atom.Interrupt)
+      }),
+    )
+    .pipe(Atom.keepAlive)
+
+  const resume = options.transport.resume
+  const attach =
+    resume === undefined
+      ? undefined
+      : options.runtime
+          .fn<{ readonly streamId: StreamId; readonly after: number }>()((arg) =>
+            follow(resume(arg.streamId, arg.after)),
+          )
+          .pipe(Atom.keepAlive)
+
+  return {
+    state,
+    streamId,
+    submit,
+    /** The current run; `AtomRegistry.getResult` on it waits for the run to finish. */
+    run,
+    stop,
+    /** Re-attach to a run (`{ streamId, after }`); set for durable transports. */
+    resume: attach,
+  }
+}
+
+type Built<I, S, E, R, ER> = ReturnType<typeof build<I, S, E, R, ER, unknown>>
+
+/**
+ * State over a per-run transport: `state`, `submit`, `stop`, `run`, and
+ * `resume` when the transport can re-attach (`Transport.durable`,
+ * `durableHttp`), typed as present for those.
+ */
+export function make<I, S, E, R, ER, D = Envelope>(
+  options: Options<I, S, E, R, ER, D> & {
+    readonly transport: Transport.Durable<Input.Sent<I>, S, E, R>
+  },
+): Omit<Built<I, S, E, R, ER>, "resume"> & {
+  readonly resume: NonNullable<Built<I, S, E, R, ER>["resume"]>
+}
+export function make<I, S, E, R, ER, D = Envelope>(
+  options: Options<I, S, E, R, ER, D>,
+): Built<I, S, E, R, ER>
+export function make<I, S, E, R, ER>(
+  options: Options<I, S, E, R, ER, Envelope>,
+): Built<I, S, E, R, ER> {
+  return build({ ...options, decode: options.decode ?? identity })
+}
+
+type ThreadOptions<I, E, R, ER, P extends Payloads> = {
+  readonly runtime: Runtime<R, ER>
+  readonly transport: Transport.Transport<Input.Sent<I>, Thread.Thread<P>, E, R>
+  readonly busy: Busy
+  readonly initial?: Thread.Thread<P>
+}
+
+/**
+ * `make` with the `Thread` preset: a message list plus the active run. Takes
+ * the `Input` preset, with or without typed `data`. With `contract`, the
+ * state is typed by it. For other entry types, spread a `Thread.make(config)`
+ * fold into `make`.
+ */
+export function thread<I extends Input.Input, E, R, ER, P extends Payloads>(
+  options: ThreadOptions<I, E, R, ER, P> & { readonly contract: UiContract<P> },
+): Built<I, Thread.Thread<P>, E, R, ER>
+export function thread<I extends Input.Input, E, R, ER>(
+  options: ThreadOptions<I, E, R, ER, Untyped>,
+): Built<I, Thread.Thread, E, R, ER>
+// The implementation sees `P` as `any`: the options both read and receive
+// `Thread<P>`, so no single `P` fits both overloads. Callers get the overloads.
+export function thread<I extends Input.Input, E, R, ER>(
+  options: ThreadOptions<I, E, R, ER, any> & { readonly contract?: UiContract<any> },
+): Built<I, Thread.Thread<any>, E, R, ER> {
+  const fold = Thread.presetFor<any>()
+  return build({
+    runtime: options.runtime,
+    transport: options.transport,
+    busy: options.busy,
+    initial: options.initial ?? fold.initial,
+    step: fold.step,
+    decode: options.contract?.decode ?? identity,
+    isBusy: (t) => t.active !== null,
+    submitted: (t, input: Input.Sent<I>) => fold.submitted(t, input),
+    ended: fold.ended,
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Sessions: one stream carries every run (a durable chat)
+// ---------------------------------------------------------------------------
+
+type BaseSessionOptions<I, S, E, R, ER, D> = {
+  readonly runtime: Runtime<R, ER>
+  readonly transport: Transport.Session<Input.Sent<I>, S, E, R>
+  readonly initial: S
+  readonly step: (state: S, envelope: D) => S
+  /** While true, `submit` ignores new input (the server may also refuse). */
+  readonly isBusy?: (state: S) => boolean
+  /** Optimistic update applied before the input is sent. */
+  readonly submitted?: (state: S, input: Input.Sent<I>) => S
+  /** Applied when sending fails or the session's stream gives up. */
+  readonly ended?: (state: S, reason: "stopped" | "disconnected") => S
+}
+
+export type SessionOptions<I, S, E, R, ER, D = Envelope> = BaseSessionOptions<I, S, E, R, ER, D> &
+  WithDecode<D>
+
+const buildSession = <I, S, E, R, ER, D>(
+  options: BaseSessionOptions<I, S, E, R, ER, D> & { readonly decode: Decode<D> },
+) => {
+  const state = Atom.make(options.initial).pipe(Atom.keepAlive)
+  const streamId = Atom.make<StreamId | null>(null).pipe(Atom.keepAlive)
+
+  const settle = (exit: Exit.Exit<unknown, unknown>) => {
+    const ended = options.ended
+    return ended === undefined || Exit.isSuccess(exit) || Exit.hasInterrupts(exit)
+      ? Effect.void
+      : Atom.update(state, (s) => ended(s, "disconnected"))
+  }
+
+  // Non-concurrent: opening another session stops following the previous one.
+  const open = options.runtime
+    .fn<StreamId>()((id) =>
+      Atom.set(streamId, id).pipe(
+        Effect.andThen(
+          options.transport
+            .events(id, 0)
+            .pipe(
+              Stream.runForEach((envelope) =>
+                options
+                  .decode(envelope)
+                  .pipe(
+                    Effect.flatMap((decoded) =>
+                      Atom.update(state, (s) => options.step(s, decoded)),
+                    ),
+                  ),
+              ),
+            ),
+        ),
+        Effect.onExit(settle),
+      ),
+    )
+    .pipe(Atom.keepAlive)
+
+  const submit = options.runtime
+    .fn<Input.Draft<I>>()(
+      (draft) =>
+        Effect.gen(function* () {
+          if (options.isBusy?.(yield* Atom.get(state)) === true) return
+          const input = yield* Input.withId(draft)
+          const submitted = options.submitted
+          if (submitted !== undefined) yield* Atom.update(state, (s) => submitted(s, input))
+          const opened = Option.fromNullishOr(yield* Atom.get(streamId))
+          const sent = yield* options.transport.send(opened, input, yield* Atom.get(state))
+          if (Option.isNone(opened)) yield* Atom.set(open, sent)
+        }).pipe(Effect.onExit(settle)),
+      { concurrent: true },
+    )
+    .pipe(Atom.keepAlive)
+
+  // The server stops the active run; its `run-stopped` arrives on the stream.
+  const stop = options.runtime
+    .fn<void>()(() =>
+      Effect.gen(function* () {
+        const id = yield* Atom.get(streamId)
+        const serverStop = options.transport.stop
+        if (serverStop !== undefined && id !== null) yield* serverStop(id)
+      }),
+    )
+    .pipe(Atom.keepAlive)
+
+  return { state, streamId, open, submit, stop }
+}
+
+type BuiltSession<I, S, E, R, ER> = ReturnType<typeof buildSession<I, S, E, R, ER, unknown>>
+
+/**
+ * State over a session transport. `open(streamId)` follows a session's
+ * stream from its start (e.g. a chat id kept across reloads). `submit` sends
+ * an input; without an open session the server starts one, which is then
+ * opened. Runs arrive on the followed stream, not as responses to `submit`.
+ */
+export function session<I, S, E, R, ER, D = Envelope>(
+  options: SessionOptions<I, S, E, R, ER, D>,
+): BuiltSession<I, S, E, R, ER>
+export function session<I, S, E, R, ER>(
+  options: SessionOptions<I, S, E, R, ER, Envelope>,
+): BuiltSession<I, S, E, R, ER> {
+  return buildSession({ ...options, decode: options.decode ?? identity })
+}
+
+type SessionThreadOptions<I, E, R, ER, P extends Payloads> = {
+  readonly runtime: Runtime<R, ER>
+  readonly transport: Transport.Session<Input.Sent<I>, Thread.Thread<P>, E, R>
+  readonly isBusy?: (thread: Thread.Thread<P>) => boolean
+}
+
+/**
+ * `session` with the `Thread` preset. Input sent while a run is active, or
+ * echoed by the server (`input-accepted`), waits in `thread.pending`: the
+ * server queues it. Pass `isBusy` for a server that refuses instead. With
+ * `contract`, the state is typed by it. For other entry types, spread a
+ * `Thread.make(config)` fold into `session`.
+ */
+export function sessionThread<I extends Input.Input, E, R, ER, P extends Payloads>(
+  options: SessionThreadOptions<I, E, R, ER, P> & { readonly contract: UiContract<P> },
+): BuiltSession<I, Thread.Thread<P>, E, R, ER>
+export function sessionThread<I extends Input.Input, E, R, ER>(
+  options: SessionThreadOptions<I, E, R, ER, Untyped>,
+): BuiltSession<I, Thread.Thread, E, R, ER>
+// `any` for `P` in the implementation only, as in `thread`.
+export function sessionThread<I extends Input.Input, E, R, ER>(
+  options: SessionThreadOptions<I, E, R, ER, any> & { readonly contract?: UiContract<any> },
+): BuiltSession<I, Thread.Thread<any>, E, R, ER> {
+  const fold = Thread.presetFor<any>()
+  return buildSession({
+    runtime: options.runtime,
+    transport: options.transport,
+    initial: fold.initial,
+    step: fold.step,
+    decode: options.contract?.decode ?? identity,
+    ...(options.isBusy !== undefined ? { isBusy: options.isBusy } : {}),
+    submitted: (t, input: Input.Sent<I>) => fold.submitted(t, input),
+    ended: fold.ended,
+  })
+}

package/src/Client.test.ts

@@ -0,0 +1,53 @@
+import { describe, it } from "@effect/vitest"
+import { Data, Effect, Ref, Schedule, Stream } from "effect"
+import { expect } from "vitest"
+import * as Client from "./Client.js"
+import { type Envelope, RunId, type RunEvent, StreamId } from "./RunEvent.js"
+
+const r1 = RunId.make("r1")
+
+class Dropped extends Data.TaggedError("Dropped")<{}> {}
+
+const frames: ReadonlyArray<Envelope> = (
+  [
+    { type: "run-started", runId: r1, inputs: [], protocol: 2 },
+    { type: "text-delta", text: "a" },
+    { type: "text-delta", text: "b" },
+    { type: "text-delta", text: "c" },
+    { type: "run-completed" },
+  ] satisfies ReadonlyArray<RunEvent>
+).map((event, i) => ({ streamId: StreamId.make("s"), seq: i + 1, runId: r1, event }))
+
+// A server that replays from `after`; how each connection ends is scripted.
+const server = (endings: ReadonlyArray<{ readonly upTo: number; readonly fails: boolean }>) =>
+  Effect.gen(function* () {
+    const calls = yield* Ref.make<ReadonlyArray<number>>([])
+    const connect = (after: number) =>
+      Stream.unwrap(
+        Ref.modify(calls, (cs) => [cs.length, [...cs, after]]).pipe(
+          Effect.map((attempt) => {
+            const ending = endings[attempt] ?? { upTo: frames.length, fails: false }
+            // Re-sends one frame it already delivered, as real servers may.
+            const sent = Stream.fromIterable(frames.slice(Math.max(0, after - 1), ending.upTo))
+            return ending.fails ? sent.pipe(Stream.concat(Stream.fail(new Dropped()))) : sent
+          }),
+        ),
+      )
+    return { calls, connect }
+  })
+
+describe("Client.resumable", () => {
+  it.effect.each([
+    { label: "a failed connection", fails: true },
+    { label: "a connection that closes before the terminal", fails: false },
+  ])("resumes after $label from the last seq, without duplicates", ({ fails }) =>
+    Effect.gen(function* () {
+      const { calls, connect } = yield* server([{ upTo: 2, fails }])
+      const received = yield* Client.resumable(connect, { schedule: Schedule.recurs(3) }).pipe(
+        Stream.runCollect,
+      )
+      expect(received.map((e) => e.seq)).toEqual([1, 2, 3, 4, 5])
+      expect(yield* Ref.get(calls)).toEqual([0, 2])
+    }),
+  )
+})

package/src/Client.ts

@@ -0,0 +1,92 @@
+/**
+ * Browser-safe sources of envelopes. Every source yields
+ * `Stream<Envelope>`; `resumable` adds reconnect-from-last-seq on top of
+ * any of them. HTTP goes through `effect/http`'s `HttpClient`, so a browser
+ * provides `FetchHttpClient.layer` and tests provide a fake client.
+ */
+import { Data, Effect, Ref, type Schedule, type Schema, Stream } from "effect"
+import { Ndjson, type Sse } from "effect/encoding"
+import { HttpClient, type HttpClientError, type HttpClientRequest } from "effect/http"
+import { type Envelope, EnvelopeJson, isTerminal } from "./RunEvent.js"
+import * as SseEncoding from "./SseEncoding.js"
+
+/** The connection ended before the run's terminal event arrived. */
+export class Disconnected extends Data.TaggedError("Disconnected")<{ readonly lastSeq: number }> {}
+
+/** What an HTTP source can fail with: transport, a malformed SSE frame, or a malformed NDJSON line. */
+export type ClientError =
+  | HttpClientError.HttpClientError
+  | Schema.SchemaError
+  | Sse.Retry
+  | Sse.SseError
+  | Ndjson.NdjsonError
+
+/** Run a request, failing on a non-2xx status. */
+export const execute = (request: HttpClientRequest.HttpClientRequest) =>
+  HttpClient.HttpClient.pipe(
+    Effect.flatMap((client) => HttpClient.filterStatusOk(client).execute(request)),
+  )
+
+const body = (request: HttpClientRequest.HttpClientRequest) =>
+  Stream.unwrap(Effect.map(execute(request), (response) => response.stream))
+
+/** An SSE response (`text/event-stream`) as envelopes. */
+export const sse = (request: HttpClientRequest.HttpClientRequest) =>
+  body(request).pipe(SseEncoding.decode)
+
+/** An NDJSON response (one envelope per line) as envelopes. */
+export const ndjson = (request: HttpClientRequest.HttpClientRequest) =>
+  body(request).pipe(Stream.pipeThroughChannelOrFail(Ndjson.decodeSchema(EnvelopeJson)()))
+
+/**
+ * Keep events flowing across dropped connections: `connect(after)` is
+ * re-invoked with the last seen `seq` on failure, per `schedule`; duplicates
+ * are dropped. A connection that ends cleanly before the end counts as a
+ * failure (`Disconnected`), so it is retried too.
+ *
+ * `until: "terminal"` (default) follows one run and completes after its
+ * terminal. `until: "never"` follows a session stream that carries many runs
+ * (a durable chat) and never completes on its own.
+ */
+export const resumable = <E, R, X>(
+  connect: (after: number) => Stream.Stream<Envelope, E, R>,
+  options: {
+    readonly from?: number
+    readonly until?: "terminal" | "never"
+    readonly schedule: Schedule.Schedule<X, E | Disconnected>
+  },
+): Stream.Stream<Envelope, E | Disconnected, R> =>
+  Stream.unwrap(
+    Effect.gen(function* () {
+      const untilTerminal = options.until !== "never"
+      const ends = (envelope: Envelope) => untilTerminal && isTerminal(envelope.event)
+      // The last seen seq, and whether the run's terminal arrived.
+      const position = yield* Ref.make({ seq: options.from ?? 0, done: false })
+      const attempt = Stream.unwrap(
+        Ref.get(position).pipe(
+          Effect.map(({ seq: after }) =>
+            connect(after).pipe(
+              Stream.filterEffect((envelope) =>
+                Ref.modify(position, (p) =>
+                  envelope.seq > p.seq
+                    ? [true, { seq: envelope.seq, done: ends(envelope) }]
+                    : [false, p],
+                ),
+              ),
+              Stream.takeUntil(ends),
+              Stream.concat(
+                Stream.unwrap(
+                  Ref.get(position).pipe(
+                    Effect.map((p) =>
+                      p.done ? Stream.empty : Stream.fail(new Disconnected({ lastSeq: p.seq })),
+                    ),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+      )
+      return attempt.pipe(Stream.retry(options.schedule))
+    }),
+  )

package/src/Input.test.ts

@@ -0,0 +1,68 @@
+import * as ToolDecision from "@effect-uai/core/ToolDecision"
+import * as Image from "@effect-uai/core/Image"
+import { describe, it } from "@effect/vitest"
+import { Effect, Exit, Schema } from "effect"
+import { expect } from "vitest"
+import * as Input from "./Input.js"
+import { InputId } from "./RunEvent.js"
+
+const ChatInput = Input.make(Schema.Struct({ templateId: Schema.String }))
+const Body = Schema.fromJsonString(ChatInput.InputJson)
+
+describe("Input wire codec", () => {
+  it.effect("carries image bytes and typed data through a JSON body", () =>
+    Effect.gen(function* () {
+      const draft = Input.submit(
+        [
+          Input.user("What is in this picture?", [
+            {
+              type: "input_image",
+              source: Image.imageBytes(new Uint8Array([1, 2, 3]), "image/png"),
+            },
+          ]),
+          Input.user("Answer in one sentence."),
+        ],
+        { data: { templateId: "describe" } },
+      )
+      const input = { ...draft, id: InputId.make("in_1") }
+      const body = yield* Schema.encodeEffect(Body)(input)
+      expect(yield* Schema.decodeUnknownEffect(Body)(body)).toEqual(input)
+    }),
+  )
+
+  it.effect("rejects a submit whose data does not match the app schema", () =>
+    Effect.gen(function* () {
+      const body = JSON.stringify({ ...Input.submit("Hi"), data: { templateId: 42 } })
+      const exit = yield* Effect.exit(Schema.decodeUnknownEffect(Body)(body))
+      expect(Exit.isFailure(exit)).toBe(true)
+    }),
+  )
+
+  it.effect("carries the app's own decisions and rejects one it doesn't define", () =>
+    Effect.gen(function* () {
+      const Decisions = ToolDecision.make({
+        Approve: { always: Schema.optionalKey(Schema.Boolean) },
+        Respond: { output: Schema.Json },
+      })
+      const Booking = Input.make(Schema.Struct({}), Decisions.schema)
+      const Resolve = Schema.fromJsonString(Booking.InputJson)
+      const input = {
+        ...Input.resolve([
+          { callId: "c1", decision: Decisions.Approve({ always: true }) },
+          { callId: "c2", decision: Decisions.Respond({ output: { booked: true } }) },
+        ]),
+        id: InputId.make("in_1"),
+      }
+      const body = yield* Schema.encodeEffect(Resolve)(input)
+      expect(yield* Schema.decodeUnknownEffect(Resolve)(body)).toEqual(input)
+
+      const denied = JSON.stringify({
+        ...input,
+        decisions: [{ callId: "c1", decision: { _tag: "Deny" } }],
+      })
+      expect(Exit.isFailure(yield* Effect.exit(Schema.decodeUnknownEffect(Resolve)(denied)))).toBe(
+        true,
+      )
+    }),
+  )
+})