alchemy 2.0.0-beta.44 → 2.0.0-beta.45

package/lib/Cloudflare/Workers/RpcDurableObjectNamespace.d.ts

@@ -0,0 +1,285 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type * as Layer from "effect/Layer";
+import type { Rpc, RpcGroup } from "effect/unstable/rpc";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as RpcClientError from "effect/unstable/rpc/RpcClientError";
+import type { Dependencies } from "../../Dependencies.ts";
+import type { HttpEffect } from "../../Http.ts";
+import type { Input } from "../../Input.ts";
+import { type DurableObjectNamespaceLike, type DurableObjectNamespaceProps, type DurableObjectNamespace as DurableObjectNamespaceType, type DurableObjectServices } from "./DurableObjectNamespace.ts";
+import type { DurableObjectState } from "./DurableObjectState.ts";
+import type { Worker as WorkerService } from "./Worker.ts";
+/**
+ * The runtime value bound to a typed rpc Durable Object namespace.
+ * Same shape as the underlying {@link DurableObjectNamespaceType} for
+ * binding metadata (name, namespaceId, kind), but `getByName(id)`
+ * returns a typed Effect `RpcClient` over the rpc server living on
+ * the DO's `fetch` handler.
+ */
+export interface RpcDurableObjectNamespace<Self, Rpcs extends Rpc.Any = Rpc.Any> extends Omit<DurableObjectNamespaceType<{
+    fetch: HttpEffect<DurableObjectState>;
+}>, "getByName" | "get" | "Shape"> {
+    /** @internal phantom — keeps `Self` reachable through the inferred type */
+    Self?: Self;
+    readonly getByName: (id: string) => Effect.Effect<RpcClient.RpcClient<Rpcs, RpcClientError.RpcClientError>, never, Rpc.MiddlewareClient<Rpcs>>;
+}
+declare const RpcDurableObjectNamespaceScope_base: Context.ServiceClass<RpcDurableObjectNamespaceScope, "Cloudflare.RpcDurableObjectNamespace", RpcDurableObjectNamespace<unknown, Rpc.Any>>;
+export declare class RpcDurableObjectNamespaceScope extends RpcDurableObjectNamespaceScope_base {
+}
+export interface RpcDurableObjectNamespaceClass extends Effect.Effect<RpcDurableObjectNamespace<unknown>, never, RpcDurableObjectNamespaceScope> {
+    /**
+     * Class-based forms: `class Counter extends RpcDurableObjectNamespace<Counter>()(...)`.
+     *
+     * Modular (no impl):
+     * ```ts
+     * class Counter extends RpcDurableObjectNamespace<Counter>()(
+     *   "Counter",
+     *   { schema: CounterRpcs },
+     * ) {}
+     * export const CounterLive = Counter.make(/* impl *\/);
+     * ```
+     * Inline impl:
+     * ```ts
+     * class Counter extends RpcDurableObjectNamespace<Counter>()(
+     *   "Counter",
+     *   { schema: CounterRpcs },
+     *   Effect.gen(function* () { ... }),
+     * ) {}
+     * ```
+     */
+    <Self>(): {
+        /** Modular form: separate `static make(impl)` + `static from(scriptName | Worker)`. */
+        <Rpcs extends Rpc.Any>(name: string, props: {
+            readonly schema: RpcGroup.RpcGroup<Rpcs>;
+        }): Effect.Effect<RpcDurableObjectNamespace<Self, Rpcs>, never, WorkerService | Self> & {
+            new (_: never): {};
+            from(scriptName: Input<string>): Effect.Effect<RpcDurableObjectNamespace<Self, Rpcs>, never, WorkerService>;
+            from<Req = never>(worker: Dependencies<Self> | Effect.Effect<Dependencies<Self>, never, Req>): Effect.Effect<RpcDurableObjectNamespace<Self, Rpcs>, never, WorkerService | Req>;
+            make<InnerR = never, InitReq = never>(impl: Effect.Effect<Effect.Effect<Effect.Effect<HttpEffect<InnerR>, never, InnerR>, never, DurableObjectServices>, never, InitReq>): Layer.Layer<Self, never, WorkerService | Exclude<InitReq | InnerR, DurableObjectServices>>;
+        };
+        /** Inline-impl form. */
+        <Rpcs extends Rpc.Any, InnerR = never, InitReq = never>(name: string, props: {
+            readonly schema: RpcGroup.RpcGroup<Rpcs>;
+        }, impl: Effect.Effect<Effect.Effect<Effect.Effect<HttpEffect<InnerR>, never, InnerR>, never, DurableObjectServices>, never, InitReq>): Effect.Effect<RpcDurableObjectNamespace<Self, Rpcs>, never, WorkerService | Exclude<InitReq | InnerR, DurableObjectServices>> & {
+            new (_: never): {};
+        };
+    };
+    /** Descriptor-only form, for `worker.bind` declarations */
+    <Rpcs extends Rpc.Any>(name: string, props: {
+        readonly schema: RpcGroup.RpcGroup<Rpcs>;
+    } & Partial<DurableObjectNamespaceProps>): DurableObjectNamespaceLike<{
+        fetch: HttpEffect<DurableObjectState>;
+    }>;
+    /** Bare form: `(name, { schema }, impl)` */
+    <Rpcs extends Rpc.Any, InnerR = never, InitReq = never>(name: string, props: {
+        readonly schema: RpcGroup.RpcGroup<Rpcs>;
+    }, impl: Effect.Effect<Effect.Effect<Effect.Effect<HttpEffect<InnerR>, never, InnerR>, never, DurableObjectServices>, never, InitReq>): Effect.Effect<RpcDurableObjectNamespace<unknown, Rpcs>, never, WorkerService | Exclude<InitReq | InnerR, DurableObjectServices>>;
+}
+/**
+ * `RpcDurableObjectNamespace` is sugar over {@link DurableObjectNamespace}
+ * for Durable Objects whose surface is a typed Effect `RpcGroup`. The
+ * DO serves an `RpcServer.toHttpEffect(group)` on its own `fetch`, and
+ * consumers see `namespace.getByName(id)` as a typed `RpcClient`
+ * directly — no manual client wiring.
+ *
+ * Use this over alchemy's built-in DO method bridge whenever values
+ * crossing the DO boundary contain `Schema.Class` instances. The
+ * built-in bridge `JSON.stringify`s every method return value, which
+ * strips class identity (e.g. an `effect/ai` `Response.Usage` instance
+ * becomes a plain struct on the consumer side). With
+ * `RpcDurableObjectNamespace`, both ends go through the same
+ * `RpcSerialization` codec, so `Schema.decode` reconstructs class
+ * instances correctly.
+ *
+ * @resource
+ *
+ * @section Defining the rpc group
+ * @example DO-scoped rpc schemas
+ * The DO instance *is* the session, so the group payloads typically
+ * don't include any per-session identifier — only the per-call inputs.
+ * ```typescript
+ * import * as Schema from "effect/Schema";
+ * import { Rpc, RpcGroup } from "effect/unstable/rpc";
+ *
+ * const setTitle = Rpc.make("setTitle", {
+ *   success: Schema.Void,
+ *   payload: { title: Schema.String },
+ * });
+ *
+ * const getTitle = Rpc.make("getTitle", {
+ *   success: Schema.String,
+ *   payload: {},
+ * });
+ *
+ * export class CounterRpcs extends RpcGroup.make(setTitle, getTitle) {}
+ * ```
+ *
+ * @section Implementing the Durable Object
+ * @example Class form (recommended)
+ * Mirrors `Cloudflare.DurableObjectNamespace<Self>()(...)` — same
+ * outer/inner Effect pattern. The outer Effect resolves shared deps;
+ * the per-instance inner Effect returns the
+ * `RpcServer.toHttpEffect(schema)`-piped Effect directly.
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ * import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+ * import { CounterRpcs } from "./rpcs.ts";
+ *
+ * export default class Counter extends Cloudflare.RpcDurableObjectNamespace<Counter>()(
+ *   "Counter",
+ *   { schema: CounterRpcs },
+ *   Effect.gen(function* () {
+ *     // outer init: shared deps for all instances
+ *     return Effect.gen(function* () {
+ *       // per-instance init: state + handlers
+ *       const state = yield* Cloudflare.DurableObjectState;
+ *       const handlers = CounterRpcs.toLayer({
+ *         setTitle: ({ title }) => state.storage.put("title", title),
+ *         getTitle: () =>
+ *           Effect.map(state.storage.get<string>("title"), (t) => t ?? ""),
+ *       });
+ *       return RpcServer.toHttpEffect(CounterRpcs).pipe(
+ *         Effect.provide(Layer.mergeAll(handlers, RpcSerialization.layerNdjson)),
+ *       );
+ *     });
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @section Calling the DO from a Worker
+ * @example Typed rpc client at the call site
+ * `yield* Counter` resolves to a value whose `getByName(id)` returns
+ * an `Effect<RpcClient<CounterRpcs>>`. Each rpc method is a typed
+ * Effect/Stream factory — no `RpcClient.make` setup needed. Yield
+ * the client inside a per-request `Effect.scoped` handler so it's
+ * freed with the request.
+ * ```typescript
+ * import Counter from "./counter.ts";
+ *
+ * Effect.gen(function* () {
+ *   const counters = yield* Counter;
+ *   const client = yield* counters.getByName("global");
+ *   yield* client.setTitle({ title: "Hello" });
+ *   const title = yield* client.getTitle({});
+ *   return title;
+ * }).pipe(Effect.scoped);
+ * ```
+ *
+ * @section Modular form: separate the class from its runtime
+ * @example Class declaration with no impl + `static make(impl)`
+ * The inline class form above bundles the runtime into the class
+ * declaration. The two-arg form `(name, { schema })` declares the
+ * class as a pure tagged identifier; provide the runtime separately
+ * via `Class.make(impl)`. Consumer Workers can import the class for
+ * binding (`Counter.from(HostWorker)`) without pulling the runtime
+ * into their bundle.
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ * import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+ * import { CounterRpcs } from "./rpcs.ts";
+ *
+ * export class Counter extends Cloudflare.RpcDurableObjectNamespace<Counter>()(
+ *   "Counter",
+ *   { schema: CounterRpcs },
+ * ) {}
+ *
+ * // Only the host script imports this default export.
+ * export default Counter.make(
+ *   Effect.gen(function* () {
+ *     return Effect.gen(function* () {
+ *       const state = yield* Cloudflare.DurableObjectState;
+ *       const handlers = CounterRpcs.toLayer({
+ *         setTitle: ({ title }) => state.storage.put("title", title),
+ *         getTitle: () =>
+ *           Effect.map(state.storage.get<string>("title"), (t) => t ?? ""),
+ *       });
+ *       return RpcServer.toHttpEffect(CounterRpcs).pipe(
+ *         Effect.provide(Layer.mergeAll(handlers, RpcSerialization.layerNdjson)),
+ *       );
+ *     });
+ *   }),
+ * );
+ * ```
+ *
+ * @section Cross-script binding via `Counter.from(Worker)`
+ * @example Hosting on WorkerA, binding from WorkerB
+ * The host Worker declares `Counter` in its `Deps` (third type
+ * arg of `Worker<Self, Bindings, Deps>` or second of
+ * `RpcWorker<Self, Deps>`) and provides `CounterLive`. Any other
+ * Worker uses `Counter.from(HostWorker)` to bind to the same DO
+ * instances — writes through `HostWorker.getByName(name)` are
+ * visible from `Counter.from(HostWorker).getByName(name)`.
+ * ```typescript
+ * // host worker (declares + provides Counter)
+ * import CounterLive, { Counter } from "./counter.ts";
+ *
+ * export class WorkerA extends Cloudflare.Worker<WorkerA, {}, Counter>()(
+ *   "WorkerA",
+ *   { main: import.meta.filename },
+ * ) {}
+ *
+ * export default WorkerA.make(
+ *   Effect.gen(function* () {
+ *     const counters = yield* Counter; // local host binding
+ *     // ... fetch handler ...
+ *   }).pipe(Effect.provide(CounterLive)),
+ * );
+ *
+ * // consumer worker (binds via .from)
+ * export default class WorkerB extends Cloudflare.Worker<WorkerB>()(
+ *   "WorkerB",
+ *   { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     const counters = yield* Counter.from(WorkerA);
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const client = yield* counters.getByName("shared");
+ *         yield* client.setTitle({ title: "via WorkerB" });
+ *         return HttpServerResponse.text("ok");
+ *       }).pipe(Effect.scoped),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @example Self-hosted isolated namespace
+ * A Worker that declares `Counter` in its own `Deps` and provides
+ * `CounterLive` hosts its own isolated namespace — instances under
+ * it are separate from any other host's. Use `Counter.from(Self)`
+ * inside the host to be explicit about which script's namespace
+ * you're binding to.
+ * ```typescript
+ * export class WorkerC extends Cloudflare.Worker<WorkerC, {}, Counter>()(
+ *   "WorkerC",
+ *   { main: import.meta.filename },
+ * ) {}
+ *
+ * export default WorkerC.make(
+ *   Effect.gen(function* () {
+ *     const counters = yield* Counter.from(WorkerC); // explicit self
+ *     // ... fetch handler ...
+ *   }).pipe(Effect.provide(CounterLive)),
+ * );
+ * ```
+ *
+ * @section Yielding the surrounding namespace from inside a DO
+ * @example `yield* RpcDurableObjectNamespace` inside the DO impl
+ * Lets a DO instance refer to its own namespace — e.g. to fan a call
+ * out to sibling instances. Mirrors `yield* DurableObjectNamespace`
+ * on the regular `DurableObjectNamespace`.
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const self = yield* Cloudflare.RpcDurableObjectNamespace;
+ *   const peer = yield* self.getByName("peer-1");
+ *   yield* peer.setTitle({ title: "Sibling call" });
+ * }).pipe(Effect.scoped);
+ * ```
+ */
+export declare const RpcDurableObjectNamespace: RpcDurableObjectNamespaceClass;
+export {};
+//# sourceMappingURL=RpcDurableObjectNamespace.d.ts.map

package/lib/Cloudflare/Workers/RpcDurableObjectNamespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcDurableObjectNamespace.d.ts","sourceRoot":"","sources":["../../../src/Cloudflare/Workers/RpcDurableObjectNamespace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,cAAc,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,OAAO,EAEL,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EAChC,KAAK,sBAAsB,IAAI,0BAA0B,EACzD,KAAK,qBAAqB,EAC3B,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,aAAa,CAAC;AAE3D;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB,CACxC,IAAI,EACJ,IAAI,SAAS,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAC9B,SAAQ,IAAI,CACZ,0BAA0B,CAAC;IAAE,KAAK,EAAE,UAAU,CAAC,kBAAkB,CAAC,CAAA;CAAE,CAAC,EACrE,WAAW,GAAG,KAAK,GAAG,OAAO,CAC9B;IACC,2EAA2E;IAC3E,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,QAAQ,CAAC,SAAS,EAAE,CAClB,EAAE,EAAE,MAAM,KACP,MAAM,CAAC,MAAM,CAChB,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,cAAc,CAAC,cAAc,CAAC,EACxD,KAAK,EACL,GAAG,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAC3B,CAAC;CACH;;AAOD,qBAAa,8BAA+B,SAAQ,mCAGT;CAAG;AAE9C,MAAM,WAAW,8BAA+B,SAAQ,MAAM,CAAC,MAAM,CACnE,yBAAyB,CAAC,OAAO,CAAC,EAClC,KAAK,EACL,8BAA8B,CAC/B;IACC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,CAAC,IAAI,KAAK;QACR,uFAAuF;QACvF,CAAC,IAAI,SAAS,GAAG,CAAC,GAAG,EACnB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE;YAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;SAAE,GAClD,MAAM,CAAC,MAAM,CACd,yBAAyB,CAAC,IAAI,EAAE,IAAI,CAAC,EACrC,KAAK,EACL,aAAa,GAAG,IAAI,CACrB,GAAG;YACF,KAAK,CAAC,EAAE,KAAK,GAAG,EAAE,CAAC;YACnB,IAAI,CACF,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,GACxB,MAAM,CAAC,MAAM,CACd,yBAAyB,CAAC,IAAI,EAAE,IAAI,CAAC,EACrC,KAAK,EACL,aAAa,CACd,CAAC;YACF,IAAI,CAAC,GAAG,GAAG,KAAK,EACd,MAAM,EACF,YAAY,CAAC,IAAI,CAAC,GAClB,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,GAChD,MAAM,CAAC,MAAM,CACd,yBAAyB,CAAC,IAAI,EAAE,IAAI,CAAC,EACrC,KAAK,EACL,aAAa,GAAG,GAAG,CACpB,CAAC;YACF,IAAI,CAAC,MAAM,GAAG,KAAK,EAAE,OAAO,GAAG,KAAK,EAClC,IAAI,EAAE,MAAM,CAAC,MAAM,CACjB,MAAM,CAAC,MAAM,CACX,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAChD,KAAK,EACL,qBAAqB,CACtB,EACD,KAAK,EACL,OAAO,CACR,GACA,KAAK,CAAC,KAAK,CACZ,IAAI,EACJ,KAAK,EACL,aAAa,GAAG,OAAO,CAAC,OAAO,GAAG,MAAM,EAAE,qBAAqB,CAAC,CACjE,CAAC;SACH,CAAC;QACF,wBAAwB;QACxB,CAAC,IAAI,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,OAAO,GAAG,KAAK,EACpD,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE;YAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;SAAE,EACnD,IAAI,EAAE,MAAM,CAAC,MAAM,CACjB,MAAM,CAAC,MAAM,CACX,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAChD,KAAK,EACL,qBAAqB,CACtB,EACD,KAAK,EACL,OAAO,CACR,GACA,MAAM,CAAC,MAAM,CACd,yBAAyB,CAAC,IAAI,EAAE,IAAI,CAAC,EACrC,KAAK,EACL,aAAa,GAAG,OAAO,CAAC,OAAO,GAAG,MAAM,EAAE,qBAAqB,CAAC,CACjE,GAAG;YACF,KAAK,CAAC,EAAE,KAAK,GAAG,EAAE,CAAC;SACpB,CAAC;KACH,CAAC;IACF,2DAA2D;IAC3D,CAAC,IAAI,SAAS,GAAG,CAAC,GAAG,EACnB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE;QACL,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;KAC1C,GAAG,OAAO,CAAC,2BAA2B,CAAC,GACvC,0BAA0B,CAAC;QAAE,KAAK,EAAE,UAAU,CAAC,kBAAkB,CAAC,CAAA;KAAE,CAAC,CAAC;IACzE,4CAA4C;IAC5C,CAAC,IAAI,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,EAAE,OAAO,GAAG,KAAK,EACpD,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;KAAE,EACnD,IAAI,EAAE,MAAM,CAAC,MAAM,CACjB,MAAM,CAAC,MAAM,CACX,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,EAChD,KAAK,EACL,qBAAqB,CACtB,EACD,KAAK,EACL,OAAO,CACR,GACA,MAAM,CAAC,MAAM,CACd,yBAAyB,CAAC,OAAO,EAAE,IAAI,CAAC,EACxC,KAAK,EACL,aAAa,GAAG,OAAO,CAAC,OAAO,GAAG,MAAM,EAAE,qBAAqB,CAAC,CACjE,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2MG;AACH,eAAO,MAAM,yBAAyB,EAAE,8BA4C7B,CAAC"}

package/lib/Cloudflare/Workers/RpcDurableObjectNamespace.js

@@ -0,0 +1,288 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as RpcClientError from "effect/unstable/rpc/RpcClientError";
+import { effectClass, taggedFunction } from "../../Util/effect.js";
+import { DurableObjectNamespace, } from "./DurableObjectNamespace.js";
+import { bindEffectRpc } from "./Rpc.js";
+// Context tag carrying the surrounding `RpcDurableObjectNamespace`
+// inside an rpc DO impl. Yield it from within a DO handler to refer
+// back to the surrounding namespace (e.g. to fan a call out to
+// sibling instances). Documented as part of the main
+// `RpcDurableObjectNamespace` JSDoc below.
+export class RpcDurableObjectNamespaceScope extends Context.Service()("Cloudflare.RpcDurableObjectNamespace") {
+}
+/**
+ * `RpcDurableObjectNamespace` is sugar over {@link DurableObjectNamespace}
+ * for Durable Objects whose surface is a typed Effect `RpcGroup`. The
+ * DO serves an `RpcServer.toHttpEffect(group)` on its own `fetch`, and
+ * consumers see `namespace.getByName(id)` as a typed `RpcClient`
+ * directly — no manual client wiring.
+ *
+ * Use this over alchemy's built-in DO method bridge whenever values
+ * crossing the DO boundary contain `Schema.Class` instances. The
+ * built-in bridge `JSON.stringify`s every method return value, which
+ * strips class identity (e.g. an `effect/ai` `Response.Usage` instance
+ * becomes a plain struct on the consumer side). With
+ * `RpcDurableObjectNamespace`, both ends go through the same
+ * `RpcSerialization` codec, so `Schema.decode` reconstructs class
+ * instances correctly.
+ *
+ * @resource
+ *
+ * @section Defining the rpc group
+ * @example DO-scoped rpc schemas
+ * The DO instance *is* the session, so the group payloads typically
+ * don't include any per-session identifier — only the per-call inputs.
+ * ```typescript
+ * import * as Schema from "effect/Schema";
+ * import { Rpc, RpcGroup } from "effect/unstable/rpc";
+ *
+ * const setTitle = Rpc.make("setTitle", {
+ *   success: Schema.Void,
+ *   payload: { title: Schema.String },
+ * });
+ *
+ * const getTitle = Rpc.make("getTitle", {
+ *   success: Schema.String,
+ *   payload: {},
+ * });
+ *
+ * export class CounterRpcs extends RpcGroup.make(setTitle, getTitle) {}
+ * ```
+ *
+ * @section Implementing the Durable Object
+ * @example Class form (recommended)
+ * Mirrors `Cloudflare.DurableObjectNamespace<Self>()(...)` — same
+ * outer/inner Effect pattern. The outer Effect resolves shared deps;
+ * the per-instance inner Effect returns the
+ * `RpcServer.toHttpEffect(schema)`-piped Effect directly.
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ * import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+ * import { CounterRpcs } from "./rpcs.ts";
+ *
+ * export default class Counter extends Cloudflare.RpcDurableObjectNamespace<Counter>()(
+ *   "Counter",
+ *   { schema: CounterRpcs },
+ *   Effect.gen(function* () {
+ *     // outer init: shared deps for all instances
+ *     return Effect.gen(function* () {
+ *       // per-instance init: state + handlers
+ *       const state = yield* Cloudflare.DurableObjectState;
+ *       const handlers = CounterRpcs.toLayer({
+ *         setTitle: ({ title }) => state.storage.put("title", title),
+ *         getTitle: () =>
+ *           Effect.map(state.storage.get<string>("title"), (t) => t ?? ""),
+ *       });
+ *       return RpcServer.toHttpEffect(CounterRpcs).pipe(
+ *         Effect.provide(Layer.mergeAll(handlers, RpcSerialization.layerNdjson)),
+ *       );
+ *     });
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @section Calling the DO from a Worker
+ * @example Typed rpc client at the call site
+ * `yield* Counter` resolves to a value whose `getByName(id)` returns
+ * an `Effect<RpcClient<CounterRpcs>>`. Each rpc method is a typed
+ * Effect/Stream factory — no `RpcClient.make` setup needed. Yield
+ * the client inside a per-request `Effect.scoped` handler so it's
+ * freed with the request.
+ * ```typescript
+ * import Counter from "./counter.ts";
+ *
+ * Effect.gen(function* () {
+ *   const counters = yield* Counter;
+ *   const client = yield* counters.getByName("global");
+ *   yield* client.setTitle({ title: "Hello" });
+ *   const title = yield* client.getTitle({});
+ *   return title;
+ * }).pipe(Effect.scoped);
+ * ```
+ *
+ * @section Modular form: separate the class from its runtime
+ * @example Class declaration with no impl + `static make(impl)`
+ * The inline class form above bundles the runtime into the class
+ * declaration. The two-arg form `(name, { schema })` declares the
+ * class as a pure tagged identifier; provide the runtime separately
+ * via `Class.make(impl)`. Consumer Workers can import the class for
+ * binding (`Counter.from(HostWorker)`) without pulling the runtime
+ * into their bundle.
+ * ```typescript
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as Effect from "effect/Effect";
+ * import * as Layer from "effect/Layer";
+ * import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+ * import { CounterRpcs } from "./rpcs.ts";
+ *
+ * export class Counter extends Cloudflare.RpcDurableObjectNamespace<Counter>()(
+ *   "Counter",
+ *   { schema: CounterRpcs },
+ * ) {}
+ *
+ * // Only the host script imports this default export.
+ * export default Counter.make(
+ *   Effect.gen(function* () {
+ *     return Effect.gen(function* () {
+ *       const state = yield* Cloudflare.DurableObjectState;
+ *       const handlers = CounterRpcs.toLayer({
+ *         setTitle: ({ title }) => state.storage.put("title", title),
+ *         getTitle: () =>
+ *           Effect.map(state.storage.get<string>("title"), (t) => t ?? ""),
+ *       });
+ *       return RpcServer.toHttpEffect(CounterRpcs).pipe(
+ *         Effect.provide(Layer.mergeAll(handlers, RpcSerialization.layerNdjson)),
+ *       );
+ *     });
+ *   }),
+ * );
+ * ```
+ *
+ * @section Cross-script binding via `Counter.from(Worker)`
+ * @example Hosting on WorkerA, binding from WorkerB
+ * The host Worker declares `Counter` in its `Deps` (third type
+ * arg of `Worker<Self, Bindings, Deps>` or second of
+ * `RpcWorker<Self, Deps>`) and provides `CounterLive`. Any other
+ * Worker uses `Counter.from(HostWorker)` to bind to the same DO
+ * instances — writes through `HostWorker.getByName(name)` are
+ * visible from `Counter.from(HostWorker).getByName(name)`.
+ * ```typescript
+ * // host worker (declares + provides Counter)
+ * import CounterLive, { Counter } from "./counter.ts";
+ *
+ * export class WorkerA extends Cloudflare.Worker<WorkerA, {}, Counter>()(
+ *   "WorkerA",
+ *   { main: import.meta.filename },
+ * ) {}
+ *
+ * export default WorkerA.make(
+ *   Effect.gen(function* () {
+ *     const counters = yield* Counter; // local host binding
+ *     // ... fetch handler ...
+ *   }).pipe(Effect.provide(CounterLive)),
+ * );
+ *
+ * // consumer worker (binds via .from)
+ * export default class WorkerB extends Cloudflare.Worker<WorkerB>()(
+ *   "WorkerB",
+ *   { main: import.meta.filename },
+ *   Effect.gen(function* () {
+ *     const counters = yield* Counter.from(WorkerA);
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         const client = yield* counters.getByName("shared");
+ *         yield* client.setTitle({ title: "via WorkerB" });
+ *         return HttpServerResponse.text("ok");
+ *       }).pipe(Effect.scoped),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * @example Self-hosted isolated namespace
+ * A Worker that declares `Counter` in its own `Deps` and provides
+ * `CounterLive` hosts its own isolated namespace — instances under
+ * it are separate from any other host's. Use `Counter.from(Self)`
+ * inside the host to be explicit about which script's namespace
+ * you're binding to.
+ * ```typescript
+ * export class WorkerC extends Cloudflare.Worker<WorkerC, {}, Counter>()(
+ *   "WorkerC",
+ *   { main: import.meta.filename },
+ * ) {}
+ *
+ * export default WorkerC.make(
+ *   Effect.gen(function* () {
+ *     const counters = yield* Counter.from(WorkerC); // explicit self
+ *     // ... fetch handler ...
+ *   }).pipe(Effect.provide(CounterLive)),
+ * );
+ * ```
+ *
+ * @section Yielding the surrounding namespace from inside a DO
+ * @example `yield* RpcDurableObjectNamespace` inside the DO impl
+ * Lets a DO instance refer to its own namespace — e.g. to fan a call
+ * out to sibling instances. Mirrors `yield* DurableObjectNamespace`
+ * on the regular `DurableObjectNamespace`.
+ * ```typescript
+ * Effect.gen(function* () {
+ *   const self = yield* Cloudflare.RpcDurableObjectNamespace;
+ *   const peer = yield* self.getByName("peer-1");
+ *   yield* peer.setTitle({ title: "Sibling call" });
+ * }).pipe(Effect.scoped);
+ * ```
+ */
+export const RpcDurableObjectNamespace = taggedFunction(RpcDurableObjectNamespaceScope, (...args) => {
+    // Class-form: zero args returns the inner builder. Inner-arg arity
+    // distinguishes modular (`(name, { schema })`, no impl — `static
+    // from`/`static make` provide the runtime) from inline-impl
+    // (`(name, { schema }, impl)`).
+    if (args.length === 0) {
+        return (...inner) => {
+            if (inner.length === 2) {
+                const [name, props] = inner;
+                return buildModular(name, props.schema);
+            }
+            const [name, props, impl] = inner;
+            return build(name, props, impl);
+        };
+    }
+    // Descriptor-only form: `(name, { schema })` — no impl.
+    if (args.length === 2) {
+        const [name, props] = args;
+        return {
+            kind: "Cloudflare.DurableObjectNamespace",
+            name,
+            className: props?.className,
+        };
+    }
+    // Bare form: `(name, { schema }, impl)`.
+    const [name, props, impl] = args;
+    return build(name, props, impl);
+});
+// Wrap a raw `DurableObjectNamespace` so its `getByName` returns a typed
+// Effect `RpcClient` (via `bindEffectRpc`) instead of the built-in
+// method-bridge stub. Used in every branch that produces a yieldable
+// `RpcDurableObjectNamespace` value.
+const rpcWrap = (rawNs, schema) => {
+    const rpcView = bindEffectRpc(rawNs, schema);
+    return Object.assign({}, rawNs, {
+        getByName: rpcView.getByName,
+    });
+};
+// The user's inner Effect resolves to `Effect<HttpEffect>`; the
+// underlying `DurableObjectNamespace` expects `Effect<{ fetch:
+// HttpEffect }>` (a `DurableObjectShape`). Map through both layers to
+// box the http effect in the `{ fetch }` shape.
+const wrapImpl = (impl) => impl.pipe(Effect.map((inner) => inner.pipe(Effect.map((fetch) => ({ fetch })))));
+const build = (name, props, impl) => {
+    // Inline-impl class form: delegate to `DurableObjectNamespace`'s
+    // inline class form, then expose the rpc-wrapped view at yield
+    // time. No `static from`/`static make` because the impl is provided
+    // eagerly here (consumers wanting cross-script binding use the
+    // modular form below).
+    const underlying = DurableObjectNamespace()(name, wrapImpl(impl));
+    const underlyingEff = underlying.asEffect();
+    const rpcBound = underlyingEff.pipe(Effect.map((rawNs) => rpcWrap(rawNs, props.schema)));
+    return effectClass(rpcBound);
+};
+const buildModular = (name, schema) => {
+    // Delegate to `DurableObjectNamespace<Self>()(name)` (no-impl class
+    // form) so we inherit its Self-tag plumbing for free:
+    //   - yielding the class resolves to the live namespace via the tag
+    //     (populated by `static make(impl)`'s Layer)
+    //   - `static from(scriptName | Worker)` registers a foreign-script
+    //     binding on the surrounding worker and yields a fresh handle
+    // We just rpc-wrap each output so consumers see a typed `getByName`.
+    const Underlying = DurableObjectNamespace()(name);
+    const underlyingEff = Underlying.asEffect();
+    return class extends effectClass(underlyingEff.pipe(Effect.map((rawNs) => rpcWrap(rawNs, schema)))) {
+        static make = (impl) => Underlying.make(wrapImpl(impl));
+        static from = (worker) => Underlying.from(worker).pipe(Effect.map((rawNs) => rpcWrap(rawNs, schema)));
+    };
+};
+//# sourceMappingURL=RpcDurableObjectNamespace.js.map

package/lib/Cloudflare/Workers/RpcDurableObjectNamespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcDurableObjectNamespace.js","sourceRoot":"","sources":["../../../src/Cloudflare/Workers/RpcDurableObjectNamespace.ts"],"names":[],"mappings":"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"}