liminal 0.17.15 → 0.17.16

package/BrowserActorNamespace.ts

@@ -0,0 +1,257 @@
+import { BrowserWorkerRunner } from "@effect/platform-browser"
+import { Effect, Exit, Layer, Option, Ref, Schema as S, Scope, Semaphore, Stream, Tracer } from "effect"
+import { WorkerRunner } from "effect/unstable/workers"
+import * as Boundary from "liminal-util/Boundary"
+import { encodeJsonString, decodeJsonString, type TopFromString } from "liminal-util/schema"
+
+import type { Actor } from "./Actor.ts"
+import type { ActorTransport } from "./ActorTransport.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"
+
+export interface Introduction<Name extends TopFromString, AttachmentFields extends S.Struct.Fields> {
+  readonly port: MessagePort
+  readonly name: Name["Type"]
+  readonly attachments: S.Struct<AttachmentFields>["Type"]
+}
+
+export const make = Effect.fnUntraced(
+  function* <
+    ActorSelf,
+    ActorId extends string,
+    Name extends TopFromString,
+    AttachmentFields extends S.Struct.Fields,
+    ClientSelf,
+    ClientId extends string,
+    D extends ProtocolDefinition,
+    const Handlers extends Method.Handlers<D["external"], any>,
+    E,
+    R,
+    IntroductionE,
+    IntroductionR,
+  >({
+    actor,
+    handlers,
+    hydrate,
+    introductions,
+  }: {
+    readonly actor: Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>
+    readonly handlers: Handlers
+    readonly hydrate: Effect.Effect<S.Struct<D["state"]>["Type"], E, R>
+    readonly introductions: Stream.Stream<Introduction<Name, AttachmentFields>, IntroductionE, IntroductionR>
+  }) {
+    const {
+      definition: {
+        client: { protocol: P, key: expected },
+        name: Name,
+      },
+    } = actor
+    const { Client: ClientM } = P
+    const decodeClient = decodeJsonString(ClientM)
+    const encodeAuditionSuccess = encodeJsonString(P.Audition.Success)
+    const encodeAuditionFailure = encodeJsonString(P.Audition.Failure)
+    const encodeFSuccess = encodeJsonString(P.F.Success)
+    const encodeFFailure = encodeJsonString(P.F.Failure)
+    const encodeEvent = encodeJsonString(P.Event)
+
+    interface BrowserClient {
+      readonly port: MessagePort
+
+      readonly backing: WorkerRunner.WorkerRunner<string, string>
+
+      readonly close: Effect.Effect<void>
+    }
+
+    interface Entry {
+      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 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,
+            yield* encodeEvent({ ...event, ...(trace && { trace }) }).pipe(
+              Effect.catchTags({
+                SchemaError: Effect.die,
+              }),
+            ),
+          )
+        }).pipe(Boundary.span("send", import.meta.url, { attributes: { _tag }, kind: "producer" }))
+      },
+      close: ({ close }) => close,
+      snapshot: () => Effect.void,
+    }
+
+    const useEntries = yield* Semaphore.make(1).pipe(Effect.map((v) => v.withPermits(1)))
+
+    const getEntry = Effect.fnUntraced(function* (key: string) {
+      const existing = entries[key]
+      if (existing) return existing
+      const directory = ClientDirectory.make(actor, { transport })
+      const semaphore = yield* Semaphore.make(1)
+      const fresh = {
+        directory,
+        mutex: semaphore.withPermits(1),
+      }
+      entries[key] = fresh
+      return fresh
+    }, useEntries)
+
+    const outerScope = yield* Scope.Scope
+
+    yield* introductions.pipe(
+      Stream.runForEach(
+        Effect.fnUntraced(function* ({ name, port, attachments }) {
+          const stateRef = yield* Ref.make<
+            Option.Option<{
+              readonly key: string
+              readonly entry: Entry
+              readonly currentClient: ClientHandle<ActorSelf, AttachmentFields, D>
+              readonly ActorLive: Layer.Layer<ActorSelf>
+            }>
+          >(Option.none())
+
+          const scope = yield* Scope.fork(outerScope, "sequential")
+          const closeScope = Scope.close(scope, Exit.void)
+
+          const backing = yield* BrowserWorkerRunner.make(port).start<string, string>()
+
+          yield* Scope.addFinalizer(
+            scope,
+            Effect.gen(function* () {
+              const state = yield* Ref.get(stateRef)
+              if (state._tag === "Some") {
+                const {
+                  key,
+                  entry: { directory },
+                } = state.value
+                yield* directory.unregister(port)
+                if (directory.handles.size === 0) {
+                  delete entries[key]
+                }
+              }
+            }).pipe(useEntries),
+          )
+
+          yield* backing
+            .run(
+              Effect.fnUntraced(
+                function* (_portId, raw) {
+                  const state = yield* Ref.get(stateRef)
+                  const message = yield* decodeClient(raw)
+                  if (state._tag === "None") {
+                    if (message._tag !== "Audition.Payload") {
+                      return yield* Effect.die(undefined)
+                    }
+                    const { client: actual } = message
+                    if (actual !== expected) {
+                      yield* backing.send(
+                        0,
+                        yield* encodeAuditionFailure({
+                          _tag: "Audition.Failure",
+                          expected,
+                          actual,
+                        }),
+                      )
+                      return yield* closeScope
+                    }
+                    const key = yield* S.encodeEffect(Name)(name)
+                    const entry = yield* getEntry(key)
+                    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 }))
+                    const initial = yield* hydrate.pipe(
+                      entry.mutex,
+                      Effect.scoped,
+                      Boundary.span("onConnect", import.meta.url),
+                      Effect.provide(ActorLive),
+                    )
+                    return yield* backing.send(0, yield* encodeAuditionSuccess({ _tag: "Audition.Success", initial }))
+                  }
+                  const { entry, ActorLive } = state.value
+                  if (message._tag === "Audition.Payload") {
+                    return yield* Effect.die(undefined)
+                  }
+                  if (message._tag === "Disconnect") {
+                    return yield* closeScope
+                  }
+                  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["external"],
+                      Handlers[keyof Handlers] extends (v: never) => Effect.Effect<any, any, infer R> ? R : never
+                    >
+                  )[_tag]!(value).pipe(
+                    Effect.matchEffect({
+                      onSuccess: (value) =>
+                        encodeFSuccess({
+                          _tag: "F.Success",
+                          id,
+                          success: { _tag, value } as never,
+                        }),
+                      onFailure: (value) =>
+                        encodeFFailure({
+                          _tag: "F.Failure",
+                          id,
+                          failure: { _tag, value } as never,
+                        }),
+                    }),
+                    Effect.andThen((v) => backing.send(0, v)),
+                    Boundary.span("handle", import.meta.url, {
+                      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,
+                  )
+                },
+                Boundary.span("message", import.meta.url),
+              ),
+            )
+            .pipe(
+              Effect.andThen(closeScope),
+              Effect.catchCause((cause) => Effect.logError(cause).pipe(Effect.andThen(closeScope))),
+              Boundary.span("backing", import.meta.url),
+              Effect.forkScoped,
+              Scope.provide(scope),
+            )
+        }),
+      ),
+    )
+  },
+  Boundary.span("make", import.meta.url),
+)

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # liminal
 
+## 0.17.16
+
+### Patch Changes
+
+- b08b6d9: Begin trusted publishing configuration.
+- Updated dependencies [b08b6d9]
+  - effect-workerd@0.0.6
+  - liminal-util@0.0.10
+
 ## 0.17.15
 
 ### Patch Changes

package/Client.ts

@@ -26,17 +26,15 @@ import {
 } from "effect"
 import { Socket } from "effect/unstable/socket"
 import { Worker } from "effect/unstable/workers"
-import * as Spanner from "liminal-util/Spanner"
+import * as Boundary from "liminal-util/Boundary"
+import { decodeJsonString, encodeJsonString } from "liminal-util/schema"
 
-import { decodeJsonString, encodeJsonString } from "./_util/schema.ts"
 import { type ClientError, AuditionError, ConnectionError, UnresolvedError } from "./errors.ts"
-import type { Fn, FnError } from "./Fn.ts"
+import type { Fn, FnError, FnNoSelf } from "./Fn.ts"
 import { Protocol, type ProtocolDefinition } from "./Protocol.ts"
 import * as Reducer from "./Reducer.ts"
 import * as Tracing from "./Tracing.ts"
 
-const span = Spanner.make(import.meta.url)
-
 export const TypeId = "~liminal/Client" as const
 
 export interface ReplayConfig {
@@ -67,11 +65,13 @@ export type Service<ClientSelf, D extends ProtocolDefinition> = RcRef.RcRef<
   ClientError
 >
 
-export interface Client<Self, ClientId extends string, D extends ProtocolDefinition> extends Context.Service<
+export interface Client<Self, Id extends string, D extends ProtocolDefinition> extends Context.Service<
   Self,
   Service<Self, D>
 > {
-  new (_: never): Context.ServiceClass.Shape<ClientId, Service<Self, D>>
+  new (_: never): Context.ServiceClass.Shape<Id, Service<Self, D>> & {
+    readonly State: S.Struct<D["state"]>["Type"]
+  }
 
   readonly [TypeId]: typeof TypeId
 
@@ -98,6 +98,17 @@ export interface Client<Self, ClientId extends string, D extends ProtocolDefinit
   readonly reducer: <K extends keyof D["events"], R extends Reducer.Reducer<D, K>>(_tag: K, f: R) => R
 }
 
+export const fn = <ClientSelf, D extends ProtocolDefinition>(service: Service<ClientSelf, D>) =>
+  ((_tag: keyof D["external"], ...f: Array<any>) =>
+    Effect.fnUntraced(
+      function* (payload: any) {
+        const { fnRaw: fn } = yield* RcRef.get(service)
+        return yield* fn(_tag, payload)
+      },
+      Effect.scoped,
+      ...(f as [any]),
+    )) as FnNoSelf<D["external"]>
+
 export const Service =
   <Self>() =>
   <Id extends string, D extends ProtocolDefinition>(id: Id, definition: D): Client<Self, Id, D> => {
@@ -105,13 +116,13 @@ export const Service =
 
     const protocol = Protocol(definition)
 
-    const state = tag.asEffect().pipe(
+    const state = tag.pipe(
       Effect.flatMap(RcRef.get),
       Effect.map(({ state }) => state),
       Stream.unwrap,
     )
 
-    const events = tag.asEffect().pipe(
+    const events = tag.pipe(
       Effect.flatMap(RcRef.get),
       Effect.map(({ events }) => events),
       Stream.unwrap,
@@ -120,14 +131,14 @@ export const Service =
     const fn = ((_tag: keyof D["external"], ...f: Array<any>) =>
       Effect.fnUntraced(
         function* (payload: any) {
-          const { fnRaw: fn } = yield* tag.asEffect().pipe(Effect.flatMap(RcRef.get))
+          const { fnRaw: fn } = yield* tag.pipe(Effect.flatMap(RcRef.get))
           return yield* fn(_tag, payload)
         },
         Effect.scoped,
         ...(f as [any]),
       )) as Fn<Self, D["external"]>
 
-    const invalidate = tag.asEffect().pipe(
+    const invalidate = tag.pipe(
       Effect.flatMap((rc) =>
         RcRef.get(rc).pipe(
           Effect.flatMap(({ end }) => end),
@@ -140,7 +151,7 @@ export const Service =
 
     const reducer = <K extends keyof D["events"], R extends Reducer.Reducer<D, K>>(_event: K, f: R) => f
 
-    return Object.assign(tag, {
+    return Object.assign(tag satisfies Context.ServiceClass.Shape<Id, Service<Self, D>> as never, {
       [TypeId]: TypeId,
       definition,
       protocol,
@@ -263,6 +274,8 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, Reducers ex
                   const current = yield* Ref.get(state)
                   const reduced = yield* reducer(event as never)(current).pipe(
                     Effect.provideService(client, rcr),
+                    // TODO: rework error-handling
+                    Effect.catchDefect(() => Effect.succeed(undefined)),
                   ) as Effect.Effect<
                     S.Struct<D["state"]>["Type"] | undefined,
                     never,
@@ -275,7 +288,7 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, Reducers ex
                 }).pipe(reduceTask)
                 const parent = message.trace ? Tracer.externalSpan(message.trace) : undefined
                 yield* publishTake([event], true).pipe(
-                  span("enqueue-event", {
+                  Boundary.span("enqueue-event", import.meta.url, {
                     attributes: { _tag },
                     kind: "consumer",
                     parent,
@@ -431,12 +444,12 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, Reducers ex
                 Effect.flatMap(
                   (exit): Effect.Effect<never, ClientError | UnresolvedError | S.SchemaError> =>
                     Exit.match(exit, {
-                      onSuccess: () => new UnresolvedError().asEffect(),
+                      onSuccess: () => new UnresolvedError(),
                       onFailure: flow(
                         Cause.findError,
                         Result.match({
                           onSuccess: Effect.fail,
-                          onFailure: () => new UnresolvedError().asEffect(),
+                          onFailure: () => new UnresolvedError(),
                         }),
                       ),
                     }),
@@ -444,7 +457,7 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, Reducers ex
               ),
             )
           }).pipe(
-            span("fn", {
+            Boundary.span("fn", import.meta.url, {
               kind: "client",
               attributes: { _tag },
             }),
@@ -452,12 +465,25 @@ const make = <Self, Id extends string, D extends ProtocolDefinition, Reducers ex
           )
 
         return { state, events, fnRaw, end }
-      }).pipe(span("acquire", { attributes: { client: client.key } }), Effect.annotateLogs("client", client.key)),
+      }).pipe(
+        Boundary.span("acquire", import.meta.url, {
+          attributes: { client: client.key },
+        }),
+        Effect.annotateLogs("client", client.key),
+      ),
     })
 
     return rcr
   }).pipe(Layer.effect(client))
 
+let clientId_: string | undefined
+const clientId = () => {
+  if (!clientId_) {
+    clientId_ = crypto.randomUUID()
+  }
+  return clientId_
+}
+
 export const layerSocket = <
   Self,
   Id extends string,
@@ -498,41 +524,51 @@ export const layerSocket = <
     replay,
     build: Effect.gen(function* () {
       const socket = yield* Socket.makeWebSocket(url ?? "/", {
-        protocols: ["liminal", Encoding.encodeBase64Url(client.key), ...(protocols ? Array.ensure(protocols) : [])],
+        protocols: [
+          "liminal",
+          clientId(),
+          Encoding.encodeBase64Url(client.key),
+          ...(protocols ? Array.ensure(protocols) : []),
+        ],
       })
       return {
-        listen: Effect.fnUntraced(function* (publish) {
-          yield* socket
-            .runRaw((raw) =>
-              pipe(
-                raw instanceof Uint8Array ? new TextDecoder().decode(raw) : raw,
-                decodeActor,
-                Effect.andThen(publish),
-              ),
-            )
-            .pipe(
-              Effect.catchIf(
-                Socket.isSocketError,
-                Effect.fnUntraced(function* (cause) {
-                  const { reason } = cause
-                  if (reason._tag === "SocketCloseError" && reason.code === 1000) {
-                    return yield* publish({ _tag: "Disconnect" })
-                  }
-                  yield* Effect.annotateLogs(Effect.logDebug(`SocketErrored.${reason._tag}`), { cause })
-                  return yield* new ConnectionError({ cause })
-                }),
-              ),
-            )
-        }, span("listen")),
+        listen: Effect.fnUntraced(
+          function* (publish) {
+            yield* socket
+              .runRaw((raw) =>
+                pipe(
+                  raw instanceof Uint8Array ? new TextDecoder().decode(raw) : raw,
+                  decodeActor,
+                  Effect.andThen(publish),
+                ),
+              )
+              .pipe(
+                Effect.catchIf(
+                  Socket.isSocketError,
+                  Effect.fnUntraced(function* (cause) {
+                    const { reason } = cause
+                    if (reason._tag === "SocketCloseError" && reason.code === 1000) {
+                      return yield* publish({ _tag: "Disconnect" })
+                    }
+                    yield* Effect.annotateLogs(Effect.logDebug(`SocketErrored.${reason._tag}`), { cause })
+                    return yield* new ConnectionError({ cause })
+                  }),
+                ),
+              )
+          },
+          Boundary.span("listen", import.meta.url),
+        ),
         send: Effect.fnUntraced(
           function* (v) {
             const write = yield* socket.writer
             const message = yield* encodeFPayload(v)
             yield* write(message).pipe(
-              Effect.catchTag("SocketError", (cause) => new ConnectionError({ cause }).asEffect()),
+              Effect.catchTags({
+                SocketError: (cause) => new ConnectionError({ cause }),
+              }),
             )
           },
-          span("send"),
+          Boundary.span("send", import.meta.url),
           Effect.scoped,
         ),
       }
@@ -563,52 +599,67 @@ export const layerWorker = <
   | Worker.WorkerPlatform
   | Worker.Spawner
   | T["Actor"]["DecodingServices"]
-  | T["F"]["Payload"]["EncodingServices"]
+  | T["Client"]["EncodingServices"]
   | Reducer.Reducers.Services<Self, Reducers>
-> =>
-  make<Self, Id, D, Reducers, Worker.WorkerPlatform | Worker.Spawner, CR>({
+> => {
+  const { Actor, Client: ClientM } = client.protocol
+  const encodeClient = encodeJsonString(ClientM)
+  const decodeActor = decodeJsonString(Actor)
+
+  return make<Self, Id, D, Reducers, Worker.WorkerPlatform | Worker.Spawner, CR>({
     client,
     reducers,
     onConnect,
     replay,
     build: Effect.gen(function* () {
       const platform = yield* Worker.WorkerPlatform
-      const backing = yield* platform
-        .spawn<T["Actor"]["Type"], T["Client"]["Type"]>(0)
-        .pipe(Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()))
+      const backing = yield* platform.spawn<string, string>(0).pipe(
+        Effect.catchTags({
+          WorkerError: (cause) => new ConnectionError({ cause }),
+        }),
+      )
 
       const send = (message: T["Client"]["Type"]) =>
-        backing.send(message).pipe(
-          Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()),
-          span("send"),
+        encodeClient(message).pipe(
+          Effect.flatMap((encoded) => backing.send(encoded)),
+          Effect.catchTags({
+            WorkerError: (cause) => new ConnectionError({ cause }),
+          }),
+          Boundary.span("send", import.meta.url),
         )
 
       return {
-        listen: Effect.fnUntraced(function* (publish) {
-          const stop = yield* Deferred.make<void>()
-          yield* backing
-            .run(
-              Effect.fnUntraced(function* (message) {
-                yield* publish(message)
-                if (message._tag === "Disconnect" || message._tag === "Audition.Failure") {
-                  yield* Deferred.succeed(stop, void 0)
-                }
-              }),
-              {
-                onSpawn: backing
-                  .send({
-                    _tag: "Audition.Payload",
-                    client: client.key,
-                  })
-                  .pipe(Effect.orDie),
-              },
-            )
-            .pipe(
-              Effect.raceFirst(Deferred.await(stop)),
-              Effect.catchTag("WorkerError", (cause) => new ConnectionError({ cause }).asEffect()),
-            )
-        }, span("listen")),
+        listen: Effect.fnUntraced(
+          function* (publish) {
+            const stop = yield* Deferred.make<void>()
+            const audition = yield* encodeClient({
+              _tag: "Audition.Payload",
+              client: client.key,
+            })
+            yield* backing
+              .run(
+                Effect.fnUntraced(function* (raw) {
+                  const message = yield* decodeActor(raw)
+                  yield* publish(message)
+                  if (message._tag === "Disconnect" || message._tag === "Audition.Failure") {
+                    yield* Deferred.succeed(stop, void 0)
+                  }
+                }),
+                {
+                  onSpawn: backing.send(audition).pipe(Effect.orDie),
+                },
+              )
+              .pipe(
+                Effect.raceFirst(Deferred.await(stop)),
+                Effect.catchTags({
+                  WorkerError: (cause) => new ConnectionError({ cause }),
+                }),
+              )
+          },
+          Boundary.span("listen", import.meta.url),
+        ),
         send,
       }
     }),
   })
+}