liminal 0.17.13 → 0.17.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "liminal",
-  "version": "0.17.13",
+  "version": "0.17.15",
   "description": "Effect x Actors",
   "bugs": {
     "url": "https://github.com/crosshatch/liminal/issues"
@@ -14,34 +14,19 @@
   "type": "module",
   "sideEffects": false,
   "exports": {
-    ".": {
-      "types": "./index.ts",
-      "default": "./dist/index.js"
-    },
-    "./*": {
-      "types": "./*.ts",
-      "default": "./dist/*.js"
-    },
-    "./browser": {
-      "types": "./browser/index.ts",
-      "default": "./dist/browser/index.js"
-    },
-    "./experimental": {
-      "types": "./experimental/index.ts",
-      "default": "./dist/experimental/index.js"
-    },
-    "./workerd": {
-      "types": "./workerd/index.ts",
-      "default": "./dist/workerd/index.js"
-    },
+    ".": "./dist/index.js",
+    "./*": "./dist/*.js",
+    "./browser": "./dist/browser/index.js",
+    "./experimental": "./dist/experimental/index.js",
+    "./workerd": "./dist/workerd/index.js",
     "./package.json": "./package.json"
   },
   "peerDependencies": {
     "@cloudflare/workers-types": "^4.20260414.1",
-    "@effect/platform-browser": "4.0.0-beta.50",
-    "@effect/sql-d1": "4.0.0-beta.50",
-    "effect": "4.0.0-beta.50",
-    "effect-workerd": "0.0.3",
+    "@effect/platform-browser": "4.0.0-beta.57",
+    "@effect/sql-d1": "4.0.0-beta.57",
+    "effect": "4.0.0-beta.57",
+    "effect-workerd": "0.0.5",
     "liminal-util": "0.0.9"
   }
 }

package/tsconfig.json

@@ -6,6 +6,6 @@
     "types": ["@cloudflare/workers-types"]
   },
   "include": [".", "package.json"],
-  "exclude": ["dist"],
+  "exclude": ["dist", "vitest.config.ts"],
   "references": [{ "path": "../effect-workerd" }, { "path": "../liminal-util" }]
 }

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { mergeConfig, type ViteUserConfig } from "vitest/config"
+
+import config from "../konfik/vitest.ts"
+
+export default mergeConfig(config, {
+  test: { name: "liminal" },
+} satisfies ViteUserConfig)

package/workerd/ActorHandle.ts

@@ -0,0 +1,29 @@
+import { Schema as S, Effect, Cause, Encoding } from "effect"
+import { NativeRequest } from "effect-workerd"
+import { HttpServerResponse } from "effect/unstable/http"
+
+import type { TopFromString } from "../_util/schema.ts"
+import type { Methods } from "../Method.ts"
+
+export interface ActorHandle<
+  NamespaceSelf,
+  Internal extends Methods,
+  Name extends TopFromString,
+  AttachmentFields extends S.Struct.Fields,
+> {
+  readonly upgrade: (
+    attachments: S.Struct<AttachmentFields>["Type"],
+  ) => Effect.Effect<
+    HttpServerResponse.HttpServerResponse,
+    S.SchemaError | Encoding.EncodingError | Cause.NoSuchElementError,
+    | NamespaceSelf
+    | NativeRequest.NativeRequest
+    | Name["EncodingServices"]
+    | S.Struct<AttachmentFields>["EncodingServices"]
+  >
+
+  readonly call: <K extends keyof Internal, M extends Internal[K]>(
+    method: K,
+    payload: M["payload"]["Type"],
+  ) => Effect.Effect<M["success"]["Type"], M["failure"]["Type"], NamespaceSelf>
+}

package/workerd/WorkerdActorNamespace.ts

@@ -1,37 +1,19 @@
-import {
-  Layer,
-  Effect,
-  Scope,
-  Schema as S,
-  Context,
-  ManagedRuntime,
-  ConfigProvider,
-  Duration,
-  flow,
-  String,
-  Array,
-  Encoding,
-  Option,
-} from "effect"
-import { Binding, DoState, NativeRequest } from "effect-workerd"
+import { Layer, Effect, Schema as S, Context, flow, String, Array, Encoding, Exit } from "effect"
+import { Binding, NativeRequest } from "effect-workerd"
 import { SecWebSocketProtocol, close } from "effect-workerd/socket_util"
-import { HttpServerResponse, HttpClient, FetchHttpClient } from "effect/unstable/http"
-import { boundLayer } from "liminal-util/boundLayer"
-import { logCause } from "liminal-util/logCause"
+import { HttpServerResponse, HttpTraceContext } from "effect/unstable/http"
+import * as Spanner from "liminal-util/Spanner"
 
+import { type TopFromString, encodeJsonString } from "../_util/schema.ts"
 import type { Actor } from "../Actor.ts"
-import type { ActorTransport } from "../ActorTransport.ts"
+import type { Methods } from "../Method.ts"
 import type { ProtocolDefinition } from "../Protocol.ts"
+import type { ActorHandle } from "./ActorHandle.ts"
 
-import { diagnostic } from "../_diagnostic.ts"
-import * as Mutex from "../_util/Mutex.ts"
-import { type TopFromString, encodeJsonString, decodeJsonString } from "../_util/schema.ts"
-import * as ClientDirectory from "../ClientDirectory.ts"
-import * as Method from "../Method.ts"
-
-const { debug, span } = diagnostic("workerd.WorkerdActorNamespace")
+const span = Spanner.make(import.meta.url)
 
 export interface ActorNamespaceDefinition<
+  Internal extends Methods,
   ActorSelf,
   ActorId extends string,
   Name extends TopFromString,
@@ -39,47 +21,18 @@ export interface ActorNamespaceDefinition<
   ClientSelf,
   ClientId extends string,
   D extends ProtocolDefinition,
-  PreludeROut,
-  PreludeE,
-  RunROut,
-  RunE,
 > {
-  readonly ""?: this["actor"]["definition"]["client"]["protocol"]
-
-  readonly actor: Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>
-
-  readonly prelude: Layer.Layer<
-    | PreludeROut
-    | NonNullable<this[""]>["F"]["Payload"]["DecodingServices"]
-    | NonNullable<this[""]>["F"]["Success"]["EncodingServices"]
-    | NonNullable<this[""]>["F"]["Failure"]["EncodingServices"]
-    | NonNullable<this[""]>["Event"]["EncodingServices"]
-    | S.Struct<AttachmentFields>["DecodingServices"]
-    | S.Struct<AttachmentFields>["EncodingServices"]
-    | Name["EncodingServices"]
-    | Name["DecodingServices"],
-    PreludeE
-  >
+  readonly binding: string
 
-  readonly layer: Layer.Layer<RunROut, RunE, ActorSelf | HttpClient.HttpClient | PreludeROut>
+  readonly internal: Internal
 
-  readonly handlers: Method.Handlers<
-    D["methods"],
-    ActorSelf | HttpClient.HttpClient | PreludeROut | RunROut | Scope.Scope
-  >
-
-  readonly onConnect: Effect.Effect<
-    void,
-    never,
-    ActorSelf | HttpClient.HttpClient | PreludeROut | RunROut | Scope.Scope
-  >
-
-  readonly hibernation?: Duration.Input | undefined
+  readonly actor: Actor<ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>
 }
 
 export interface ActorNamespace<
   NamespaceSelf,
   NamespaceId extends string,
+  Internal extends Methods,
   ActorSelf,
   ActorId extends string,
   Name extends TopFromString,
@@ -87,39 +40,44 @@ export interface ActorNamespace<
   ClientSelf,
   ClientId extends string,
   D extends ProtocolDefinition,
-  PreludeROut,
-  PreludeE,
-  RunROut,
-  RunE,
-> extends Context.Service<NamespaceSelf, DurableObjectNamespace> {
-  new (state: globalThis.DurableObjectState<{}>): Context.ServiceClass.Shape<NamespaceId, DurableObjectNamespace>
+> {
+  new (
+    _: never,
+  ): Context.ServiceClass.Shape<
+    NamespaceId,
+    DurableObjectNamespace<Rpc.DurableObjectBranded & WorkerdActorNamespace.MakeRpc<Internal>>
+  >
 
   readonly definition: ActorNamespaceDefinition<
+    Methods,
     ActorSelf,
     ActorId,
     Name,
     AttachmentFields,
     ClientSelf,
     ClientId,
-    D,
-    PreludeROut,
-    PreludeE,
-    RunROut,
-    RunE
+    D
   >
 
-  readonly upgrade: (
-    name: Name["Type"],
-    attachments: S.Struct<AttachmentFields>["Type"],
-  ) => Effect.Effect<HttpServerResponse.HttpServerResponse, S.SchemaError, NamespaceSelf | NativeRequest.NativeRequest>
+  readonly bind: (name: Name["Type"]) => ActorHandle<NamespaceSelf, Internal, Name, AttachmentFields>
 
-  readonly layer: (binding: string) => Layer.Layer<NamespaceSelf, S.SchemaError, never>
+  readonly layer: Layer.Layer<NamespaceSelf, S.SchemaError, never>
+}
+
+export declare namespace WorkerdActorNamespace {
+  export type MakeRpc<External extends Methods> = {
+    rpc: <K extends keyof External>(
+      method: K,
+      payload: External[K]["payload"]["Type"],
+    ) => Promise<Exit.Exit<External[K]["success"]["Type"], External[K]["failure"]["Type"]>>
+  }
 }
 
 export const Service =
   <NamespaceSelf>() =>
   <
     NamespaceId extends string,
+    Internal extends Methods,
     ActorSelf,
     ActorId extends string,
     Name extends TopFromString,
@@ -127,41 +85,22 @@ export const Service =
     ClientSelf,
     ClientId extends string,
     D extends ProtocolDefinition,
-    PreludeROut,
-    PreludeE,
-    RunROut,
-    RunE,
   >(
     id: NamespaceId,
-    definition: ActorNamespaceDefinition<
-      ActorSelf,
-      ActorId,
-      Name,
-      AttachmentFields,
-      ClientSelf,
-      ClientId,
-      D,
-      PreludeROut,
-      PreludeE,
-      RunROut,
-      RunE
-    >,
+    definition: ActorNamespaceDefinition<Internal, ActorSelf, ActorId, Name, AttachmentFields, ClientSelf, ClientId, D>,
   ): ActorNamespace<
     NamespaceSelf,
     NamespaceId,
+    Internal,
     ActorSelf,
     ActorId,
     Name,
     AttachmentFields,
     ClientSelf,
     ClientId,
-    D,
-    PreludeROut,
-    PreludeE,
-    RunROut,
-    RunE
+    D
   > => {
-    const { hibernation, actor, prelude, handlers, layer: runLayer, onConnect } = definition
+    const { binding, actor } = definition
     const {
       definition: {
         name: Name,
@@ -170,192 +109,66 @@ export const Service =
       },
     } = actor
 
-    const encodeName = S.encodeEffect(Name)
-    const decodeName = S.decodeUnknownEffect(Name)
+    const tag = Context.Service<
+      NamespaceSelf,
+      DurableObjectNamespace<Rpc.DurableObjectBranded & WorkerdActorNamespace.MakeRpc<Internal>>
+    >()(id)
 
+    const encodeName = S.encodeEffect(Name)
     const Attachments = S.Struct(AttachmentFields)
-    const encodeAttachments = S.encodeEffect(S.toCodecJson(Attachments))
-    const decodeAttachments = S.decodeUnknownEffect(S.toCodecJson(Attachments))
     const encodeAttachmentsString = encodeJsonString(Attachments)
-    const decodeAttachmentsString = decodeJsonString(Attachments)
-
-    const encodeAuditionSuccess = encodeJsonString(P.Audition.Success)
     const encodeAuditionFailure = encodeJsonString(P.Audition.Failure)
-    const decodeClientM = decodeJsonString(P.Client)
-    const encodeFSuccess = encodeJsonString(P.F.Success)
-    const encodeFFailure = encodeJsonString(P.F.Failure)
 
-    const encodeEvent = encodeJsonString(P.Event)
+    const bind = (name: Name["Type"]): ActorHandle<NamespaceSelf, Internal, Name, AttachmentFields> => {
+      const getStub = Effect.gen(function* () {
+        const namespace = yield* tag
+        const nameEncoded = yield* encodeName(name)
+        return namespace.getByName(nameEncoded)
+      })
 
-    const transport: ActorTransport<WebSocket, AttachmentFields, D> = {
-      send: (socket, event) => encodeEvent(event).pipe(Effect.andThen((v) => Effect.sync(() => socket.send(v)))),
-      close: (socket) => Effect.sync(() => socket.close(1000)),
-      snapshot: (socket, attachments) =>
-        encodeAttachments(attachments).pipe(Effect.andThen((v) => Effect.sync(() => socket.serializeAttachment(v)))),
-    }
-
-    const tag = class tag extends Context.Service<NamespaceSelf, DurableObjectNamespace>()(id) {
-      readonly runtime
-      readonly directory = ClientDirectory.make(actor, transport)
-
-      constructor(...args: [never]) {
-        super(...args)
-        const [state, env] = args as never as [state: globalThis.DurableObjectState<{}>, env: unknown]
-
-        if (hibernation) {
-          Option.andThen(
-            Duration.fromInput(hibernation),
-            flow(Duration.toMillis, state.setHibernatableWebSocketEventTimeout),
+      const upgrade = (attachments: S.Struct<AttachmentFields>["Type"]) =>
+        Effect.gen({ self: this }, function* () {
+          const request = yield* NativeRequest.NativeRequest
+          const protocols = yield* Effect.fromNullishOr(request.headers.get(SecWebSocketProtocol)).pipe(
+            Effect.map(flow(String.split(","), Array.map(String.trim))),
           )
-        }
-
-        const baseLayer = Layer.mergeAll(
-          prelude.pipe(Layer.provideMerge(ConfigProvider.layer(ConfigProvider.fromUnknown(env)))),
-          FetchHttpClient.layer,
-          Layer.succeed(DoState.DoState, state),
-          Mutex.layer,
-        )
-
-        this.runtime = Effect.gen({ self: this }, function* () {
-          this.#name = yield* Effect.tryPromise(() => state.storage.get("__liminal_name")).pipe(
-            Effect.flatMap((v) => (typeof v === "string" ? decodeName(v) : Effect.succeed(undefined))),
+          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()),
           )
-          for (const socket of state.getWebSockets()) {
-            const attachments = yield* decodeAttachments(socket.deserializeAttachment())
-            yield* this.directory.register(socket, attachments)
+          if (requestClientId !== clientId) {
+            return close(
+              yield* encodeAuditionFailure({
+                _tag: "Audition.Failure",
+                expected: clientId,
+                actual: requestClientId,
+              }),
+            )
           }
-        }).pipe(
-          Effect.tapCause(logCause),
-          span("make_runtime"),
-          Layer.effectDiscard,
-          Layer.provideMerge(baseLayer),
-          boundLayer("actor"),
-          ManagedRuntime.make,
-        )
-      }
-
-      #name?: Name["Type"] | undefined
-      fetch(request: Request): Promise<Response> {
-        return Effect.gen({ self: this }, function* () {
           const url = new URL(request.url)
-          const name = yield* decodeName(url.searchParams.get("__liminal_name"))
-          const attachments = yield* decodeAttachmentsString(url.searchParams.get("__liminal_attachments"))
-          if (!this.#name) {
-            this.#name = name
-            const state = yield* DoState.DoState
-            const encoded = yield* S.encodeEffect(Name)(name)
-            yield* Effect.promise(() => state.storage.put("__liminal_name", encoded))
-          }
-          const { 0: webSocket, 1: server } = new WebSocketPair()
-          const state = yield* DoState.DoState
-          state.acceptWebSocket(server)
-          server.send(yield* encodeAuditionSuccess({ _tag: "Audition.Success" }))
-          const currentClient = yield* this.directory.register(server, attachments)
-          const ActorLive = Layer.succeed(actor, {
-            name,
-            clients: this.directory.handles,
-            currentClient,
-          })
-          yield* onConnect.pipe(
-            Effect.scoped,
-            span("onConnect"),
-            Effect.scoped,
-            Effect.provide(Layer.provideMerge(runLayer, ActorLive)),
-          )
-          yield* debug("ClientRegistered")
-          return new Response(null, {
-            status: 101,
-            webSocket,
-            headers: { [SecWebSocketProtocol]: "liminal" },
-          })
-        }).pipe(Effect.tapCause(logCause), span("fetch"), this.runtime.runPromise)
-      }
-
-      webSocketMessage(socket: WebSocket, raw: string | ArrayBuffer) {
-        Effect.gen({ self: this }, function* () {
-          const currentClient = yield* this.directory.get(socket)
-          const name = yield* Effect.fromNullishOr(this.#name)
-          const ActorLive = Layer.succeed(actor, {
-            name,
-            clients: this.directory.handles,
-            currentClient,
-          })
-          const message = yield* decodeClientM(raw instanceof ArrayBuffer ? new TextDecoder().decode(raw) : raw)
-          yield* debug("MessageReceived", { message })
-          if (message._tag === "Audition.Payload") {
-            return yield* Effect.die(undefined)
+          url.searchParams.set("__liminal_attachments", yield* encodeAttachmentsString(attachments))
+          const actorRequest = new Request(url, request)
+          const traceHeaders = yield* Effect.currentSpan.pipe(Effect.map(HttpTraceContext.toHeaders))
+          for (const [key, value] of Object.entries(traceHeaders)) {
+            actorRequest.headers.set(key, value)
           }
-          if (message._tag === "Disconnect") {
-            return yield* currentClient.disconnect
-          }
-          const { id, payload } = message
-          const { _tag, value } = payload as never
-          yield* handlers[_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,
-                }),
-            }),
-            span("handler", { attributes: { _tag } }),
-            Effect.andThen((v) => Effect.sync(() => socket.send(v))),
-            Effect.scoped,
-            Effect.provide(Layer.provideMerge(runLayer, ActorLive)),
-          )
-        }).pipe(Effect.scoped, Mutex.task, Effect.tapCause(logCause), span("webSocketMessage"), this.runtime.runFork)
-      }
-
-      webSocketClose(socket: WebSocket, _code: number, _reason: string, _wasClean: boolean) {
-        this.directory
-          .unregister(socket)
-          .pipe(Effect.tap(debug("SocketClosed")), Effect.tapCause(logCause), this.runtime.runFork)
-      }
-
-      webSocketError(socket: WebSocket, cause: unknown) {
-        Effect.gen({ self: this }, function* () {
-          yield* debug("SocketErrored", { cause })
-          yield* this.directory.unregister(socket)
-        }).pipe(Effect.tapCause(logCause), span("SocketErrored", { attributes: { cause } }), this.runtime.runFork)
-      }
+          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
+      })
+
+      return { upgrade, call }
     }
 
-    const upgrade = Effect.fnUntraced(function* (name: Name["Type"], attachments: (typeof Attachments)["Type"]) {
-      yield* debug("UpgradeInitiated", { attachments })
-      const namespace = yield* tag
-      const nameEncoded = yield* encodeName(name)
-      const stub = namespace.getByName(nameEncoded)
-      const request = yield* NativeRequest.NativeRequest
-      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()),
-      )
-      if (requestClientId !== clientId) {
-        return close(
-          yield* encodeAuditionFailure({
-            _tag: "Audition.Failure",
-            expected: clientId,
-            actual: requestClientId,
-          }),
-        )
-      }
-      const url = new URL(request.url)
-      url.searchParams.set("__liminal_name", nameEncoded)
-      url.searchParams.set("__liminal_attachments", yield* encodeAttachmentsString(attachments))
-      return yield* Effect.promise(() => stub.fetch(new Request(url, request))).pipe(Effect.map(HttpServerResponse.raw))
-    }, span("upgrade"))
-
-    const layer = Binding.layer(tag, ["getByName"])
+    const layer = Binding.layer(tag, ["idFromName", "idFromString", "newUniqueId", "get", "getByName"])(binding)
 
-    return Object.assign(tag, { definition, upgrade, layer }) as never
+    return Object.assign(tag, { definition, bind, layer })
   }