liminal 0.17.14 → 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,22 @@
 # 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
+
+- ab30d60: Move accumulator api directly into client and implement internal actor method bindings.
+- Updated dependencies [ab30d60]
+  - effect-workerd@0.0.5
+
 ## 0.17.14
 
 ### Patch Changes