liminal 0.17.15 → 0.17.17

package/Actor.ts

@@ -1,14 +1,11 @@
 import { Context, Schema as S, Effect } from "effect"
-import * as Spanner from "liminal-util/Spanner"
+import * as Boundary from "liminal-util/Boundary"
+import type { TopFromString } from "liminal-util/schema"
 
-import type { TopFromString } from "./_util/schema.ts"
 import type * as ActorClient from "./Client.ts"
 import type { ClientHandle, Sender } from "./ClientHandle.ts"
-import * as Method from "./Method.ts"
 import { type ProtocolDefinition } from "./Protocol.ts"
 
-const span = Spanner.make(import.meta.url)
-
 export const TypeId = "~liminal/Actor" as const
 
 export interface Service<
@@ -53,14 +50,9 @@ export interface Actor<
 
   readonly definition: ActorDefinition<Name, AttachmentFields, ActorClientSelf, ActorClientId, D>
 
-  readonly all: Sender<ActorSelf, D>
-
-  readonly others: Sender<ActorSelf, D>
+  readonly all: Sender<D, ActorSelf>
 
-  readonly handler: <K extends keyof D["external"], R>(
-    tag: K,
-    f: Method.Handler<D["external"][K], R>,
-  ) => Method.Handler<D["external"][K], R>
+  readonly others: Sender<D, ActorSelf>
 }
 
 export const Service =
@@ -78,45 +70,42 @@ export const Service =
   ): Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D> => {
     const tag = Context.Service<ActorSelf, Service<ActorSelf, Name, AttachmentFields, D>>()(id)
 
-    const all: Sender<ActorSelf, D> = {
+    const all: Sender<D, ActorSelf> = {
       send: (key, payload) =>
-        tag.asEffect().pipe(
+        tag.pipe(
           Effect.flatMap(({ clients }) =>
             Effect.forEach(clients, (client) => client.send(key, payload), { concurrency: "unbounded" }),
           ),
-          span("send-all"),
+          Boundary.span("send-all", import.meta.url),
         ),
-      disconnect: tag.asEffect().pipe(
+      disconnect: tag.pipe(
         Effect.flatMap(({ clients }) => Effect.forEach(clients, ({ disconnect }) => disconnect)),
-        span("disconnect-all"),
+        Boundary.span("disconnect-all", import.meta.url),
       ),
     }
 
-    const others: Sender<ActorSelf, D> = {
-      send: Effect.fnUntraced(function* (key, payload) {
-        const { clients, currentClient } = yield* tag
-        yield* Effect.forEach(
-          clients,
-          (client) => (client === currentClient ? Effect.void : client.send(key, payload)),
-          { concurrency: "unbounded" },
-        )
-      }, span("send-others")),
+    const others: Sender<D, ActorSelf> = {
+      send: Effect.fnUntraced(
+        function* (key, payload) {
+          const { clients, currentClient } = yield* tag
+          yield* Effect.forEach(
+            clients,
+            (client) => (client === currentClient ? Effect.void : client.send(key, payload)),
+            { concurrency: "unbounded" },
+          )
+        },
+        Boundary.span("send-others", import.meta.url),
+      ),
       disconnect: Effect.gen(function* () {
         const { clients, currentClient } = yield* tag
         yield* Effect.forEach(clients, (client) => (client === currentClient ? Effect.void : client.disconnect))
-      }).pipe(span("disconnect-others")),
+      }).pipe(Boundary.span("disconnect-others", import.meta.url)),
     }
 
-    const handler = <K extends keyof D["external"], R>(
-      _tag: K,
-      f: Method.Handler<D["external"][K], R>,
-    ): Method.Handler<D["external"][K], R> => f
-
     return Object.assign(tag, {
       [TypeId]: TypeId,
       definition,
       all,
       others,
-      handler,
     })
   }

package/{workerd/ActorHandle.ts → ActorHandle.ts}

@@ -1,15 +1,18 @@
 import { Schema as S, Effect, Cause, Encoding } from "effect"
 import { NativeRequest } from "effect-workerd"
 import { HttpServerResponse } from "effect/unstable/http"
+import type { TopFromString } from "liminal-util/schema"
 
-import type { TopFromString } from "../_util/schema.ts"
-import type { Methods } from "../Method.ts"
+import type { Send } from "./ClientHandle.ts"
+import type { Methods } from "./Method.ts"
+import type { ProtocolDefinition } from "./Protocol.ts"
 
 export interface ActorHandle<
   NamespaceSelf,
   Internal extends Methods,
   Name extends TopFromString,
   AttachmentFields extends S.Struct.Fields,
+  D extends ProtocolDefinition,
 > {
   readonly upgrade: (
     attachments: S.Struct<AttachmentFields>["Type"],
@@ -26,4 +29,6 @@ export interface ActorHandle<
     method: K,
     payload: M["payload"]["Type"],
   ) => Effect.Effect<M["success"]["Type"], M["failure"]["Type"], NamespaceSelf>
+
+  readonly proxySendAll: Send<D, NamespaceSelf>
 }

package/{workerd/WorkerdActorNamespace.ts → ActorNamespace.ts}

@@ -1,16 +1,14 @@
 import { Layer, Effect, Schema as S, Context, flow, String, Array, Encoding, Exit } from "effect"
-import { Binding, NativeRequest } from "effect-workerd"
+import { Binding, Env, NativeRequest } from "effect-workerd"
 import { SecWebSocketProtocol, close } from "effect-workerd/socket_util"
 import { HttpServerResponse, HttpTraceContext } from "effect/unstable/http"
-import * as Spanner from "liminal-util/Spanner"
+import * as Boundary from "liminal-util/Boundary"
+import { type TopFromString, encodeJsonString } from "liminal-util/schema"
 
-import { type TopFromString, encodeJsonString } from "../_util/schema.ts"
-import type { Actor } from "../Actor.ts"
-import type { Methods } from "../Method.ts"
-import type { ProtocolDefinition } from "../Protocol.ts"
+import type { Actor } from "./Actor.ts"
 import type { ActorHandle } from "./ActorHandle.ts"
-
-const span = Spanner.make(import.meta.url)
+import type { Methods } from "./Method.ts"
+import type { ProtocolDefinition } from "./Protocol.ts"
 
 export interface ActorNamespaceDefinition<
   Internal extends Methods,
@@ -45,7 +43,7 @@ export interface ActorNamespace<
     _: never,
   ): Context.ServiceClass.Shape<
     NamespaceId,
-    DurableObjectNamespace<Rpc.DurableObjectBranded & WorkerdActorNamespace.MakeRpc<Internal>>
+    DurableObjectNamespace<Rpc.DurableObjectBranded & ActorNamespace.MakeRpc<Internal, D>>
   >
 
   readonly definition: ActorNamespaceDefinition<
@@ -59,17 +57,19 @@ export interface ActorNamespace<
     D
   >
 
-  readonly bind: (name: Name["Type"]) => ActorHandle<NamespaceSelf, Internal, Name, AttachmentFields>
+  readonly bind: (name: Name["Type"]) => ActorHandle<NamespaceSelf, Internal, Name, AttachmentFields, D>
 
-  readonly layer: Layer.Layer<NamespaceSelf, S.SchemaError, never>
+  readonly layer: Layer.Layer<NamespaceSelf, S.SchemaError, Env>
 }
 
-export declare namespace WorkerdActorNamespace {
-  export type MakeRpc<External extends Methods> = {
-    rpc: <K extends keyof External>(
+export declare namespace ActorNamespace {
+  export type MakeRpc<Internal extends Methods, D extends ProtocolDefinition> = {
+    rpc: <K extends keyof Internal>(
       method: K,
-      payload: External[K]["payload"]["Type"],
-    ) => Promise<Exit.Exit<External[K]["success"]["Type"], External[K]["failure"]["Type"]>>
+      payload: Internal[K]["payload"]["Type"],
+    ) => Promise<Exit.Exit<Internal[K]["success"]["Type"], Internal[K]["failure"]["Type"]>>
+
+    proxySendAll<K extends keyof D["events"]>(event: K, payload: S.Struct<D["events"][K]>["Type"]): void
   }
 }
 
@@ -111,7 +111,7 @@ export const Service =
 
     const tag = Context.Service<
       NamespaceSelf,
-      DurableObjectNamespace<Rpc.DurableObjectBranded & WorkerdActorNamespace.MakeRpc<Internal>>
+      DurableObjectNamespace<Rpc.DurableObjectBranded & ActorNamespace.MakeRpc<Internal, D>>
     >()(id)
 
     const encodeName = S.encodeEffect(Name)
@@ -119,7 +119,7 @@ export const Service =
     const encodeAttachmentsString = encodeJsonString(Attachments)
     const encodeAuditionFailure = encodeJsonString(P.Audition.Failure)
 
-    const bind = (name: Name["Type"]): ActorHandle<NamespaceSelf, Internal, Name, AttachmentFields> => {
+    const bind = (name: Name["Type"]): ActorHandle<NamespaceSelf, Internal, Name, AttachmentFields, D> => {
       const getStub = Effect.gen(function* () {
         const namespace = yield* tag
         const nameEncoded = yield* encodeName(name)
@@ -132,9 +132,10 @@ export const Service =
           const protocols = yield* Effect.fromNullishOr(request.headers.get(SecWebSocketProtocol)).pipe(
             Effect.map(flow(String.split(","), Array.map(String.trim))),
           )
-          const liminalTokenI = yield* Array.findFirstIndex(protocols, (v) => v === "liminal")
-          const requestClientId = yield* Effect.fromNullishOr(protocols[liminalTokenI + 1]).pipe(
-            Effect.flatMap((v) => Encoding.decodeBase64UrlString(v).asEffect()),
+          const liminalTokenI = yield* Array.findFirstIndex(protocols, (v) => v === "liminal").pipe(Effect.fromOption)
+          const liminalClientId = yield* Effect.fromNullishOr(protocols[liminalTokenI + 1])
+          const requestClientId = yield* Effect.fromNullishOr(protocols[liminalTokenI + 2]).pipe(
+            Effect.flatMap((v) => Encoding.decodeBase64UrlString(v).pipe(Effect.fromResult)),
           )
           if (requestClientId !== clientId) {
             return close(
@@ -147,6 +148,7 @@ export const Service =
           }
           const url = new URL(request.url)
           url.searchParams.set("__liminal_attachments", yield* encodeAttachmentsString(attachments))
+          url.searchParams.set("__liminal_client_id", liminalClientId)
           const actorRequest = new Request(url, request)
           const traceHeaders = yield* Effect.currentSpan.pipe(Effect.map(HttpTraceContext.toHeaders))
           for (const [key, value] of Object.entries(traceHeaders)) {
@@ -154,18 +156,30 @@ export const Service =
           }
           const stub = yield* getStub
           return yield* Effect.promise(() => stub.fetch(actorRequest)).pipe(Effect.map(HttpServerResponse.raw))
-        }).pipe(span("upgrade", { kind: "client" }))
-
-      const call = Effect.fnUntraced(function* <K extends keyof Internal, M extends Internal[K]>(
-        method: K,
-        payload: M["payload"]["Type"],
-      ): Effect.fn.Return<M["success"]["Type"], M["failure"]["Type"], NamespaceSelf> {
-        const stub = yield* getStub
-        const exit = yield* Effect.promise(() => stub.rpc(method as never, payload as never))
-        return yield* exit as any
-      })
+        }).pipe(Boundary.span("upgrade", import.meta.url, { kind: "client" }))
+
+      const call = Effect.fnUntraced(
+        function* <K extends keyof Internal, M extends Internal[K]>(
+          method: K,
+          payload: M["payload"]["Type"],
+        ): Effect.fn.Return<M["success"]["Type"], M["failure"]["Type"], NamespaceSelf> {
+          const stub = yield* getStub
+          const exit = yield* Effect.promise(() => stub.rpc(method as never, payload as never))
+          return yield* exit as any
+        },
+        Boundary.span("call", import.meta.url),
+      )
+
+      // TODO:
+      const proxySendAll = Effect.fnUntraced(
+        function* <K extends keyof D["events"]>(event: K, payload: S.Struct<D["events"][K]>["Type"]) {
+          const stub = yield* getStub
+          yield* Effect.promise(() => stub.proxySendAll(event as never, payload as never))
+        },
+        Boundary.span("proxySendAll", import.meta.url),
+      ) as never
 
-      return { upgrade, call }
+      return { upgrade, call, proxySendAll }
     }
 
     const layer = Binding.layer(tag, ["idFromName", "idFromString", "newUniqueId", "get", "getByName"])(binding)

package/{workerd/WorkerdActorRuntime.ts → ActorRuntime.ts}

@@ -15,24 +15,21 @@ import {
   Exit,
 } from "effect"
 import { DoState } from "effect-workerd"
+import { Env } from "effect-workerd"
 import { Clock } from "effect-workerd/platform"
 import { SecWebSocketProtocol } from "effect-workerd/socket_util"
 import { Headers, FetchHttpClient, HttpClient, HttpTraceContext } from "effect/unstable/http"
-import { boundLayer } from "liminal-util/boundLayer"
-import { logCause } from "liminal-util/logCause"
-import * as Spanner from "liminal-util/Spanner"
+import * as Boundary from "liminal-util/Boundary"
+import { type TopFromString, encodeJsonString, decodeJsonString } from "liminal-util/schema"
 
-import { type TopFromString, encodeJsonString, decodeJsonString } from "../_util/schema.ts"
-import type { ActorTransport } from "../ActorTransport.ts"
-import * as ClientDirectory from "../ClientDirectory.ts"
-import type { ClientHandle } from "../ClientHandle.ts"
-import type { Handlers, Methods } from "../Method.ts"
-import type { ProtocolDefinition } from "../Protocol.ts"
-import * as Tracing from "../Tracing.ts"
-import { sessionAttributes, SessionId, sessionLink } from "../Tracing.ts"
-import type { ActorNamespace } from "./WorkerdActorNamespace.ts"
-
-const span = Spanner.make(import.meta.url)
+import type { ActorNamespace } from "./ActorNamespace.ts"
+import type { ActorTransport } from "./ActorTransport.ts"
+import * as ClientDirectory from "./ClientDirectory.ts"
+import type { ClientHandle } from "./ClientHandle.ts"
+import type { Handlers, Methods } from "./Method.ts"
+import type { ProtocolDefinition } from "./Protocol.ts"
+import * as Tracing from "./Tracing.ts"
+import { sessionAttributes, SessionId, sessionLink } from "./Tracing.ts"
 
 export interface ActorRuntimeDefinition<
   NamespaceSelf,
@@ -76,25 +73,28 @@ export interface ActorRuntimeDefinition<
     | Name["EncodingServices"]
     | Name["DecodingServices"],
     PreludeE,
-    HttpClient.HttpClient
+    HttpClient.HttpClient | Env
   >
 
-  readonly layer: Layer.Layer<RunROut, RunE, ActorSelf | HttpClient.HttpClient | PreludeROut>
+  readonly layer: Layer.Layer<RunROut, RunE, ActorSelf | HttpClient.HttpClient | Env | PreludeROut>
 
-  readonly external: Handlers<D["external"], ActorSelf | HttpClient.HttpClient | PreludeROut | RunROut | Scope.Scope>
+  readonly external: Handlers<
+    D["external"],
+    ActorSelf | HttpClient.HttpClient | Env | PreludeROut | RunROut | Scope.Scope
+  >
 
   readonly internal: Handlers<Internal, ActorSelf | HttpClient.HttpClient | PreludeROut | RunROut | Scope.Scope>
 
   readonly hydrate: Effect.Effect<
     S.Struct<D["state"]>["Type"],
     never,
-    ActorSelf | HttpClient.HttpClient | PreludeROut | RunROut | Scope.Scope
+    ActorSelf | HttpClient.HttpClient | Env | PreludeROut | RunROut | Scope.Scope
   >
 
   readonly onDisconnect: Effect.Effect<
     void,
     never,
-    ActorSelf | HttpClient.HttpClient | PreludeROut | RunROut | Scope.Scope
+    ActorSelf | HttpClient.HttpClient | Env | PreludeROut | RunROut | Scope.Scope
   >
 
   readonly hibernation?: Duration.Input | undefined
@@ -181,17 +181,18 @@ export const make = <
       const { _tag } = event.event as never
       return Effect.gen(function* () {
         const trace = yield* Tracing.currentTrace
-        const encoded = yield* encodeEvent({
-          ...event,
-          ...(trace && { trace }),
-        })
+        const encoded = yield* encodeEvent({ ...event, ...(trace && { trace }) }).pipe(
+          Effect.catchTags({
+            SchemaError: Effect.die,
+          }),
+        )
         // @effect-diagnostics-next-line tryCatchInEffectGen:off
         try {
           socket.send(encoded)
           // oxlint-disable-next-line no-unused-vars
         } catch (_e) {}
       }).pipe(
-        span("send", {
+        Boundary.span("send", import.meta.url, {
           attributes: { _tag, ...sessionAttributes(session) },
           kind: "producer",
           links: [sessionLink(session)],
@@ -201,11 +202,14 @@ export const make = <
     close: ({ socket }) => Effect.sync(() => socket.close(1000)),
     snapshot: ({ socket, session }, attachments) =>
       encodeSocketAttachment({ attachments, session }).pipe(
+        Effect.catchTags({
+          SchemaError: Effect.die,
+        }),
         Effect.andThen((v) => Effect.sync(() => socket.serializeAttachment(v))),
       ),
   }
 
-  class NameDecoded extends Context.Service<NameDecoded, Name["Type"]>()("liminal/WorkerdActorNamespace/NameDecoded") {}
+  class NameDecoded extends Context.Service<NameDecoded, Name["Type"]>()("liminal/ActorNamespace/NameDecoded") {}
 
   return class extends DurableObject {
     readonly run
@@ -239,12 +243,17 @@ export const make = <
       const Live = Layer.mergeAll(
         FetchHttpClient.layer,
         Layer.succeed(DoState.DoState, state),
+        Layer.succeed(Env, env as never),
         Layer.effect(NameDecoded, S.decodeUnknownEffect(Name)(state.id.name)),
       ).pipe(
         Layer.provideMerge(
           prelude.pipe(
             Layer.provideMerge(
-              Layer.mergeAll(FetchHttpClient.layer, ConfigProvider.layer(ConfigProvider.fromUnknown(env))),
+              Layer.mergeAll(
+                FetchHttpClient.layer,
+                ConfigProvider.layer(ConfigProvider.fromUnknown(env)),
+                Layer.succeed(Env, env as never),
+              ),
             ),
           ),
         ),
@@ -258,28 +267,32 @@ export const make = <
             .register({ socket, session }, attachments)
             .pipe(Effect.linkSpans(Tracer.externalSpan(session.trace), sessionLink(session).attributes))
         }
-      }).pipe(span("hydrate"), Layer.effectDiscard)
-
-      const runtime = ManagedRuntime.make(HydrateClientsLive.pipe(Layer.provideMerge(Live), boundLayer("actor")))
+      }).pipe(Boundary.span("hydrate", import.meta.url), Layer.effectDiscard)
 
-      this.run = flow(Effect.tapCause(logCause), runtime.runPromise)
+      const runtime = ManagedRuntime.make(
+        HydrateClientsLive.pipe(Layer.provideMerge(Live), Boundary.layer("actor", import.meta.url)),
+      )
+      this.run = <A, E, R extends ManagedRuntime.ManagedRuntime.Services<typeof runtime>>(
+        effect: Effect.Effect<A, E, R>,
+      ) => Effect.onError(effect, Effect.logError).pipe(runtime.runPromise)
     }
 
     override fetch(request: Request): Promise<Response> {
       return Effect.gen({ self: this }, function* () {
         const url = new URL(request.url)
         const attachments = yield* decodeAttachmentsString(url.searchParams.get("__liminal_attachments"))
+        const clientId = yield* Effect.fromNullishOr(url.searchParams.get("__liminal_client_id"))
         const { 0: webSocket, 1: server } = new WebSocketPair()
         const state = yield* DoState.DoState
         const session = {
-          id: SessionId.make(crypto.randomUUID()),
+          id: SessionId.make(clientId),
           trace: yield* Effect.currentSpan.pipe(Effect.map(Tracing.toTraceEnvelope)),
         }
         const currentClient = yield* this.directory.register({ socket: server, session }, attachments)
         state.acceptWebSocket(server)
         const initial = yield* hydrate.pipe(
           this.provideActor(currentClient),
-          span("hydrate", {
+          Boundary.span("hydrate", import.meta.url, {
             attributes: sessionAttributes(session),
             links: [sessionLink(session)],
           }),
@@ -291,7 +304,7 @@ export const make = <
           headers: { [SecWebSocketProtocol]: "liminal" },
         })
       }).pipe(
-        span("fetch", {
+        Boundary.span("fetch", import.meta.url, {
           kind: "server",
           parent: pipe(request.headers, Headers.fromInput, HttpTraceContext.fromHeaders, Option.getOrUndefined),
         }),
@@ -312,7 +325,7 @@ export const make = <
           yield* currentClient.disconnect
           return yield* onDisconnect.pipe(
             this.provideActor(currentClient),
-            span("disconnect", {
+            Boundary.span("disconnect", import.meta.url, {
               attributes: sessionAttributes(session),
               links: [sessionLink(session)],
             }),
@@ -358,21 +371,23 @@ export const make = <
             }),
           ),
           this.provideActor(currentClient),
-          span("handler", {
+          Boundary.span("handler", import.meta.url, {
             attributes: { _tag, ...sessionAttributes(session) },
             kind: "server",
             parent,
             links,
           }),
         )
-      }).pipe(span("socket-message"), this.run)
+      }).pipe(Boundary.span("socket-message", import.meta.url), this.run)
     }
 
     override webSocketClose(socket: WebSocket, _code: number, _reason: string, _wasClean: boolean) {
       Effect.gen({ self: this }, function* () {
-        const entry = yield* this.directory
-          .entry(socket)
-          .pipe(Effect.catchTag("NoSuchElementError", () => Effect.undefined))
+        const entry = yield* this.directory.entry(socket).pipe(
+          Effect.catchTags({
+            NoSuchElementError: () => Effect.undefined,
+          }),
+        )
         if (!entry) {
           return
         }
@@ -384,12 +399,12 @@ export const make = <
         yield* this.directory.unregister(socket)
         yield* onDisconnect.pipe(
           this.provideActor(currentClient),
-          span("disconnect", {
+          Boundary.span("disconnect", import.meta.url, {
             attributes: sessionAttributes(session),
             links: [sessionLink(session)],
           }),
         )
-      }).pipe(span("socket-close"), this.run)
+      }).pipe(Boundary.span("socket-close", import.meta.url), this.run)
     }
 
     override webSocketError(socket: WebSocket, cause: unknown) {
@@ -402,13 +417,13 @@ export const make = <
         yield* this.directory.unregister(socket)
         yield* onDisconnect.pipe(
           this.provideActor(currentClient),
-          span("disconnect", {
+          Boundary.span("disconnect", import.meta.url, {
             attributes: sessionAttributes(session),
             links: [sessionLink(session)],
           }),
         )
         yield* Effect.annotateLogs(Effect.logDebug("SocketErrored"), { cause })
-      }).pipe(span("socket-error"), this.run)
+      }).pipe(Boundary.span("socket-error", import.meta.url), this.run)
     }
 
     async rpc<K extends keyof Internal>(
@@ -416,7 +431,19 @@ export const make = <
       payload: Internal[K]["payload"]["Type"],
     ): Promise<Exit.Exit<Internal[K]["success"]["Type"], Internal[K]["failure"]["Type"]>> {
       const handler = internal[method]
-      return await handler(payload).pipe(this.provideActor(null!), span("fn-internal"), Effect.exit, this.run)
+      return await handler(payload).pipe(
+        this.provideActor(null!),
+        Boundary.span("fn-internal", import.meta.url),
+        Effect.exit,
+        this.run,
+      )
+    }
+
+    async proxySendAll<K extends keyof D["events"]>(event: K, payload: S.Struct<D["events"][K]>["Type"]) {
+      await Effect.gen(function* () {
+        const { clients } = yield* actor
+        yield* Effect.forEach(clients, ({ send }) => send(event, payload), { concurrency: "unbounded" })
+      }).pipe(this.provideActor(null!), Boundary.span("fn-internal", import.meta.url), this.run)
     }
   }
 }

package/ActorTransport.ts

@@ -8,12 +8,12 @@ export interface ActorTransport<Key, Client, AttachmentFields extends S.Struct.F
   readonly send: (
     client: Client,
     event: Protocol<D>["Event"]["Type"],
-  ) => Effect.Effect<void, S.SchemaError, Protocol<D>["Event"]["EncodingServices"]>
+  ) => Effect.Effect<void, never, Protocol<D>["Event"]["EncodingServices"]>
 
   readonly close: (client: Client) => Effect.Effect<void>
 
   readonly snapshot: (
     client: Client,
     attachments: S.Struct<AttachmentFields>["Type"],
-  ) => Effect.Effect<void, S.SchemaError, S.Struct<AttachmentFields>["EncodingServices"]>
+  ) => Effect.Effect<void, never, S.Struct<AttachmentFields>["EncodingServices"]>
 }

package/Audition.ts

@@ -35,7 +35,7 @@ export const empty: Audition<never, never, {}, never> = {
     return Pipeable.pipeArguments(this, arguments)
   },
   state: Stream.fail(new AuditionError()),
-  fn: () => () => new AuditionError().asEffect(),
+  fn: () => () => new AuditionError(),
   events: Stream.fail(new AuditionError()),
 }