liminal 0.17.14 → 0.17.15

package/ClientDirectory.ts

@@ -1,36 +1,45 @@
 import { Schema as S, Effect, Cause, Ref } from "effect"
+import * as Spanner from "liminal-util/Spanner"
 
+import { phantom } from "./_util/phantom.ts"
 import type { TopFromString } from "./_util/schema.ts"
 import type { Actor } from "./Actor.ts"
 import type { ActorTransport } from "./ActorTransport.ts"
+import * as ClientHandle from "./ClientHandle.ts"
 import type { ProtocolDefinition, Disconnect, Protocol } from "./Protocol.ts"
 
-import { diagnostic } from "./_diagnostic.ts"
-import { phantom } from "./_util/phantom.ts"
-import * as ClientHandle from "./ClientHandle.ts"
+const span = Spanner.make(import.meta.url)
 
-const { span } = diagnostic("ClientDirectory")
+export interface ClientEntry<Client, Handle> {
+  readonly client: Client
+
+  readonly handle: Handle
+}
 
 export interface ClientDirectory<
-  Raw,
+  Key,
+  Client,
   ActorSelf,
   AttachmentFields extends S.Struct.Fields,
   D extends ProtocolDefinition,
 > {
   readonly "": {
     readonly Handle: ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>
+    readonly Entry: ClientEntry<Client, ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>>
   }
 
   readonly handles: ReadonlySet<this[""]["Handle"]>
 
   readonly register: (
-    raw: Raw,
+    client: Client,
     attachments: S.Struct<AttachmentFields>["Type"],
   ) => Effect.Effect<this[""]["Handle"], S.SchemaError, S.Struct<AttachmentFields>["EncodingServices"]>
 
-  readonly get: (raw: Raw) => Effect.Effect<this[""]["Handle"], Cause.NoSuchElementError>
+  readonly get: (key: Key) => Effect.Effect<this[""]["Handle"], Cause.NoSuchElementError>
 
-  readonly unregister: (raw: Raw) => Effect.Effect<void>
+  readonly entry: (key: Key) => Effect.Effect<this[""]["Entry"], Cause.NoSuchElementError>
+
+  readonly unregister: (key: Key) => Effect.Effect<void>
 }
 
 export interface HandleEncoders<T, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
@@ -44,7 +53,8 @@ export interface HandleEncoders<T, AttachmentFields extends S.Struct.Fields, D e
 }
 
 export const make = <
-  Raw,
+  Key,
+  Client,
   ActorSelf,
   ActorId extends string,
   Name extends TopFromString,
@@ -54,51 +64,55 @@ export const make = <
   D extends ProtocolDefinition,
 >(
   _actor: Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>,
-  { send, close, snapshot }: ActorTransport<Raw, AttachmentFields, D>,
-): ClientDirectory<Raw, ActorSelf, AttachmentFields, D> => {
+  {
+    transport: { key, send, close, snapshot },
+  }: {
+    readonly transport: ActorTransport<Key, Client, AttachmentFields, D>
+  },
+): ClientDirectory<Key, Client, ActorSelf, AttachmentFields, D> => {
   type Handle = ClientHandle.ClientHandle<ActorSelf, AttachmentFields, D>
+  type Entry = ClientEntry<Client, Handle>
 
-  const raws = new Map<Raw, Handle>()
+  const entries = new Map<Key, Entry>()
   const handles = new Set<Handle>()
 
-  const get = (raw: Raw) => Effect.fromNullishOr(raws.get(raw))
+  const entry = (key: Key) => Effect.fromNullishOr(entries.get(key))
+  const get = (key: Key) => entry(key).pipe(Effect.map(({ handle }) => handle))
+
+  const unregister = (key: Key) =>
+    Effect.sync(() => {
+      const current = entries.get(key)
+      if (current) {
+        entries.delete(key)
+        handles.delete(current.handle)
+      }
+    }).pipe(span("unregister"))
 
-  const register = Effect.fnUntraced(function* (raw: Raw, attachments: S.Struct<AttachmentFields>["Type"]) {
-    yield* snapshot(raw, attachments)
+  const register = Effect.fnUntraced(function* (client: Client, attachments: S.Struct<AttachmentFields>["Type"]) {
+    const clientKey = key(client)
+    yield* snapshot(client, attachments)
     const attachmentsRef = yield* Ref.make(attachments)
     const handle: Handle = {
       attachments: Ref.get(attachmentsRef),
       save: Effect.fnUntraced(function* (attachments) {
         yield* Ref.set(attachmentsRef, attachments)
-        yield* snapshot(raw, attachments)
+        yield* snapshot(client, attachments)
       }),
       send: (_tag, payload) =>
-        send(raw, {
+        send(client, {
           _tag: "Event",
           event: { _tag, ...payload } as never,
         }),
-      disconnect: close(raw).pipe(
-        Effect.andThen(() =>
-          Effect.sync(() => {
-            raws.delete(raw)
-            handles.delete(handle)
-          }),
-        ),
-      ),
+      disconnect: close(client).pipe(Effect.andThen(unregister(clientKey)), Effect.asVoid),
+    }
+    const previous = entries.get(clientKey)
+    if (previous) {
+      handles.delete(previous.handle)
     }
-    raws.set(raw, handle)
+    entries.set(clientKey, { client, handle })
     handles.add(handle)
     return handle
   }, span("register"))
 
-  const unregister = (raw: Raw) =>
-    Effect.sync(() => {
-      const handle = raws.get(raw)
-      if (handle) {
-        raws.delete(raw)
-        handles.delete(handle)
-      }
-    }).pipe(span("unregister"))
-
-  return { ...phantom, handles, register, get, unregister }
+  return { ...phantom, handles, register, get, entry, unregister }
 }

package/ClientHandleEncoders.ts

@@ -0,0 +1,15 @@
+import { Schema as S, Effect } from "effect"
+
+import type { ProtocolDefinition, Disconnect, Protocol } from "./Protocol.ts"
+
+export interface HandleEncoders<T, AttachmentFields extends S.Struct.Fields, D extends ProtocolDefinition> {
+  readonly attachments: (
+    value: S.Struct<AttachmentFields>["Type"],
+  ) => Effect.Effect<T, S.SchemaError, S.Struct<AttachmentFields>["EncodingServices"]>
+
+  readonly event: (
+    value: Protocol<D>["Event"]["Type"],
+  ) => Effect.Effect<T, S.SchemaError, Protocol<D>["Event"]["EncodingServices"]>
+
+  readonly disconnect: Effect.Effect<T, S.SchemaError, (typeof Disconnect)["EncodingServices"]>
+}

package/Fn.ts

@@ -0,0 +1,55 @@
+import { Effect, Schema as S } from "effect"
+
+import type { ClientError, UnresolvedError } from "./errors.ts"
+import type { Methods } from "./Method.ts"
+
+export type FnPayload<External extends Methods, K extends keyof External> = External[K]["payload"]["Type"]
+
+export type FnError<External extends Methods, K extends keyof External> = [
+  External[K]["failure"]["Type"] | ClientError | S.SchemaError | UnresolvedError,
+][0]
+
+export type FnEffect<Self, External extends Methods, K extends keyof External> = Effect.Effect<
+  External[K]["success"]["Type"],
+  FnError<External, K>,
+  Self
+>
+
+export interface Fn<Self, Internal extends Methods> {
+  <K extends keyof Internal>(tag: K): (payload: FnPayload<Internal, K>) => FnEffect<Self, Internal, K>
+
+  <K extends keyof Internal, A>(
+    tag: K,
+    a: (effect: FnEffect<Self, Internal, K>, payload: FnPayload<Internal, K>) => A,
+  ): (payload: FnPayload<Internal, K>) => A
+
+  <K extends keyof Internal, A, B>(
+    tag: K,
+    a: (effect: FnEffect<Self, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+  ): (payload: FnPayload<Internal, K>) => B
+
+  <K extends keyof Internal, A, B, C>(
+    tag: K,
+    a: (effect: FnEffect<Self, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+    c: (value: B, payload: FnPayload<Internal, K>) => C,
+  ): (payload: FnPayload<Internal, K>) => C
+
+  <K extends keyof Internal, A, B, C, D>(
+    tag: K,
+    a: (effect: FnEffect<Self, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+    c: (value: B, payload: FnPayload<Internal, K>) => C,
+    d: (value: C, payload: FnPayload<Internal, K>) => D,
+  ): (payload: FnPayload<Internal, K>) => D
+
+  <K extends keyof Internal, A, B, C, D, E>(
+    tag: K,
+    a: (effect: FnEffect<Self, Internal, K>, payload: FnPayload<Internal, K>) => A,
+    b: (value: A, payload: FnPayload<Internal, K>) => B,
+    c: (value: B, payload: FnPayload<Internal, K>) => C,
+    d: (value: C, payload: FnPayload<Internal, K>) => D,
+    e: (value: D, payload: FnPayload<Internal, K>) => E,
+  ): (payload: FnPayload<Internal, K>) => E
+}

package/Method.ts

@@ -1,29 +1,19 @@
 import { Schema as S, Effect } from "effect"
 
-export interface MethodDefinition<Payload extends S.Top, Success extends S.Top, Failure extends S.Top> {
-  readonly payload: Payload
-  readonly success: Success
-  readonly failure: Failure
+export interface Method {
+  readonly payload: S.Top
+  readonly success: S.Top
+  readonly failure: S.Top
 }
 
-export type Any = MethodDefinition<S.Top, S.Top, S.Top>
+export type Methods = Record<string, Method>
 
-export const make = <Payload extends S.Top, Success extends S.Top, Failure extends S.Top>({
-  payload,
-  success,
-  failure,
-}: {
-  readonly payload: Payload
-  readonly success: Success
-  readonly failure: Failure
-}): MethodDefinition<Payload, Success, Failure> => ({ payload, success, failure })
+export type Handler<M extends Method, R> = (
+  payload: M["payload"]["Type"],
+) => Effect.Effect<M["success"]["Type"], M["failure"]["Type"], R>
 
-export type Handler<Method extends Any, R> = (
-  payload: Method["payload"]["Type"],
-) => Effect.Effect<Method["success"]["Type"], Method["failure"]["Type"], R>
+export const handler = <M extends Method, R>(_method: M, f: Handler<M, R>): Handler<M, R> => f
 
-export type Handlers<Methods extends Record<string, Any>, R> = {
-  [K in keyof Methods]: Handler<Methods[K], R>
+export type Handlers<Internal extends Methods, R> = {
+  readonly [K in keyof Internal]: Handler<Internal[K], R>
 }
-
-export const handler = <Method extends Any, R>(_method: Method, f: Handler<Method, R>): Handler<Method, R> => f

package/Protocol.ts

@@ -1,33 +1,24 @@
-import { Schema as S, Record, Types } from "effect"
+import { Schema as S, Record } from "effect"
 
-import type * as Method from "./Method.ts"
+import type { Methods } from "./Method.ts"
+import * as Tracing from "./Tracing.ts"
 
 export interface ProtocolDefinition<
-  Methods extends Record<string, Method.Any> = Record<string, Method.Any>,
+  State extends S.Struct.Fields = S.Struct.Fields,
+  External extends Methods = Methods,
   Events extends Record<string, S.Struct.Fields> = Record<string, S.Struct.Fields>,
 > {
-  readonly methods: Methods
+  readonly state: State
 
-  readonly events: Events
-}
+  readonly external: External
 
-export declare namespace ProtocolDefinition {
-  export type Merge<T extends ProtocolDefinition, U extends ProtocolDefinition> = ProtocolDefinition<
-    [T] extends [never]
-      ? U["methods"]
-      : {
-          [K in keyof T["methods"] & keyof U["methods"] as Types.Equals<T["methods"][K], U["methods"][K]> extends true
-            ? K
-            : never]: T["methods"][K]
-        },
-    [T] extends [never] ? U["events"] : T["events"] & U["events"]
-  >
+  readonly events: Events
 }
 
 export interface Protocol<D extends ProtocolDefinition> {
   readonly Audition: {
-    readonly Payload: S.TaggedStruct<"Audition.Payload", { client: S.String }>
-    readonly Success: S.TaggedStruct<"Audition.Success", {}>
+    readonly Payload: S.TaggedStruct<"Audition.Payload", { readonly client: S.String }>
+    readonly Success: S.TaggedStruct<"Audition.Success", { readonly initial: S.Struct<D["state"]> }>
     readonly Failure: S.TaggedStruct<
       "Audition.Failure",
       {
@@ -43,6 +34,7 @@ export interface Protocol<D extends ProtocolDefinition> {
       readonly event: S.TaggedUnion<{
         readonly [K in keyof D["events"] & string]: S.TaggedStruct<K, D["events"][K]>
       }>
+      readonly trace: S.optional<typeof Tracing.TraceEnvelope>
     }
   >
 
@@ -52,8 +44,12 @@ export interface Protocol<D extends ProtocolDefinition> {
       {
         readonly id: S.Int
         readonly payload: S.TaggedUnion<{
-          readonly [K in keyof D["methods"] & string]: S.TaggedStruct<K, { readonly value: D["methods"][K]["payload"] }>
+          readonly [K in keyof D["external"] & string]: S.TaggedStruct<
+            K,
+            { readonly value: D["external"][K]["payload"] }
+          >
         }>
+        readonly trace: S.optional<typeof Tracing.TraceEnvelope>
       }
     >
 
@@ -62,7 +58,10 @@ export interface Protocol<D extends ProtocolDefinition> {
       {
         readonly id: S.Int
         readonly success: S.TaggedUnion<{
-          readonly [K in keyof D["methods"] & string]: S.TaggedStruct<K, { readonly value: D["methods"][K]["success"] }>
+          readonly [K in keyof D["external"] & string]: S.TaggedStruct<
+            K,
+            { readonly value: D["external"][K]["success"] }
+          >
         }>
       }
     >
@@ -72,7 +71,10 @@ export interface Protocol<D extends ProtocolDefinition> {
       {
         readonly id: S.Int
         readonly failure: S.TaggedUnion<{
-          readonly [K in keyof D["methods"] & string]: S.TaggedStruct<K, { readonly value: D["methods"][K]["failure"] }>
+          readonly [K in keyof D["external"] & string]: S.TaggedStruct<
+            K,
+            { readonly value: D["external"][K]["failure"] }
+          >
         }>
       }
     >
@@ -96,37 +98,43 @@ export interface Protocol<D extends ProtocolDefinition> {
 
 export const Disconnect = S.TaggedStruct("Disconnect", {})
 
-const Audition = {
-  Payload: S.TaggedStruct("Audition.Payload", {
-    client: S.String,
-  }),
-  Success: S.TaggedStruct("Audition.Success", {}),
-  Failure: S.TaggedStruct("Audition.Failure", {
-    expected: S.String,
-    actual: S.String,
-  }),
-}
+const AuditionPayload = S.TaggedStruct("Audition.Payload", {
+  client: S.String,
+})
+
+const AuditionFailure = S.TaggedStruct("Audition.Failure", {
+  expected: S.String,
+  actual: S.String,
+})
 
-export const Protocol = <D extends ProtocolDefinition>({ events, methods }: D): Protocol<D> => {
+export const Protocol = <D extends ProtocolDefinition>({ state, events, external }: D): Protocol<D> => {
   type T = Protocol<D>
 
+  const Audition = {
+    Payload: AuditionPayload,
+    Success: S.TaggedStruct("Audition.Success", { initial: S.Struct(state) }),
+    Failure: AuditionFailure,
+  }
+
   const F: T["F"] = {
     Payload: S.TaggedStruct("F.Payload", {
       id: S.Int,
-      payload: S.TaggedUnion(Record.map(methods, ({ payload: value }) => ({ value }))),
+      payload: S.TaggedUnion(Record.map(external, ({ payload: value }) => ({ value }))),
+      trace: S.optional(Tracing.TraceEnvelope),
     }) as never,
     Success: S.TaggedStruct("F.Success", {
       id: S.Int,
-      success: S.TaggedUnion(Record.map(methods, ({ success: value }) => ({ value }))),
+      success: S.TaggedUnion(Record.map(external, ({ success: value }) => ({ value }))),
     }) as never,
     Failure: S.TaggedStruct("F.Failure", {
       id: S.Int,
-      failure: S.TaggedUnion(Record.map(methods, ({ failure: value }) => ({ value }))),
+      failure: S.TaggedUnion(Record.map(external, ({ failure: value }) => ({ value }))),
     }) as never,
   }
 
   const Event: T["Event"] = S.TaggedStruct("Event", {
     event: S.TaggedUnion(events),
+    trace: S.optional(Tracing.TraceEnvelope),
   }) as never
 
   const Client: T["Client"] = S.Union([Audition.Payload, F.Payload, Disconnect])

package/Reducer.ts

@@ -0,0 +1,22 @@
+import { Schema as S, Types, Effect } from "effect"
+
+import type { ProtocolDefinition } from "./Protocol.ts"
+
+export type Reducer<D extends ProtocolDefinition, K extends keyof D["events"] = keyof D["events"]> = (
+  event: Types.ExtractTag<ReturnType<typeof S.TaggedUnion<D["events"]>>["Type"], Extract<K, string>>,
+) => (state: S.Struct<D["state"]>["Type"]) => Effect.Effect<S.Struct<D["state"]>["Type"] | void, never, unknown>
+
+export type Reducers<D extends ProtocolDefinition> = {
+  readonly [K in keyof D["events"]]: Reducer<D, K>
+}
+
+export declare namespace Reducers {
+  export type Services<Self, D extends Record<string, Reducer<any, any>>> = Exclude<
+    {
+      readonly [K in keyof D]: D[K] extends (...args: any) => (...args: any) => Effect.Effect<any, any, infer R>
+        ? R
+        : never
+    }[keyof D],
+    Self
+  >
+}

package/Tracing.ts

@@ -0,0 +1,37 @@
+import { Effect, Schema as S, Tracer } from "effect"
+
+export const TraceEnvelope = S.Struct({
+  traceId: S.String,
+  spanId: S.String,
+  sampled: S.Boolean,
+})
+
+export const toTraceEnvelope = ({ traceId, spanId, sampled }: typeof TraceEnvelope.Type) => ({
+  traceId,
+  spanId,
+  sampled,
+})
+
+export const SessionId = S.String.check(S.isUUID()).pipe(S.brand("SessionId"))
+
+export const Session = S.Struct({
+  id: SessionId,
+  trace: TraceEnvelope,
+})
+
+export const parent = Effect.currentParentSpan.pipe(Effect.catchTag("NoSuchElementError", () => Effect.undefined))
+
+export const current = Effect.currentSpan.pipe(Effect.catchTag("NoSuchElementError", () => Effect.undefined))
+
+export const currentTrace = current.pipe(Effect.map((span) => (span ? toTraceEnvelope(span) : undefined)))
+
+export const sessionAttributes = ({ id }: typeof Session.Type) => ({ "liminal.session.id": id })
+
+export const sessionLink = (session: typeof Session.Type, attributes: Record<string, unknown> = {}) => ({
+  span: Tracer.externalSpan(session.trace),
+  attributes: {
+    "liminal.link": "session",
+    ...sessionAttributes(session),
+    ...attributes,
+  },
+})

package/browser/BrowserActorNamespace.ts

@@ -1,19 +1,19 @@
 import { BrowserWorkerRunner } from "@effect/platform-browser"
-import { Cause, Effect, Exit, Layer, Option, Ref, Schema as S, Scope, Semaphore, Stream } from "effect"
+import { Cause, Effect, Exit, Layer, Option, Ref, Schema as S, Scope, Semaphore, Stream, Tracer } from "effect"
 import { WorkerRunner } from "effect/unstable/workers"
 import { logCause } from "liminal-util/logCause"
+import * as Spanner from "liminal-util/Spanner"
 
 import type { TopFromString } from "../_util/schema.ts"
 import type { Actor } from "../Actor.ts"
 import type { ActorTransport } from "../ActorTransport.ts"
-import type { ClientHandle } from "../ClientHandle.ts"
-import type { ProtocolDefinition } from "../Protocol.ts"
-
-import { diagnostic } from "../_diagnostic.ts"
 import * as ClientDirectory from "../ClientDirectory.ts"
+import type { ClientHandle } from "../ClientHandle.ts"
 import * as Method from "../Method.ts"
+import type { ProtocolDefinition } from "../Protocol.ts"
+import * as Tracing from "../Tracing.ts"
 
-const { debug, span } = diagnostic("browser.BrowserActorNamespace")
+const span = Spanner.make(import.meta.url)
 
 export interface Introduction<Name extends TopFromString, AttachmentFields extends S.Struct.Fields> {
   readonly port: MessagePort
@@ -29,8 +29,7 @@ export const make = Effect.fnUntraced(function* <
   ClientSelf,
   ClientId extends string,
   D extends ProtocolDefinition,
-  const Handlers extends Method.Handlers<D["methods"], any>,
-  A,
+  const Handlers extends Method.Handlers<D["external"], any>,
   E,
   R,
   IntroductionE,
@@ -38,12 +37,12 @@ export const make = Effect.fnUntraced(function* <
 >({
   actor,
   handlers,
-  onConnect,
+  hydrate,
   introductions,
 }: {
   readonly actor: Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>
   readonly handlers: Handlers
-  readonly onConnect: Effect.Effect<A, E, R>
+  readonly hydrate: Effect.Effect<S.Struct<D["state"]>["Type"], E, R>
   readonly introductions: Stream.Stream<Introduction<Name, AttachmentFields>, IntroductionE, IntroductionR>
 }) {
   const {
@@ -59,17 +58,34 @@ export const make = Effect.fnUntraced(function* <
   const validateClientMessage = S.decodeUnknownEffect(S.toType(ClientM))
   const encodeName = S.encodeEffect(Name)
 
+  interface BrowserClient {
+    readonly port: MessagePort
+
+    readonly backing: WorkerRunner.WorkerRunner<typeof Actor.Type, typeof ClientM.Type>
+
+    readonly close: Effect.Effect<void>
+  }
+
   interface Entry {
-    readonly directory: ClientDirectory.ClientDirectory<MessagePort, ActorSelf, AttachmentFields, D>
+    readonly directory: ClientDirectory.ClientDirectory<MessagePort, BrowserClient, ActorSelf, AttachmentFields, D>
     readonly mutex: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   }
 
   const entries: Record<string, Entry> = {}
-  const runners = new Map<MessagePort, WorkerRunner.WorkerRunner<typeof Actor.Type, typeof ClientM.Type>>()
 
-  const transport: ActorTransport<MessagePort, AttachmentFields, D> = {
-    send: (port, event) => runners.get(port)?.send(0, event) ?? Effect.void,
-    close: () => Effect.void,
+  const transport: ActorTransport<MessagePort, BrowserClient, AttachmentFields, D> = {
+    key: ({ port }) => port,
+    send: ({ backing }, event) => {
+      const { _tag } = event.event as never
+      return Effect.gen(function* () {
+        const trace = yield* Tracing.currentTrace
+        yield* backing.send(0, {
+          ...event,
+          ...(trace && { trace }),
+        })
+      }).pipe(span("send", { attributes: { _tag }, kind: "producer" }))
+    },
+    close: ({ close }) => close,
     snapshot: () => Effect.void,
   }
 
@@ -78,7 +94,7 @@ export const make = Effect.fnUntraced(function* <
   const getEntry = Effect.fnUntraced(function* (key: string) {
     const existing = entries[key]
     if (existing) return existing
-    const directory = ClientDirectory.make(actor, transport)
+    const directory = ClientDirectory.make(actor, { transport })
     const semaphore = yield* Semaphore.make(1)
     const fresh = {
       directory,
@@ -93,8 +109,6 @@ export const make = Effect.fnUntraced(function* <
   yield* introductions.pipe(
     Stream.runForEach(
       Effect.fnUntraced(function* ({ name, port, attachments }) {
-        yield* debug("IntroductionReceived", { name })
-
         const stateRef = yield* Ref.make<
           Option.Option<{
             readonly key: string
@@ -108,14 +122,12 @@ export const make = Effect.fnUntraced(function* <
         const closeScope = Scope.close(scope, Exit.void)
 
         const backing = yield* BrowserWorkerRunner.make(port).start<typeof Actor.Type, typeof ClientM.Type>()
-        runners.set(port, backing)
 
         yield* Scope.addFinalizer(
           scope,
           Effect.gen(function* () {
-            runners.delete(port)
             const state = yield* Ref.get(stateRef)
-            if (Option.isSome(state)) {
+            if (state._tag === "Some") {
               const {
                 key,
                 entry: { directory },
@@ -134,8 +146,7 @@ export const make = Effect.fnUntraced(function* <
               const state = yield* Ref.get(stateRef)
               yield* Effect.gen(function* () {
                 const message = yield* validateClientMessage(raw)
-                yield* debug("MessageReceived", { message })
-                if (Option.isNone(state)) {
+                if (state._tag === "None") {
                   if (message._tag !== "Audition.Payload") {
                     return yield* Effect.die(undefined)
                   }
@@ -150,17 +161,23 @@ export const make = Effect.fnUntraced(function* <
                   }
                   const key = yield* encodeName(name)
                   const entry = yield* getEntry(key)
-                  const currentClient = Object.assign(yield* entry.directory.register(port, attachments), {
-                    disconnect: closeScope,
-                  })
+                  const currentClient = yield* entry.directory.register(
+                    { port, backing, close: closeScope },
+                    attachments,
+                  )
                   const ActorLive = Layer.succeed(actor, {
                     name,
                     clients: entry.directory.handles,
                     currentClient,
                   })
                   yield* Ref.set(stateRef, Option.some({ key, entry, currentClient, ActorLive }))
-                  yield* backing.send(0, { _tag: "Audition.Success" })
-                  return yield* onConnect.pipe(entry.mutex, Effect.scoped, span("onConnect"), Effect.provide(ActorLive))
+                  const initial = yield* hydrate.pipe(
+                    entry.mutex,
+                    Effect.scoped,
+                    span("onConnect"),
+                    Effect.provide(ActorLive),
+                  )
+                  return yield* backing.send(0, { _tag: "Audition.Success", initial })
                 }
                 const { entry, ActorLive } = state.value
                 if (message._tag === "Audition.Payload") {
@@ -171,9 +188,11 @@ export const make = Effect.fnUntraced(function* <
                 }
                 const { id, payload } = message
                 const { _tag, value } = payload as never
+                const parent = message.trace && Tracer.externalSpan(message.trace)
+                const transportSpan = yield* Tracing.parent
                 yield* (
                   handlers as Method.Handlers<
-                    D["methods"],
+                    D["external"],
                     Handlers[keyof Handlers] extends (v: never) => Effect.Effect<any, any, infer R> ? R : never
                   >
                 )[_tag]!(value).pipe(
@@ -190,7 +209,23 @@ export const make = Effect.fnUntraced(function* <
                     }),
                   }),
                   Effect.andThen((v) => backing.send(0, v)),
-                  span("handler", { attributes: { _tag } }),
+                  span("handle", {
+                    attributes: { _tag },
+                    kind: "server",
+                    parent,
+                    links:
+                      parent && transportSpan
+                        ? [
+                            {
+                              span: transportSpan,
+                              attributes: {
+                                "liminal.link": "transport",
+                                "liminal.transport": "worker",
+                              },
+                            },
+                          ]
+                        : undefined,
+                  }),
                   Effect.scoped,
                   Effect.provide(ActorLive),
                   entry.mutex,