@statewalker/cellb 0.0.0-stage → 0.1.0

package/dist/core/durable-object.d.ts

@@ -0,0 +1,28 @@
+import type { DurableObjectState } from "./state.js";
+/** Stand-in for `import { DurableObject } from "cloudflare:workers"` (mapped via webrun-modules ~deps/ in P08). */
+export declare class DurableObject<Env = unknown> {
+    protected ctx: DurableObjectState;
+    protected env: Env;
+    constructor(ctx: DurableObjectState, env: Env);
+}
+/** Brands WorkerEntrypoint subclasses across copies of this module (a loaded Worker bundles its own). */
+declare const ENTRYPOINT: unique symbol;
+export declare const isWorkerEntrypoint: (v: unknown) => boolean;
+export declare class WorkerEntrypoint<Env = unknown> {
+    static readonly [ENTRYPOINT] = true;
+    protected ctx: ExecutionContext;
+    protected env: Env;
+    constructor(ctx: ExecutionContext, env: Env);
+}
+export interface ExecutionContext {
+    waitUntil(p: Promise<unknown>): void;
+    passThroughOnException(): void;
+}
+/** Brands RpcTarget instances across copies of this module (a loaded Worker bundles its own). */
+declare const RPC_TARGET: unique symbol;
+export declare const isRpcTarget: (v: unknown) => boolean;
+/** Marker base class for JS-RPC targets returned by reference (`cloudflare:workers`). */
+export declare class RpcTarget {
+    get [RPC_TARGET](): boolean;
+}
+export {};

package/dist/core/durable-object.js

@@ -0,0 +1,31 @@
+/** Stand-in for `import { DurableObject } from "cloudflare:workers"` (mapped via webrun-modules ~deps/ in P08). */
+export class DurableObject {
+    ctx;
+    env;
+    constructor(ctx, env) {
+        this.ctx = ctx;
+        this.env = env;
+    }
+}
+/** Brands WorkerEntrypoint subclasses across copies of this module (a loaded Worker bundles its own). */
+const ENTRYPOINT = Symbol.for("cellb.WorkerEntrypoint");
+export const isWorkerEntrypoint = (v) => typeof v === "function" && v[ENTRYPOINT] === true;
+export class WorkerEntrypoint {
+    static [ENTRYPOINT] = true;
+    ctx;
+    env;
+    constructor(ctx, env) {
+        this.ctx = ctx;
+        this.env = env;
+    }
+}
+/** Brands RpcTarget instances across copies of this module (a loaded Worker bundles its own). */
+const RPC_TARGET = Symbol.for("cellb.RpcTarget");
+export const isRpcTarget = (v) => !!v && typeof v === "object" && v[RPC_TARGET] === true;
+/** Marker base class for JS-RPC targets returned by reference (`cloudflare:workers`). */
+export class RpcTarget {
+    get [RPC_TARGET]() {
+        return true;
+    }
+}
+//# sourceMappingURL=durable-object.js.map

package/dist/core/durable-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-object.js","sourceRoot":"","sources":["../../src/core/durable-object.ts"],"names":[],"mappings":"AAEA,mHAAmH;AACnH,MAAM,OAAO,aAAa;IACd,GAAG,CAAqB;IACxB,GAAG,CAAM;IACnB,YAAY,GAAuB,EAAE,GAAQ;QAC3C,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;CACF;AAED,yGAAyG;AACzG,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;AAExD,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAU,EAAW,EAAE,CACxD,OAAO,CAAC,KAAK,UAAU,IAAK,CAAwC,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;AAE5F,MAAM,OAAO,gBAAgB;IAC3B,MAAM,CAAU,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IAC1B,GAAG,CAAmB;IACtB,GAAG,CAAM;IACnB,YAAY,GAAqB,EAAE,GAAQ;QACzC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;CACF;AAOD,iGAAiG;AACjG,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;AAEjD,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAU,EAAW,EAAE,CACjD,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAK,CAA6B,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC;AAEtF,yFAAyF;AACzF,MAAM,OAAO,SAAS;IACpB,IAAI,CAAC,UAAU,CAAC;QACd,OAAO,IAAI,CAAC;IACd,CAAC;CACF","sourcesContent":["import type { DurableObjectState } from \"./state.js\";\n\n/** Stand-in for `import { DurableObject } from \"cloudflare:workers\"` (mapped via webrun-modules ~deps/ in P08). */\nexport class DurableObject<Env = unknown> {\n  protected ctx: DurableObjectState;\n  protected env: Env;\n  constructor(ctx: DurableObjectState, env: Env) {\n    this.ctx = ctx;\n    this.env = env;\n  }\n}\n\n/** Brands WorkerEntrypoint subclasses across copies of this module (a loaded Worker bundles its own). */\nconst ENTRYPOINT = Symbol.for(\"cellb.WorkerEntrypoint\");\n\nexport const isWorkerEntrypoint = (v: unknown): boolean =>\n  typeof v === \"function\" && (v as unknown as Record<symbol, unknown>)[ENTRYPOINT] === true;\n\nexport class WorkerEntrypoint<Env = unknown> {\n  static readonly [ENTRYPOINT] = true;\n  protected ctx: ExecutionContext;\n  protected env: Env;\n  constructor(ctx: ExecutionContext, env: Env) {\n    this.ctx = ctx;\n    this.env = env;\n  }\n}\n\nexport interface ExecutionContext {\n  waitUntil(p: Promise<unknown>): void;\n  passThroughOnException(): void;\n}\n\n/** Brands RpcTarget instances across copies of this module (a loaded Worker bundles its own). */\nconst RPC_TARGET = Symbol.for(\"cellb.RpcTarget\");\n\nexport const isRpcTarget = (v: unknown): boolean =>\n  !!v && typeof v === \"object\" && (v as Record<symbol, unknown>)[RPC_TARGET] === true;\n\n/** Marker base class for JS-RPC targets returned by reference (`cloudflare:workers`). */\nexport class RpcTarget {\n  get [RPC_TARGET]() {\n    return true;\n  }\n}\n"]}

package/dist/core/gates.d.ts

@@ -0,0 +1,33 @@
+/** Defers to a macrotask (portable: browser, Worker, Node, Deno). */
+export declare const nextMacrotask: () => Promise<void>;
+/**
+ * Input gate: while any storage operation is in flight, no new event is
+ * delivered to the object. Unlike Miniflare 2 it needs no AsyncLocalStorage:
+ * each object owns its gate and storage captures it by closure.
+ *
+ * Release is deferred to a macrotask so the continuation of the operation
+ * that held the gate runs before the next event (the read-modify-write
+ * guarantee), and waiters are woken ONE at a time, re-checking the gate.
+ */
+export declare class InputGate {
+    #private;
+    get isOpen(): boolean;
+    waitOpen(): Promise<void>;
+    /** Calls `cb` synchronously at the moment the gate is (re)opened for it. */
+    onOpen(cb: () => void): void;
+    lock(): void;
+    unlock(): void;
+    runClosed<T>(fn: () => T | Promise<T>): Promise<T>;
+}
+/**
+ * Output gate: tracks durability promises of local commits. Responses and
+ * outgoing messages are released only once every commit that happened
+ * before them is durable. A failed commit breaks the object.
+ */
+export declare class OutputGate {
+    #private;
+    track(p: Promise<void>): void;
+    get failure(): unknown;
+    /** Resolves when everything committed so far is durable; rejects if any failed. */
+    barrier(): Promise<void>;
+}

package/dist/core/gates.js

@@ -0,0 +1,89 @@
+/** Defers to a macrotask (portable: browser, Worker, Node, Deno). */
+export const nextMacrotask = () => new Promise((r) => setTimeout(r, 0));
+/**
+ * Input gate: while any storage operation is in flight, no new event is
+ * delivered to the object. Unlike Miniflare 2 it needs no AsyncLocalStorage:
+ * each object owns its gate and storage captures it by closure.
+ *
+ * Release is deferred to a macrotask so the continuation of the operation
+ * that held the gate runs before the next event (the read-modify-write
+ * guarantee), and waiters are woken ONE at a time, re-checking the gate.
+ */
+export class InputGate {
+    #locks = 0;
+    #waiters = [];
+    #draining = false;
+    get isOpen() {
+        return this.#locks === 0;
+    }
+    async waitOpen() {
+        while (this.#locks > 0)
+            await new Promise((r) => this.#waiters.push(r));
+    }
+    /** Calls `cb` synchronously at the moment the gate is (re)opened for it. */
+    onOpen(cb) {
+        if (this.#locks === 0 && !this.#draining)
+            cb();
+        else
+            this.#waiters.push(cb);
+    }
+    lock() {
+        this.#locks++;
+    }
+    unlock() {
+        setTimeout(() => {
+            this.#locks--;
+            void this.#drain();
+        }, 0);
+    }
+    async runClosed(fn) {
+        this.lock();
+        try {
+            return await fn();
+        }
+        finally {
+            this.unlock();
+        }
+    }
+    async #drain() {
+        if (this.#draining)
+            return;
+        this.#draining = true;
+        try {
+            while (this.#locks === 0 && this.#waiters.length) {
+                this.#waiters.shift()();
+                await nextMacrotask();
+            }
+        }
+        finally {
+            this.#draining = false;
+        }
+    }
+}
+/**
+ * Output gate: tracks durability promises of local commits. Responses and
+ * outgoing messages are released only once every commit that happened
+ * before them is durable. A failed commit breaks the object.
+ */
+export class OutputGate {
+    #pending = new Set();
+    #failure = undefined;
+    track(p) {
+        const tracked = p.then(() => void this.#pending.delete(tracked), (err) => {
+            this.#pending.delete(tracked);
+            this.#failure ??= err;
+        });
+        this.#pending.add(tracked);
+    }
+    get failure() {
+        return this.#failure;
+    }
+    /** Resolves when everything committed so far is durable; rejects if any failed. */
+    async barrier() {
+        while (this.#pending.size)
+            await Promise.all([...this.#pending]);
+        if (this.#failure !== undefined)
+            throw this.#failure;
+    }
+}
+//# sourceMappingURL=gates.js.map

package/dist/core/gates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gates.js","sourceRoot":"","sources":["../../src/core/gates.ts"],"names":[],"mappings":"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","sourcesContent":["/** Defers to a macrotask (portable: browser, Worker, Node, Deno). */\nexport const nextMacrotask = () => new Promise<void>((r) => setTimeout(r, 0));\n\n/**\n * Input gate: while any storage operation is in flight, no new event is\n * delivered to the object. Unlike Miniflare 2 it needs no AsyncLocalStorage:\n * each object owns its gate and storage captures it by closure.\n *\n * Release is deferred to a macrotask so the continuation of the operation\n * that held the gate runs before the next event (the read-modify-write\n * guarantee), and waiters are woken ONE at a time, re-checking the gate.\n */\nexport class InputGate {\n  #locks = 0;\n  #waiters: (() => void)[] = [];\n  #draining = false;\n\n  get isOpen(): boolean {\n    return this.#locks === 0;\n  }\n  async waitOpen(): Promise<void> {\n    while (this.#locks > 0) await new Promise<void>((r) => this.#waiters.push(r));\n  }\n  /** Calls `cb` synchronously at the moment the gate is (re)opened for it. */\n  onOpen(cb: () => void): void {\n    if (this.#locks === 0 && !this.#draining) cb();\n    else this.#waiters.push(cb);\n  }\n  lock(): void {\n    this.#locks++;\n  }\n  unlock(): void {\n    setTimeout(() => {\n      this.#locks--;\n      void this.#drain();\n    }, 0);\n  }\n  async runClosed<T>(fn: () => T | Promise<T>): Promise<T> {\n    this.lock();\n    try {\n      return await fn();\n    } finally {\n      this.unlock();\n    }\n  }\n  async #drain(): Promise<void> {\n    if (this.#draining) return;\n    this.#draining = true;\n    try {\n      while (this.#locks === 0 && this.#waiters.length) {\n        this.#waiters.shift()!();\n        await nextMacrotask();\n      }\n    } finally {\n      this.#draining = false;\n    }\n  }\n}\n\n/**\n * Output gate: tracks durability promises of local commits. Responses and\n * outgoing messages are released only once every commit that happened\n * before them is durable. A failed commit breaks the object.\n */\nexport class OutputGate {\n  #pending = new Set<Promise<void>>();\n  #failure: unknown = undefined;\n\n  track(p: Promise<void>): void {\n    const tracked = p.then(\n      () => void this.#pending.delete(tracked),\n      (err) => {\n        this.#pending.delete(tracked);\n        this.#failure ??= err;\n      },\n    );\n    this.#pending.add(tracked);\n  }\n  get failure(): unknown {\n    return this.#failure;\n  }\n  /** Resolves when everything committed so far is durable; rejects if any failed. */\n  async barrier(): Promise<void> {\n    while (this.#pending.size) await Promise.all([...this.#pending]);\n    if (this.#failure !== undefined) throw this.#failure;\n  }\n}\n"]}

package/dist/core/handles.d.ts

@@ -0,0 +1,90 @@
+import { type HostObjects } from "../v8/serialize.js";
+import type { DurableObjectState } from "./state.js";
+export type DurableObjectClass = new (ctx: DurableObjectState, env: any) => any;
+/**
+ * A class handle — what `worker.getDurableObjectClass(name)` (Worker Loader) and
+ * `ctx.exports.App` return, and what `ctx.facets.get(name, () => ({ class }))` accepts.
+ * Resolution may be asynchronous (loaded code is compiled on first use).
+ */
+export interface ClassHandle {
+    readonly __cellsClassHandle: true;
+    resolve(): Promise<{
+        cls: DurableObjectClass;
+        env: unknown;
+        props?: unknown;
+    } | {
+        isolated: IsolatedClass;
+    }>;
+}
+/** Key of the isolate's class factory on a module facade (see getDurableObjectClass). */
+export declare const ISOLATED: unique symbol;
+/** A Durable Object class that runs in an isolate: its instances and storage live there. */
+export interface IsolatedClass {
+    fetch(cellKey: string, req: Request): Promise<Response>;
+    call(cellKey: string, method: string, args: unknown[]): Promise<unknown>;
+    restart(cellKey: string): Promise<void>;
+    delete(cellKey: string): Promise<void>;
+    /** Tells the isolate which root epoch the facet's log is written under. */
+    attach?(cellKey: string, epoch?: number): Promise<void>;
+}
+export declare function classHandle(resolve: ClassHandle["resolve"]): ClassHandle;
+export declare function isClassHandle(v: unknown): v is ClassHandle;
+/** Answered `true` by cellb's stubs: they cross by reference. */
+export declare const STUB: unique symbol;
+/** Answered by a value that may not cross, with workerd's reason. */
+export declare const REFUSE: unique symbol;
+/** Answered by a `ctx.exports.X({ props })` stub or class handle: `{ name, props }` (storable). */
+export declare const EXPORT: unique symbol;
+/**
+ * What crosses a stub, as in workerd: functions, `RpcTarget`s, stubs and class handles by
+ * reference (`ref` says what stands for one on the far side; in one realm, the value itself),
+ * arrays and plain objects walked, anything else structured-cloned (`copy`).
+ */
+export declare function cross<T>(v: T, ref?: (v: object) => unknown, copy?: (v: unknown) => unknown): T;
+/**
+ * A value sent to an object on another node (cells-http, celld's tunnel), checked first: only
+ * copies travel between nodes, so a function, `RpcTarget` or stub is refused, not sent as `{}`.
+ */
+export declare function toAnotherNode<T>(v: T): T;
+/** Where a call on an RpcPromise goes: the property path from its result, and the arguments. */
+export type Pipe = (path: string[], args: unknown[]) => unknown;
+/**
+ * workerd's RpcPromise: what a call on a stub returns. It is awaited as a promise, and used
+ * before it settles (promise pipelining): a property read gives the RpcPromise of that path,
+ * and a call on a path goes through `pipe` at once, without waiting for `result`.
+ */
+export declare function rpcPromise(result: Promise<unknown>, pipe: Pipe): any;
+/**
+ * Runs a call and returns its result as an RpcPromise (`map` applies to the settled value);
+ * calls on it go to the result: at once if the result is an RpcPromise itself, else once it
+ * settles.
+ */
+export declare function rpcCall(call: () => unknown, map?: (v: unknown) => unknown): any;
+/** Calls `path` of `r` (a value, a promise of one, or an RpcPromise) with `args`. */
+export declare function pipeTo(r: unknown, path: string[], args: unknown[]): unknown;
+/**
+ * A stub over an asynchronously obtained target: `fetch` and JS-RPC methods, arguments
+ * and results crossing as between isolates. A method's result is an RpcPromise over what
+ * `call` returns.
+ */
+export declare function asyncStub(call: (method: string, args: unknown[]) => unknown, fetch: (req: Request) => Promise<Response>): Record<string, any>;
+/**
+ * A stub of a WorkerEntrypoint (or a default export object): a fresh instance per call,
+ * as workerd creates one per request; `ctx.props` carries copied startup properties. Methods
+ * of a plain object receive `(…args, env, ctx)`, as its `fetch` receives `(request, env, ctx)`.
+ */
+export declare function entrypointStub(target: unknown, env: unknown, props: unknown, exports?: unknown): Record<string, any>;
+/**
+ * `ctx.exports`: loopback handles of a Worker's named exports. An entrypoint's (a
+ * WorkerEntrypoint class, or an object with methods) is a stub (`ctx.exports.Greeter.greet()`),
+ * and called with `{ props }` gives one with props; a Durable Object class's is a facet class
+ * handle, also callable with `{ props }`.
+ */
+export declare function ctxExports(worker: Record<string, unknown>, env: unknown): Record<string, unknown>;
+/**
+ * Stubs in Durable Object storage (workerd's `allow_irrevocable_stub_storage`), as V8 host
+ * objects: a `ctx.exports.X({ props })` stub or class handle is stored as `[name, props]` and
+ * read back as `ctx.exports[name]({ props })`. Other stubs and `RpcTarget`s are refused rather
+ * than stored as `{}`.
+ */
+export declare function storedExports(exports: Record<string, unknown>): HostObjects;

package/dist/core/handles.js

@@ -0,0 +1,224 @@
+import { deserialize, serialize } from "../v8/serialize.js";
+import { isRpcTarget, isWorkerEntrypoint } from "./durable-object.js";
+/** Key of the isolate's class factory on a module facade (see getDurableObjectClass). */
+export const ISOLATED = Symbol.for("cellb.isolated-classes");
+export function classHandle(resolve) {
+    return { __cellsClassHandle: true, resolve };
+}
+export function isClassHandle(v) {
+    return (!!v &&
+        (typeof v === "object" || typeof v === "function") &&
+        v.__cellsClassHandle === true);
+}
+/** Answered `true` by cellb's stubs: they cross by reference. */
+export const STUB = Symbol.for("cellb.stub");
+/** Answered by a value that may not cross, with workerd's reason. */
+export const REFUSE = Symbol.for("cellb.refuse");
+/** Answered by a `ctx.exports.X({ props })` stub or class handle: `{ name, props }` (storable). */
+export const EXPORT = Symbol.for("cellb.export");
+/**
+ * What crosses a stub, as in workerd: functions, `RpcTarget`s, stubs and class handles by
+ * reference (`ref` says what stands for one on the far side; in one realm, the value itself),
+ * arrays and plain objects walked, anything else structured-cloned (`copy`).
+ */
+export function cross(v, ref = (x) => x, copy = structuredClone) {
+    if (v === undefined || v === null || (typeof v !== "object" && typeof v !== "function"))
+        return copy(v);
+    const refused = v[REFUSE];
+    if (typeof refused === "string")
+        throw new DOMException(refused, "DataCloneError");
+    if (typeof v === "function" ||
+        isRpcTarget(v) ||
+        v[STUB] === true ||
+        isClassHandle(v))
+        return ref(v);
+    if (Array.isArray(v))
+        return v.map((x) => cross(x, ref, copy));
+    if (Object.getPrototypeOf(v) === Object.prototype) {
+        const out = {};
+        for (const [k, x] of Object.entries(v))
+            out[k] = cross(x, ref, copy);
+        return out;
+    }
+    return copy(v);
+}
+/**
+ * A value sent to an object on another node (cells-http, celld's tunnel), checked first: only
+ * copies travel between nodes, so a function, `RpcTarget` or stub is refused, not sent as `{}`.
+ */
+export function toAnotherNode(v) {
+    cross(v, () => {
+        const e = new DOMException("Functions, RpcTargets and stubs cannot be sent to another node: they pass by reference only within one runtime.", "DataCloneError");
+        // An own `name`, so it survives the error's trip back over the link.
+        throw Object.defineProperty(e, "name", { value: e.name, enumerable: true });
+    }, (x) => x);
+    return v;
+}
+const RPC_PROMISE = Symbol("cellb.rpc-promise");
+/**
+ * workerd's RpcPromise: what a call on a stub returns. It is awaited as a promise, and used
+ * before it settles (promise pipelining): a property read gives the RpcPromise of that path,
+ * and a call on a path goes through `pipe` at once, without waiting for `result`.
+ */
+export function rpcPromise(result, pipe) {
+    const at = (path) => {
+        let value;
+        // The result itself is a Promise-like object, not callable (node:assert calls a function
+        // given to `rejects`); a property path is callable.
+        return new Proxy(path.length ? () => { } : Object.create(Promise.prototype), {
+            apply: (_t, _this, args) => rpcCall(() => pipe(path, args)),
+            get(_t, prop) {
+                if (prop === RPC_PROMISE)
+                    return true;
+                if (prop === "then" || prop === "catch" || prop === "finally") {
+                    value ??= result.then((v) => path.reduce((o, k) => o[k], v));
+                    return value[prop].bind(value);
+                }
+                if (typeof prop === "symbol")
+                    return undefined;
+                return at([...path, prop]);
+            },
+        });
+    };
+    return at([]);
+}
+/**
+ * Runs a call and returns its result as an RpcPromise (`map` applies to the settled value);
+ * calls on it go to the result: at once if the result is an RpcPromise itself, else once it
+ * settles.
+ */
+export function rpcCall(call, map) {
+    let r;
+    try {
+        r = call();
+    }
+    catch (e) {
+        r = Promise.reject(e);
+    }
+    const result = Promise.resolve(r);
+    return rpcPromise(map ? result.then(map) : result, (path, args) => pipeTo(r, path, args));
+}
+/** Calls `path` of `r` (a value, a promise of one, or an RpcPromise) with `args`. */
+export function pipeTo(r, path, args) {
+    const callAt = (v) => {
+        if (!path.length)
+            return v(...args);
+        const receiver = path.slice(0, -1).reduce((o, k) => o[k], v);
+        return receiver[path[path.length - 1]](...args);
+    };
+    return r?.[RPC_PROMISE]
+        ? callAt(r)
+        : Promise.resolve(r).then(callAt);
+}
+/**
+ * A stub over an asynchronously obtained target: `fetch` and JS-RPC methods, arguments
+ * and results crossing as between isolates. A method's result is an RpcPromise over what
+ * `call` returns.
+ */
+export function asyncStub(call, fetch) {
+    return new Proxy({}, {
+        get(_t, prop) {
+            if (prop === STUB)
+                return true;
+            if (prop === "then" || typeof prop === "symbol")
+                return undefined;
+            if (prop === "fetch")
+                return (input, init) => fetch(new Request(input, init));
+            return (...args) => rpcCall(() => call(String(prop), cross(args)), cross);
+        },
+    });
+}
+/**
+ * A stub of a WorkerEntrypoint (or a default export object): a fresh instance per call,
+ * as workerd creates one per request; `ctx.props` carries copied startup properties. Methods
+ * of a plain object receive `(…args, env, ctx)`, as its `fetch` receives `(request, env, ctx)`.
+ */
+export function entrypointStub(target, env, props, exports) {
+    const objectCtx = () => ({
+        waitUntil() { },
+        passThroughOnException() { },
+        props: cross(props ?? {}),
+    });
+    const make = () => {
+        if (typeof target === "function") {
+            const ctx = {
+                props: cross(props ?? {}),
+                exports,
+                waitUntil() { },
+                passThroughOnException() { },
+            };
+            return new target(ctx, env);
+        }
+        return target;
+    };
+    return asyncStub((method, args) => {
+        const instance = make();
+        const fn = instance?.[method];
+        if (typeof fn !== "function")
+            throw new TypeError(`The RPC receiver does not implement the method "${method}".`);
+        return fn.apply(instance, typeof target === "function" ? args : [...args, env, objectCtx()]);
+    }, async (req) => {
+        const instance = make();
+        if (typeof instance?.fetch !== "function")
+            throw new Error("Handler does not export a fetch() function.");
+        return typeof target === "function"
+            ? instance.fetch(req)
+            : instance.fetch(req, env, objectCtx());
+    });
+}
+/** workerd's refusal of `ctx.exports.<Entrypoint>` passed on without `({ props })`. */
+const LOOPBACK = 'Could not serialize object of type "LoopbackServiceStub". This type does not support serialization.';
+/**
+ * `ctx.exports`: loopback handles of a Worker's named exports. An entrypoint's (a
+ * WorkerEntrypoint class, or an object with methods) is a stub (`ctx.exports.Greeter.greet()`),
+ * and called with `{ props }` gives one with props; a Durable Object class's is a facet class
+ * handle, also callable with `{ props }`.
+ */
+export function ctxExports(worker, env) {
+    const exports = {};
+    for (const [name, value] of Object.entries(worker)) {
+        if (name === "default" || !value || (typeof value !== "function" && typeof value !== "object"))
+            continue;
+        if (typeof value === "object" || isWorkerEntrypoint(value)) {
+            const withProps = (o = {}) => {
+                const stub = entrypointStub(value, env, o.props, exports);
+                return new Proxy(stub, {
+                    get: (t, prop) => (prop === EXPORT ? { name, props: o.props } : t[prop]),
+                });
+            };
+            const stub = withProps();
+            exports[name] = new Proxy(withProps, {
+                get: (_t, prop) => (prop === REFUSE ? LOOPBACK : stub[prop]),
+            });
+        }
+        else {
+            const handle = (o = {}) => Object.assign(classHandle(async () => ({ cls: value, env, props: o.props })), { [EXPORT]: { name, props: o.props } });
+            exports[name] = Object.assign(handle, classHandle(async () => ({ cls: value, env })));
+        }
+    }
+    return exports;
+}
+/**
+ * Stubs in Durable Object storage (workerd's `allow_irrevocable_stub_storage`), as V8 host
+ * objects: a `ctx.exports.X({ props })` stub or class handle is stored as `[name, props]` and
+ * read back as `ctx.exports[name]({ props })`. Other stubs and `RpcTarget`s are refused rather
+ * than stored as `{}`.
+ */
+export function storedExports(exports) {
+    const host = {
+        encode(v) {
+            const e = v[EXPORT];
+            if (e)
+                return serialize([e.name, e.props], host);
+            if (v[STUB] === true || isRpcTarget(v))
+                throw new DOMException("Only ctx.exports.<name>({ props }) stubs and class handles can be stored.", "DataCloneError");
+            return undefined;
+        },
+        decode(bytes) {
+            const [name, props] = deserialize(bytes, host);
+            return exports[name]({ props });
+        },
+    };
+    return host;
+}
+//# sourceMappingURL=handles.js.map

package/dist/core/handles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handles.js","sourceRoot":"","sources":["../../src/core/handles.ts"],"names":[],"mappings":"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","sourcesContent":["import { deserialize, type HostObjects, serialize } from \"../v8/serialize.js\";\nimport { isRpcTarget, isWorkerEntrypoint } from \"./durable-object.js\";\nimport type { DurableObjectState } from \"./state.js\";\n\nexport type DurableObjectClass = new (ctx: DurableObjectState, env: any) => any;\n\n/**\n * A class handle — what `worker.getDurableObjectClass(name)` (Worker Loader) and\n * `ctx.exports.App` return, and what `ctx.facets.get(name, () => ({ class }))` accepts.\n * Resolution may be asynchronous (loaded code is compiled on first use).\n */\nexport interface ClassHandle {\n  readonly __cellsClassHandle: true;\n  resolve(): Promise<\n    { cls: DurableObjectClass; env: unknown; props?: unknown } | { isolated: IsolatedClass }\n  >;\n}\n\n/** Key of the isolate's class factory on a module facade (see getDurableObjectClass). */\nexport const ISOLATED = Symbol.for(\"cellb.isolated-classes\");\n\n/** A Durable Object class that runs in an isolate: its instances and storage live there. */\nexport interface IsolatedClass {\n  fetch(cellKey: string, req: Request): Promise<Response>;\n  call(cellKey: string, method: string, args: unknown[]): Promise<unknown>;\n  restart(cellKey: string): Promise<void>;\n  delete(cellKey: string): Promise<void>;\n  /** Tells the isolate which root epoch the facet's log is written under. */\n  attach?(cellKey: string, epoch?: number): Promise<void>;\n}\n\nexport function classHandle(resolve: ClassHandle[\"resolve\"]): ClassHandle {\n  return { __cellsClassHandle: true, resolve };\n}\n\nexport function isClassHandle(v: unknown): v is ClassHandle {\n  return (\n    !!v &&\n    (typeof v === \"object\" || typeof v === \"function\") &&\n    (v as ClassHandle).__cellsClassHandle === true\n  );\n}\n\n/** Answered `true` by cellb's stubs: they cross by reference. */\nexport const STUB = Symbol.for(\"cellb.stub\");\n/** Answered by a value that may not cross, with workerd's reason. */\nexport const REFUSE = Symbol.for(\"cellb.refuse\");\n/** Answered by a `ctx.exports.X({ props })` stub or class handle: `{ name, props }` (storable). */\nexport const EXPORT = Symbol.for(\"cellb.export\");\n\n/**\n * What crosses a stub, as in workerd: functions, `RpcTarget`s, stubs and class handles by\n * reference (`ref` says what stands for one on the far side; in one realm, the value itself),\n * arrays and plain objects walked, anything else structured-cloned (`copy`).\n */\nexport function cross<T>(\n  v: T,\n  ref: (v: object) => unknown = (x) => x,\n  copy: (v: unknown) => unknown = structuredClone,\n): T {\n  if (v === undefined || v === null || (typeof v !== \"object\" && typeof v !== \"function\"))\n    return copy(v) as T;\n  const refused = (v as Record<symbol, unknown>)[REFUSE];\n  if (typeof refused === \"string\") throw new DOMException(refused, \"DataCloneError\");\n  if (\n    typeof v === \"function\" ||\n    isRpcTarget(v) ||\n    (v as Record<symbol, unknown>)[STUB] === true ||\n    isClassHandle(v)\n  )\n    return ref(v) as T;\n  if (Array.isArray(v)) return v.map((x) => cross(x, ref, copy)) as T;\n  if (Object.getPrototypeOf(v) === Object.prototype) {\n    const out: Record<string, unknown> = {};\n    for (const [k, x] of Object.entries(v)) out[k] = cross(x, ref, copy);\n    return out as T;\n  }\n  return copy(v) as T;\n}\n\n/**\n * A value sent to an object on another node (cells-http, celld's tunnel), checked first: only\n * copies travel between nodes, so a function, `RpcTarget` or stub is refused, not sent as `{}`.\n */\nexport function toAnotherNode<T>(v: T): T {\n  cross(\n    v,\n    () => {\n      const e = new DOMException(\n        \"Functions, RpcTargets and stubs cannot be sent to another node: they pass by reference only within one runtime.\",\n        \"DataCloneError\",\n      );\n      // An own `name`, so it survives the error's trip back over the link.\n      throw Object.defineProperty(e, \"name\", { value: e.name, enumerable: true });\n    },\n    (x) => x,\n  );\n  return v;\n}\n\n/** Where a call on an RpcPromise goes: the property path from its result, and the arguments. */\nexport type Pipe = (path: string[], args: unknown[]) => unknown;\n\nconst RPC_PROMISE = Symbol(\"cellb.rpc-promise\");\n\n/**\n * workerd's RpcPromise: what a call on a stub returns. It is awaited as a promise, and used\n * before it settles (promise pipelining): a property read gives the RpcPromise of that path,\n * and a call on a path goes through `pipe` at once, without waiting for `result`.\n */\nexport function rpcPromise(result: Promise<unknown>, pipe: Pipe): any {\n  const at = (path: string[]): any => {\n    let value: Promise<unknown> | undefined;\n    // The result itself is a Promise-like object, not callable (node:assert calls a function\n    // given to `rejects`); a property path is callable.\n    return new Proxy(path.length ? () => {} : Object.create(Promise.prototype), {\n      apply: (_t, _this, args) => rpcCall(() => pipe(path, args)),\n      get(_t, prop) {\n        if (prop === RPC_PROMISE) return true;\n        if (prop === \"then\" || prop === \"catch\" || prop === \"finally\") {\n          value ??= result.then((v) => path.reduce((o: any, k) => o[k], v));\n          return value[prop].bind(value);\n        }\n        if (typeof prop === \"symbol\") return undefined;\n        return at([...path, prop]);\n      },\n    });\n  };\n  return at([]);\n}\n\n/**\n * Runs a call and returns its result as an RpcPromise (`map` applies to the settled value);\n * calls on it go to the result: at once if the result is an RpcPromise itself, else once it\n * settles.\n */\nexport function rpcCall(call: () => unknown, map?: (v: unknown) => unknown): any {\n  let r: unknown;\n  try {\n    r = call();\n  } catch (e) {\n    r = Promise.reject(e);\n  }\n  const result = Promise.resolve(r);\n  return rpcPromise(map ? result.then(map) : result, (path, args) => pipeTo(r, path, args));\n}\n\n/** Calls `path` of `r` (a value, a promise of one, or an RpcPromise) with `args`. */\nexport function pipeTo(r: unknown, path: string[], args: unknown[]): unknown {\n  const callAt = (v: any) => {\n    if (!path.length) return v(...args);\n    const receiver = path.slice(0, -1).reduce((o, k) => o[k], v);\n    return receiver[path[path.length - 1]](...args);\n  };\n  return (r as Record<symbol, unknown>)?.[RPC_PROMISE]\n    ? callAt(r)\n    : Promise.resolve(r).then(callAt);\n}\n\n/**\n * A stub over an asynchronously obtained target: `fetch` and JS-RPC methods, arguments\n * and results crossing as between isolates. A method's result is an RpcPromise over what\n * `call` returns.\n */\nexport function asyncStub(\n  call: (method: string, args: unknown[]) => unknown,\n  fetch: (req: Request) => Promise<Response>,\n): Record<string, any> {\n  return new Proxy(\n    {},\n    {\n      get(_t, prop) {\n        if (prop === STUB) return true;\n        if (prop === \"then\" || typeof prop === \"symbol\") return undefined;\n        if (prop === \"fetch\")\n          return (input: RequestInfo | URL, init?: RequestInit) =>\n            fetch(new Request(input as RequestInfo, init));\n        return (...args: unknown[]) => rpcCall(() => call(String(prop), cross(args)), cross);\n      },\n    },\n  );\n}\n\n/**\n * A stub of a WorkerEntrypoint (or a default export object): a fresh instance per call,\n * as workerd creates one per request; `ctx.props` carries copied startup properties. Methods\n * of a plain object receive `(…args, env, ctx)`, as its `fetch` receives `(request, env, ctx)`.\n */\nexport function entrypointStub(\n  target: unknown,\n  env: unknown,\n  props: unknown,\n  exports?: unknown,\n): Record<string, any> {\n  const objectCtx = () => ({\n    waitUntil() {},\n    passThroughOnException() {},\n    props: cross(props ?? {}),\n  });\n  const make = () => {\n    if (typeof target === \"function\") {\n      const ctx = {\n        props: cross(props ?? {}),\n        exports,\n        waitUntil() {},\n        passThroughOnException() {},\n      };\n      return new (target as new (c: unknown, e: unknown) => any)(ctx, env);\n    }\n    return target as any;\n  };\n  return asyncStub(\n    (method, args) => {\n      const instance = make();\n      const fn = instance?.[method];\n      if (typeof fn !== \"function\")\n        throw new TypeError(`The RPC receiver does not implement the method \"${method}\".`);\n      return fn.apply(instance, typeof target === \"function\" ? args : [...args, env, objectCtx()]);\n    },\n    async (req) => {\n      const instance = make();\n      if (typeof instance?.fetch !== \"function\")\n        throw new Error(\"Handler does not export a fetch() function.\");\n      return typeof target === \"function\"\n        ? instance.fetch(req)\n        : instance.fetch(req, env, objectCtx());\n    },\n  );\n}\n\n/** workerd's refusal of `ctx.exports.<Entrypoint>` passed on without `({ props })`. */\nconst LOOPBACK =\n  'Could not serialize object of type \"LoopbackServiceStub\". This type does not support serialization.';\n\n/**\n * `ctx.exports`: loopback handles of a Worker's named exports. An entrypoint's (a\n * WorkerEntrypoint class, or an object with methods) is a stub (`ctx.exports.Greeter.greet()`),\n * and called with `{ props }` gives one with props; a Durable Object class's is a facet class\n * handle, also callable with `{ props }`.\n */\nexport function ctxExports(worker: Record<string, unknown>, env: unknown): Record<string, unknown> {\n  const exports: Record<string, unknown> = {};\n  for (const [name, value] of Object.entries(worker)) {\n    if (name === \"default\" || !value || (typeof value !== \"function\" && typeof value !== \"object\"))\n      continue;\n    if (typeof value === \"object\" || isWorkerEntrypoint(value)) {\n      const withProps = (o: { props?: unknown } = {}) => {\n        const stub = entrypointStub(value, env, o.props, exports);\n        return new Proxy(stub, {\n          get: (t, prop) => (prop === EXPORT ? { name, props: o.props } : t[prop as string]),\n        });\n      };\n      const stub = withProps();\n      exports[name] = new Proxy(withProps, {\n        get: (_t, prop) => (prop === REFUSE ? LOOPBACK : stub[prop as string]),\n      });\n    } else {\n      const handle = (o: { props?: unknown } = {}) =>\n        Object.assign(\n          classHandle(async () => ({ cls: value as DurableObjectClass, env, props: o.props })),\n          { [EXPORT]: { name, props: o.props } },\n        );\n      exports[name] = Object.assign(\n        handle,\n        classHandle(async () => ({ cls: value as DurableObjectClass, env })),\n      );\n    }\n  }\n  return exports;\n}\n\n/**\n * Stubs in Durable Object storage (workerd's `allow_irrevocable_stub_storage`), as V8 host\n * objects: a `ctx.exports.X({ props })` stub or class handle is stored as `[name, props]` and\n * read back as `ctx.exports[name]({ props })`. Other stubs and `RpcTarget`s are refused rather\n * than stored as `{}`.\n */\nexport function storedExports(exports: Record<string, unknown>): HostObjects {\n  const host: HostObjects = {\n    encode(v) {\n      const e = (v as Record<symbol, { name: string; props: unknown } | undefined>)[EXPORT];\n      if (e) return serialize([e.name, e.props], host);\n      if ((v as Record<symbol, unknown>)[STUB] === true || isRpcTarget(v))\n        throw new DOMException(\n          \"Only ctx.exports.<name>({ props }) stubs and class handles can be stored.\",\n          \"DataCloneError\",\n        );\n      return undefined;\n    },\n    decode(bytes) {\n      const [name, props] = deserialize(bytes, host) as [string, unknown];\n      return (exports[name] as (o: { props: unknown }) => unknown)({ props });\n    },\n  };\n  return host;\n}\n"]}

package/dist/core/id.d.ts

@@ -0,0 +1,19 @@
+/** 64-hex-char object id. idFromName is SYNCHRONOUS (as on CF), hence noble instead of crypto.subtle. */
+export declare class DurableObjectId {
+    #private;
+    readonly name?: string;
+    constructor(hex: string, name?: string);
+    toString(): string;
+    equals(other: DurableObjectId): boolean;
+}
+/**
+ * Ids as celld derives them (engine_api.rs), so one name reaches the same object id on
+ * celld and on cellb: namespace key `cells:v1:<len(script)>:<script>:<class>`;
+ * key = SHA-256(namespace key); id = HMAC(key, name)[0..16] ‖ HMAC(key, first half)[0..16].
+ * The second half authenticates the first, so idFromString() rejects ids of other namespaces.
+ */
+export declare function namespaceKey(scriptName: string, className: string): string;
+export declare function idFromName(ns: string, name: string): DurableObjectId;
+export declare function newUniqueId(ns: string): DurableObjectId;
+/** idFromString(): 64 hex digits whose second half authenticates the first for `ns`. */
+export declare function validateId(ns: string, hex: string): DurableObjectId;

package/dist/core/id.js

@@ -0,0 +1,64 @@
+import { hmac } from "@noble/hashes/hmac";
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+/** 64-hex-char object id. idFromName is SYNCHRONOUS (as on CF), hence noble instead of crypto.subtle. */
+export class DurableObjectId {
+    #hex;
+    name;
+    constructor(hex, name) {
+        if (!/^[0-9a-f]{64}$/.test(hex))
+            throw new TypeError("Invalid Durable Object ID: must be 64 hex digits");
+        this.#hex = hex;
+        if (name !== undefined)
+            this.name = name;
+    }
+    toString() {
+        return this.#hex;
+    }
+    equals(other) {
+        return other.toString() === this.#hex;
+    }
+}
+/**
+ * Ids as celld derives them (engine_api.rs), so one name reaches the same object id on
+ * celld and on cellb: namespace key `cells:v1:<len(script)>:<script>:<class>`;
+ * key = SHA-256(namespace key); id = HMAC(key, name)[0..16] ‖ HMAC(key, first half)[0..16].
+ * The second half authenticates the first, so idFromString() rejects ids of other namespaces.
+ */
+export function namespaceKey(scriptName, className) {
+    return `cells:v1:${scriptName.length}:${scriptName}:${className}`;
+}
+const keys = new Map();
+const keyOf = (ns) => {
+    let k = keys.get(ns);
+    if (!k) {
+        k = sha256(new TextEncoder().encode(ns));
+        keys.set(ns, k);
+    }
+    return k;
+};
+const half = (key, data) => hmac(sha256, key, data).subarray(0, 16);
+const withSuffix = (ns, first) => {
+    const id = new Uint8Array(32);
+    id.set(first, 0);
+    id.set(half(keyOf(ns), first), 16);
+    return bytesToHex(id);
+};
+export function idFromName(ns, name) {
+    const hex = withSuffix(ns, half(keyOf(ns), new TextEncoder().encode(name)));
+    // ctx.id.name holds names up to 1024 UTF-8 bytes, as on Cloudflare and celld.
+    return new DurableObjectId(hex, new TextEncoder().encode(name).byteLength <= 1024 ? name : undefined);
+}
+export function newUniqueId(ns) {
+    const first = new Uint8Array(16);
+    crypto.getRandomValues(first);
+    return new DurableObjectId(withSuffix(ns, first));
+}
+/** idFromString(): 64 hex digits whose second half authenticates the first for `ns`. */
+export function validateId(ns, hex) {
+    const id = new DurableObjectId(hex);
+    if (withSuffix(ns, hexToBytes(hex.slice(0, 32))) !== hex)
+        throw new TypeError("Durable Object ID is not valid for this namespace");
+    return id;
+}
+//# sourceMappingURL=id.js.map