liminal 0.17.14 → 0.17.15

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,39 +1,19 @@
-import { DurableObject } from "cloudflare:workers"
-import {
-  Layer,
-  Effect,
-  Scope,
-  Schema as S,
-  Context,
-  ManagedRuntime,
-  ConfigProvider,
-  Duration,
-  flow,
-  String,
-  Array,
-  Encoding,
-  Option,
-  Cause,
-} 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,
@@ -41,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 layer: Layer.Layer<RunROut, RunE, ActorSelf | HttpClient.HttpClient | PreludeROut>
+  readonly binding: string
 
-  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 internal: Internal
 
-  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,
@@ -89,48 +40,44 @@ export interface ActorNamespace<
   ClientSelf,
   ClientId extends string,
   D extends ProtocolDefinition,
-  PreludeROut,
-  PreludeE,
-  RunROut,
-  RunE,
 > {
-  new (state: DurableObjectState<{}>, env: Cloudflare.Env): DurableObject
-
-  readonly service: Context.ServiceClass<NamespaceSelf, 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 | Encoding.EncodingError | Cause.NoSuchElementError,
-    | NamespaceSelf
-    | NativeRequest.NativeRequest
-    | Name["EncodingServices"]
-    | S.Struct<AttachmentFields>["EncodingServices"]
-  >
+  readonly bind: (name: Name["Type"]) => ActorHandle<NamespaceSelf, Internal, Name, AttachmentFields>
+
+  readonly layer: Layer.Layer<NamespaceSelf, S.SchemaError, never>
+}
 
-  readonly layer: (binding: string) => 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,
@@ -138,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, onConnect } = definition
+    const { binding, actor } = definition
     const {
       definition: {
         name: Name,
@@ -181,160 +109,25 @@ export const Service =
       },
     } = actor
 
-    const encodeName = S.encodeEffect(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 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)))),
-    }
 
-    class NameDecoded extends Context.Service<NameDecoded, Name["Type"]>()(
-      "liminal/WorkerdActorNamespace/NameDecoded",
-    ) {}
+    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)
+      })
 
-    return class extends DurableObject {
-      static definition = definition
-      static service = Context.Service<NamespaceSelf, DurableObjectNamespace>()(id)
-      static layer = Binding.layer(this.service, ["idFromName", "idFromString", "newUniqueId", "get"])
-
-      readonly runtime
-      readonly directory = ClientDirectory.make(actor, transport)
-
-      constructor(state: DurableObjectState<{}>, env: Cloudflare.Env) {
-        super(state, env)
-        if (hibernation) {
-          Option.andThen(
-            Duration.fromInput(hibernation),
-            flow(Duration.toMillis, state.setHibernatableWebSocketEventTimeout),
-          )
-        }
-
-        const Live = Layer.mergeAll(
-          FetchHttpClient.layer,
-          Layer.succeed(DoState.DoState, state),
-          Mutex.layer,
-          Layer.effect(NameDecoded, S.decodeUnknownEffect(Name)(state.id.name)).pipe(
-            Layer.provideMerge(prelude.pipe(Layer.provideMerge(ConfigProvider.layer(ConfigProvider.fromUnknown(env))))),
-          ),
-        ).pipe(boundLayer("actor"))
-
-        const hydrateAttachments = Effect.gen({ self: this }, function* () {
-          for (const socket of state.getWebSockets()) {
-            const attachments = yield* decodeAttachments(socket.deserializeAttachment())
-            yield* this.directory.register(socket, attachments)
-          }
-        }).pipe(span("hydrateAttachments"), Effect.tapCause(logCause))
-
-        this.runtime = hydrateAttachments.pipe(Layer.effectDiscard, Layer.provideMerge(Live), ManagedRuntime.make)
-      }
-
-      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 { 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 name = yield* NameDecoded
-          const ActorLive = Layer.succeed(actor, {
-            name,
-            clients: this.directory.handles,
-            currentClient,
-          })
-          yield* onConnect.pipe(
-            Effect.scoped,
-            span("onConnect"),
-            Effect.scoped,
-            Effect.provide(Layer.provideMerge(layer, ActorLive)),
-          )
-          yield* debug("ClientRegistered")
-          return new Response(null, {
-            status: 101,
-            webSocket,
-            headers: { [SecWebSocketProtocol]: "liminal" },
-          })
-        }).pipe(Effect.tapCause(logCause), span("fetch"), this.runtime.runPromise)
-      }
-
-      override webSocketMessage(socket: WebSocket, raw: string | ArrayBuffer) {
+      const upgrade = (attachments: S.Struct<AttachmentFields>["Type"]) =>
         Effect.gen({ self: this }, function* () {
-          const currentClient = yield* this.directory.get(socket)
-          const name = yield* NameDecoded
-          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)
-          }
-          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(layer, ActorLive)),
-          )
-        }).pipe(Effect.scoped, Mutex.task, Effect.tapCause(logCause), span("webSocketMessage"), this.runtime.runFork)
-      }
-
-      override webSocketClose(socket: WebSocket, _code: number, _reason: string, _wasClean: boolean) {
-        this.directory
-          .unregister(socket)
-          .pipe(Effect.tap(debug("SocketClosed")), Effect.tapCause(logCause), this.runtime.runFork)
-      }
-
-      override 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)
-      }
-
-      static readonly upgrade = (name: Name["Type"], attachments: (typeof Attachments)["Type"]) =>
-        Effect.gen({ self: this }, function* () {
-          yield* debug("UpgradeInitiated", { attachments })
-          const namespace = yield* this.service
-          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))),
@@ -354,9 +147,28 @@ export const Service =
           }
           const url = new URL(request.url)
           url.searchParams.set("__liminal_attachments", yield* encodeAttachmentsString(attachments))
-          return yield* Effect.promise(() => stub.fetch(new Request(url, request))).pipe(
-            Effect.map(HttpServerResponse.raw),
-          )
-        }).pipe(span("upgrade"))
+          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)
+          }
+          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 layer = Binding.layer(tag, ["idFromName", "idFromString", "newUniqueId", "get", "getByName"])(binding)
+
+    return Object.assign(tag, { definition, bind, layer })
   }