@nimbus-sh/fabric 0.1.0

package/dist/alarms.js

@@ -0,0 +1,214 @@
+/**
+ * alarms.ts — Durable Object alarm multiplexing + isolate-generation
+ * machinery, persisted across hibernation.
+ *
+ * Workerd hibernates Durable Objects between requests to free memory. On
+ * wake, the new isolate must rebuild its in-memory state from SQL — but it
+ * also needs to know "is this the same lifecycle as before, or did workerd
+ * recycle me?" That distinction matters for recovery (warmJoin vs cold init)
+ * and is captured by the isolate generation, a counter persisted across
+ * hibernations.
+ *
+ * A Durable Object has ONE alarm, and a second `setAlarm()` silently
+ * overwrites the first — so every alarm-driven subsystem coordinates through
+ * a single reason→deadline map and one dispatcher. Reasons are plain strings
+ * registered by the embedder: `scheduleAlarm` arms one, and `dispatchAlarm`
+ * runs the embedder-supplied handler for every reason whose deadline has
+ * passed.
+ */
+import { errorText } from '@nimbus-sh/core/_shared/error-text.js';
+/**
+ * Multi-reason alarm coordination map.
+ *
+ * JSON-serialised `Record<reason, deadlineMsEpoch>` where keys are the
+ * embedder's canonical reason strings (e.g. 'w9-flush', 'log-janitor'). The
+ * alarm() dispatcher reads this on fire, dispatches every reason whose
+ * deadline has passed, and re-arms `ctx.storage.setAlarm` at the earliest
+ * remaining deadline.
+ *
+ * Why a map (not a single nextAlarmAt + reason): two subsystems can have
+ * distinct deadlines. Without the map, the later setAlarm() call would
+ * overwrite the earlier reason silently, breaking whichever subsystem
+ * expected its deadline.
+ *
+ * Forward-compat: the dispatcher silently drops unknown reasons so a
+ * rollback from a future deploy that added new reasons doesn't leave the
+ * alarm stuck.
+ *
+ * The VALUE is live production DO storage ('w1_next_alarm_reasons', from the
+ * workstream that introduced it) and must never change — renaming a storage
+ * key is a migration, and orphaned rows are the least of what it breaks.
+ */
+export const ALARM_REASONS_KEY = 'w1_next_alarm_reasons';
+/**
+ * Storage key for the isolate-generation counter (cold-start +
+ * post-hibernation wake; one increment per fresh isolate).
+ *
+ * The VALUE is live production DO storage ('w9_isolate_gen') and must never
+ * change, same contract as {@link ALARM_REASONS_KEY}.
+ */
+export const ISOLATE_GEN_KEY = 'w9_isolate_gen';
+/**
+ * Schedule (or re-schedule) an alarm reason. Coordinated via a single map in
+ * DO storage so multiple subsystems don't clobber each other's `setAlarm()`
+ * calls.
+ *
+ * Semantics:
+ *   - Reads the existing reasons map.
+ *   - Sets `map[reason] = whenMs` IF `whenMs` is sooner than the
+ *     currently-pending deadline for that reason (or no entry exists).
+ *     Later-than-pending requests are silently ignored — the existing
+ *     alarm will fire and re-arm anyway.
+ *   - Writes the map back and calls `ctx.storage.setAlarm(min(deadlines))`.
+ *
+ * Cost: 1 storage read + 1 storage write + 1 setAlarm per call. setAlarm
+ * itself is billed as 1 row written per DO pricing. At a 60s janitor
+ * cadence, this is ~$0.05/mo/session at scale — dwarfed by the
+ * hibernation duration savings.
+ *
+ * Fail-soft: any throw is swallowed with a warn. On older runtimes /
+ * wrangler-dev where setAlarm is unavailable, this is a no-op (the
+ * subsystem's in-isolate setTimeout fallback continues to work).
+ */
+export function scheduleAlarm(host, ctx, reason, whenMs) {
+    // Serialize every read-modify-write of the reasons map through one
+    // per-instance chain: two schedulers firing back-to-back from one activity
+    // hook would otherwise interleave their get→put cycles and silently drop
+    // whichever reason wrote first.
+    const run = async () => {
+        try {
+            const setAlarmFn = ctx?.storage?.setAlarm;
+            if (typeof setAlarmFn !== 'function')
+                return false;
+            const existing = (await ctx.storage.get(ALARM_REASONS_KEY));
+            const map = { ...(existing || {}) };
+            // Earliest-deadline-first: only update if new request is sooner or
+            // this reason has no pending entry.
+            if (!(reason in map) || whenMs < map[reason]) {
+                map[reason] = whenMs;
+                await ctx.storage.put(ALARM_REASONS_KEY, map);
+            }
+            const earliest = Math.min(...Object.values(map));
+            setAlarmFn.call(ctx.storage, earliest);
+            return true;
+        }
+        catch (e) {
+            console.warn('[nimbus/W1] scheduleAlarm threw:', errorText(e));
+            return false;
+        }
+    };
+    const chained = (host._alarmChain ?? Promise.resolve()).then(run, run);
+    host._alarmChain = chained;
+    return chained;
+}
+/**
+ * Multi-reason alarm dispatcher. Called from the DO's `alarm()` handler with
+ * the embedder's handler map.
+ *
+ * For each pending reason whose deadline has passed, run its handler.
+ * Handlers are awaited in place: the alarm invocation is the fresh turn a
+ * re-entering subsystem asked for, and it has to stay the one paying for the
+ * work it just released.
+ *
+ * After running fireable reasons, re-arms `ctx.storage.setAlarm` at the
+ * earliest remaining deadline. If no reasons remain, deletes the map key and
+ * does NOT call setAlarm — the DO becomes hibernation-eligible after the 10s
+ * idle window.
+ *
+ * Forward/back-compat: unknown reasons silently dropped. `onLegacyAlarm`
+ * covers an alarm that fires with no map at all — a deploy from before the
+ * map existed left a bare `setAlarm` behind, and the embedder decides what
+ * that one-time fire means (one dispatch later the map is populated by the
+ * next scheduleAlarm call).
+ */
+export function dispatchAlarm(host, ctx, handlers, onLegacyAlarm) {
+    // Same serialization as scheduleAlarm: the dispatcher's read→handlers→write
+    // cycle must not interleave with an activity-hook scheduleAlarm.
+    const chained = (host._alarmChain ?? Promise.resolve()).then(() => dispatchAlarmBody(ctx, handlers, onLegacyAlarm), () => dispatchAlarmBody(ctx, handlers, onLegacyAlarm));
+    host._alarmChain = chained;
+    return chained;
+}
+async function dispatchAlarmBody(ctx, handlers, onLegacyAlarm) {
+    try {
+        const now = Date.now();
+        const existing = (await ctx?.storage?.get?.(ALARM_REASONS_KEY));
+        if (!existing || Object.keys(existing).length === 0) {
+            onLegacyAlarm?.();
+            return;
+        }
+        const map = { ...existing };
+        // Snapshot fireable reasons BEFORE running any of them, so a
+        // handler that schedules itself for the next cycle doesn't get
+        // immediately re-fired in the same dispatch.
+        const fired = [];
+        for (const [reason, when] of Object.entries(map)) {
+            if (when <= now)
+                fired.push(reason);
+        }
+        for (const reason of fired) {
+            delete map[reason];
+            const handler = handlers[reason];
+            // Unknown reasons silently dropped (forward-compat).
+            if (!handler)
+                continue;
+            try {
+                const result = await handler(now);
+                if (result && typeof result.rearmAt === 'number') {
+                    map[reason] = result.rearmAt;
+                }
+            }
+            catch (e) {
+                console.warn(`[nimbus/W1] dispatch ${reason} threw:`, errorText(e));
+            }
+        }
+        // Re-arm or clear.
+        const setAlarmFn = ctx?.storage?.setAlarm;
+        if (Object.keys(map).length > 0) {
+            await ctx.storage.put(ALARM_REASONS_KEY, map);
+            const earliest = Math.min(...Object.values(map));
+            if (typeof setAlarmFn === 'function') {
+                setAlarmFn.call(ctx.storage, earliest);
+            }
+        }
+        else {
+            try {
+                await ctx.storage.delete(ALARM_REASONS_KEY);
+            }
+            catch { }
+            // No remaining reasons → no setAlarm call → DO becomes
+            // hibernation-eligible after the 10s idle window.
+        }
+    }
+    catch (e) {
+        console.warn('[nimbus/W1] dispatchAlarm threw:', errorText(e));
+    }
+}
+/** Increment + persist the isolate-gen counter once per fresh isolate. */
+export async function maybeBumpIsolateGen(host, ctx) {
+    if (host._isolateGenPersisted)
+        return;
+    host._isolateGenPersisted = true;
+    try {
+        const prev = (await ctx.storage.get(ISOLATE_GEN_KEY));
+        // Adopt the persisted truth first, and adopt the bump only after the
+        // put resolves. An unpersisted `next` would be re-read as `prev` by the
+        // NEXT boot and re-issued — two instances sharing one generation is
+        // exactly the pid-aliasing this counter exists to prevent. Running on
+        // the previous persisted generation is the lesser lapse, and the
+        // put-failure case is replica-only in practice (replicas never spawn).
+        //
+        // What holds the guarantee is the output gate, not this await: measured,
+        // the block body resolves in 0 ms even with a confirmed put, because
+        // `await storage.put()` returns before durability. The gate is what
+        // keeps a pid from generation N from escaping before N is durable, which
+        // is why marking this put `allowUnconfirmed` is not a free speedup — see
+        // scratchpad/coldstart-s1.md.
+        host._isolateGen = typeof prev === 'number' ? prev : 0;
+        const next = host._isolateGen + 1;
+        await ctx.storage.put(ISOLATE_GEN_KEY, next);
+        host._isolateGen = next;
+    }
+    catch (e) {
+        console.warn('[nimbus/W9] isolate-gen bump failed:', errorText(e));
+    }
+}

package/dist/bindings.d.ts

@@ -0,0 +1,316 @@
+/**
+ * session/bindings.ts — Inner-Worker + assets binding shims (W10).
+ *
+ * `nimbus-wrangler dev` runs a USER worker as a child process. That
+ * child needs working `env` bindings (env.ASSETS, env.LOADER, env.MY_DO,
+ * etc.) but the DO's `env` belongs to the supervisor's contract — we
+ * can't pass it through directly. Workerd's enable_ctx_exports
+ * (compat date 2026-04-01+) auto-populates Service Bindings from
+ * top-level WorkerEntrypoint classes; these classes ARE those entry
+ * points. They forward each binding kind back to the supervisor DO via
+ * RPC stub (`env.NIMBUS_SESSION.idFromString(doId).get()...`).
+ *
+ * The shims have NO interaction with NimbusSession internals except
+ * through that RPC stub. Co-located here for grep-ability.
+ *
+ * NimbusAssetsRPC, NimbusLoaderRPC, NimbusLoadedWorker,
+ * NimbusLoadedEntrypoint, NimbusDurableObjectNamespace and NimbusDOStub are
+ * public API of the embedder's Worker: wrangler resolves them by class name
+ * and ctx.exports auto-populates them by export name, so the embedder's entry
+ * module re-exports them under exactly these names.
+ *
+ * Bundle-graph note: these classes must remain reachable from the embedder's
+ * entry module for Wrangler to bundle the WorkerEntrypoint exports.
+ */
+import { WorkerEntrypoint } from 'cloudflare:workers';
+import { z } from 'zod/v4';
+import type { WorkerCode } from './vendor/types.js';
+/**
+ * The supervisor DO namespace a shim resolves ONE stub from, by the id its
+ * props carry. `Stub` is that DO's RPC surface as the calling shim uses it —
+ * the supervisor class belongs to the embedder, so each shim names the methods
+ * it calls rather than the class.
+ */
+interface SupervisorNamespace<Stub> {
+    idFromString(id: string): DurableObjectId;
+    get(id: DurableObjectId): Stub;
+}
+/**
+ * A dynamic worker's entrypoint, as hop 3 relays to it. `fetch` is the
+ * entrypoint contract every loaded worker answers; `handleHttpRequest` is the
+ * fabric's own route target, which only a facet that serves ports exposes.
+ */
+interface LoadedEntrypoint {
+    fetch(request: Request): Promise<Response>;
+    handleHttpRequest?(request: Request): Promise<Response>;
+}
+/** A stub for one dynamically-loaded worker, as the shims hop across it. */
+interface LoadedWorker {
+    getEntrypoint(name?: string): LoadedEntrypoint;
+    getDurableObjectClass(name: string): DurableObjectClass;
+}
+/**
+ * The OUTER `env.LOADER` these shims forward to. `load` is the unkeyed arm the
+ * inner Worker asked for; `get` is the keyed arm every later hop re-enters in
+ * its own request context. `get`'s callback answers with whatever the caller
+ * assembled — a staged artifact's module map is the embedder's, so the fabric
+ * does not name it (see {@link ./process-fabric.js} StagedBootAssembler).
+ */
+interface OuterWorkerLoader {
+    load(code: WorkerCode): LoadedWorker;
+    get(id: string, getCode: () => Promise<object>): LoadedWorker;
+}
+/**
+ * `env` for the three Worker-Loader hops. The depth var rides the env rather
+ * than props because it is set on the OUTERMOST session and every nested
+ * Nimbus inherits it.
+ */
+interface NimbusLoaderShimEnv {
+    LOADER?: OuterWorkerLoader;
+    NIMBUS_INNER_LOADER_DEPTH?: string;
+}
+/**
+ * What the assets shim reads off the supervisor DO: the VFS bytes of one path,
+ * or null when it holds no such file.
+ */
+interface AssetsSupervisorStub {
+    _rpcReadFileBytes(path: string): Promise<ArrayBuffer | Uint8Array | null>;
+}
+/** `env` for the assets shim: the supervisor its VFS reads round-trip through. */
+interface NimbusAssetsEnv {
+    NIMBUS_SESSION?: SupervisorNamespace<AssetsSupervisorStub>;
+}
+/** Props the assets shim is minted with. */
+interface NimbusAssetsProps {
+    /** Project root in VFS (e.g. "home/user/myapp"). */
+    vfsRoot?: string;
+    /** Directory declared in wrangler.jsonc.assets.directory. */
+    assetsDir?: string;
+    /** Supervisor DO id whose VFS holds the assets. */
+    doId?: string;
+}
+/**
+ * Assets binding shim. The inner Worker calls `env.ASSETS.fetch(request)`
+ * and we serve the file from VFS under `<vfsRoot>/<assetsDir>/<pathname>`.
+ *
+ * Props (passed via ctx.props when this binding is constructed):
+ *   vfsRoot   — project root in VFS (e.g. "home/user/myapp")
+ *   assetsDir — directory declared in wrangler.jsonc.assets.directory
+ *               (e.g. "./public" → we trim the leading ./)
+ *
+ * The hostname on the incoming Request is irrelevant (Workers Assets
+ * convention); only pathname matters. Path traversal (`..`) is clamped.
+ * Directories resolve to their `index.html` child; missing files fall
+ * back to the assetsDir root `index.html` (SPA convention), then 404.
+ *
+ * The VFS is read from the supervisor DO via the class property
+ * `_nimbusVfsResolver` set by NimbusSession at construction. WorkerEntrypoint
+ * instances don't have direct access to the supervisor's SqliteVFS, so we
+ * reach it through the supervisor stub (env.NIMBUS_SESSION.idFromString).
+ * For Phase 1, we use a simpler approach: the props carry a supervisor
+ * DO id so we can round-trip through an RPC method that reads the file.
+ */
+export declare class NimbusAssetsRPC extends WorkerEntrypoint<NimbusAssetsEnv, NimbusAssetsProps> {
+    /**
+     * Fetch a static asset. Called by the inner Worker as
+     * `env.ASSETS.fetch(request)`. The request URL's pathname is used to
+     * resolve a file under the configured assets directory.
+     */
+    fetch(request: Request): Promise<Response>;
+}
+declare const NimbusLoadedEntrypointPropsSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    depth: z.ZodOptional<z.ZodNumber>;
+    supervisor: z.ZodOptional<z.ZodObject<{
+        doId: z.ZodString;
+        pid: z.ZodNumber;
+        writerId: z.ZodString;
+    }, z.core.$strip>>;
+    stage: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+type NimbusLoadedEntrypointProps = z.infer<typeof NimbusLoadedEntrypointPropsSchema>;
+/**
+ * Diagnostic surface for /api/_diag/memory. Returns a snapshot of
+ * the Map state — entry count, configured cap, eviction counter
+ * since isolate boot. Pure read; no I/O.
+ */
+export declare function getLoadedCodesStats(): {
+    entries: number;
+    maxEntries: number;
+    evictions: number;
+};
+/** Props every Worker-Loader hop carries: how deep this Nimbus already is. */
+interface NimbusLoaderDepthProps {
+    depth?: number;
+}
+/** Hop 1: env.LOADER.{load,get} forwarded to the outer loader. */
+export declare class NimbusLoaderRPC extends WorkerEntrypoint<NimbusLoaderShimEnv, NimbusLoaderDepthProps> {
+    private _currentDepth;
+    private _maxDepth;
+    private _assertDepthOk;
+    /**
+     * Inner: env.LOADER.load(code). Stashes the CODE (not a stub — stubs
+     * are I/O-bound to the calling request context) and returns a
+     * NimbusLoadedWorker RPC stub. Each downstream call re-loads the
+     * worker in its own request context via LOADER.get(key, cb).
+     */
+    load(code: WorkerCode): unknown;
+    /**
+     * Inner: env.LOADER.get(id, callback). The inner's callback returns
+     * a code object; we treat `id` as the outer cache key (prefixed so
+     * it doesn't collide with load()-generated keys).
+     */
+    get(id: string, callback: () => WorkerCode | Promise<WorkerCode>): Promise<unknown>;
+}
+/** Props hop 2 carries: the stashed code it re-loads, and its inherited depth. */
+interface NimbusLoadedWorkerProps extends NimbusLoaderDepthProps {
+    key?: string;
+}
+/** Hop 2: the returned "worker" stub. Exposes .getEntrypoint(). */
+export declare class NimbusLoadedWorker extends WorkerEntrypoint<NimbusLoaderShimEnv, NimbusLoadedWorkerProps> {
+    /**
+     * Returns a NimbusLoadedEntrypoint stub that carries the code key +
+     * entrypoint name forward. The actual outer-side load + fetch happens
+     * inside NimbusLoadedEntrypoint.fetch() so all outer hops run in a
+     * SINGLE outer request context (the cross-request-I/O limitation is
+     * real — stubs created in one outer request can't be used by another).
+     */
+    getEntrypoint(name?: string): unknown;
+    /**
+     * Pass-through to outer worker.getDurableObjectClass(name). The
+     * returned stub is tied to THIS method's outer request context; if
+     * the caller (the inner worker) uses the class in a later request
+     * it will fail the cross-request-I/O check. For Phase 3 DO binding
+     * synthesis we resolve classes directly from nimbus-wrangler's own
+     * request context (which is the build-time context), not through
+     * this method.
+     */
+    getDurableObjectClass(name: string): DurableObjectClass;
+}
+/** Hop 3: a named-or-default entrypoint. Exposes .fetch(). */
+export declare class NimbusLoadedEntrypoint extends WorkerEntrypoint<NimbusLoaderShimEnv, NimbusLoadedEntrypointProps> {
+    _props(): NimbusLoadedEntrypointProps;
+    _supervisorBinding(props: NimbusLoadedEntrypointProps): Promise<unknown>;
+    _resolveEntrypoint(): Promise<LoadedEntrypoint>;
+    /**
+     * Relay the inner entrypoint's Response to the caller with a LIVE body.
+     * The body streams through an identity pipe and the entrypoint stub is
+     * disposed only once the body finishes — materializing (arrayBuffer) here
+     * buffered every routed response to stream-end, which froze SSE/chunked
+     * bodies (an agent server's /event live-sync, `curl -N` loopback, external
+     * preview) until the facet closed the stream.
+     */
+    private _relayNestedRpcResponse;
+    /**
+     * Invoke the facet's HTTP handler.
+     *
+     * The call must be written as `ep.method(request)`. An RPC stub's method is a
+     * JsRpcProperty, whose every property access is a WILDCARD that extends a
+     * pipelined path (`JSG_WILDCARD_PROPERTY`, workerd api/worker-rpc.h) — so
+     * `method.call(ep, request)` does NOT reach Function.prototype.call. It builds
+     * the path `handleHttpRequest.call` and invokes it remotely with `ep` as its
+     * first ARGUMENT. Serializing `ep` — an entrypoint to a dynamically-loaded
+     * worker — is what workerd refuses:
+     *
+     *   DataCloneError: Entrypoints to dynamically-loaded workers cannot be
+     *   transferred to other Workers
+     *
+     * (server.c++ `requireAllowsTransfer` → `throwDynamicEntrypointTransferError`).
+     * The facet is never entered, because the failure is in serializing the
+     * arguments, before the call is delivered.
+     */
+    private _callHttpHandler;
+    handleHttpRequest(request: Request): Promise<Response>;
+    /**
+     * Forward fetch() to the outer worker's entrypoint. All three outer
+     * hops (load → getEntrypoint → fetch) run in the same outer request
+     * context (this method's invocation), which sidesteps the
+     * cross-request-I/O limitation.
+     */
+    fetch(request: Request): Promise<Response>;
+}
+/** Props the synthesized namespace carries: which binding, on which supervisor. */
+interface NimbusDoNamespaceProps {
+    bindingName?: string;
+    supervisorDoId?: string;
+}
+/**
+ * `env.MY_DO` shim — a DurableObjectNamespace-like WorkerEntrypoint.
+ *
+ * Usage from inner Worker:
+ *   const id   = await env.MY_DO.idFromName('x');   // AWAIT required
+ *   const stub = env.MY_DO.get(id);
+ *   await stub.fetch(request);
+ *
+ * IMPORTANT: unlike the real DurableObjectNamespace, idFromName /
+ * newUniqueId / idFromString here return **Promises**, because they're
+ * RPC-backed WorkerEntrypoint methods. The inner caller MUST `await`
+ * them before passing the result to `.get()`. Workers RPC pipelining
+ * does not currently allow passing an RpcPromise as a method argument
+ * — the no-await form fails with:
+ *     "Could not serialize object of type \"RpcPromise\"."
+ *
+ * Typical real-Worker code written for Cloudflare's synchronous
+ * DurableObjectNamespace needs a one-word change (add `await`).
+ *
+ * idFromName produces prefix `name:` (deterministic FNV-style hash);
+ * newUniqueId uses `uniq:` (random). The prefixes keep the two id
+ * spaces distinct so a name-derived id can't collide with a random
+ * one.
+ */
+export declare class NimbusDurableObjectNamespace extends WorkerEntrypoint<unknown, NimbusDoNamespaceProps> {
+    /** Stable string id derived from a name. Hash is deterministic. */
+    idFromName(name: string): string;
+    /** Fresh random id (matches DurableObjectNamespace.newUniqueId()). */
+    newUniqueId(): string;
+    /** Accept-through for an already-formatted id. */
+    idFromString(s: string): string;
+    /** Return a stub bound to the given id. */
+    get(id: string): unknown;
+}
+/**
+ * What the DO shim reads off the supervisor: one inner-DO request, answered
+ * from the facet the supervisor resolves in its own request context.
+ */
+interface InnerDoSupervisorStub {
+    _rpcInnerDoFetch(request: {
+        bindingName: string;
+        id: string;
+        method: string;
+        url: string;
+        headers: [string, string][];
+        body: ArrayBuffer | null;
+    }): Promise<{
+        body: ArrayBuffer;
+        status: number;
+        statusText: string;
+        headers: [string, string][];
+    }>;
+}
+/** `env` for the DO shim: the supervisor that owns the facet. */
+interface NimbusInnerDoEnv {
+    NIMBUS_SESSION?: SupervisorNamespace<InnerDoSupervisorStub>;
+}
+/** Props the DO stub carries: which binding, which supervisor, which id. */
+interface NimbusDoStubProps extends NimbusDoNamespaceProps {
+    id?: string;
+}
+/**
+ * A Durable-Object-namespace-stub for a specific id. Exposes fetch()
+ * and will, if we later need it, forward RPC method calls through a
+ * dispatch helper. The important invariant: EVERY call resolves the
+ * inner DO class via getInnerDoClass() (./inner-do-registry.js) and
+ * spins up / attaches to a facet via the supervisor's ctx.facets in
+ * the SAME outer request context — never reusing stubs across requests.
+ */
+export declare class NimbusDOStub extends WorkerEntrypoint<NimbusInnerDoEnv, NimbusDoStubProps> {
+    /**
+     * Resolve the supervisor DO from env.NIMBUS_SESSION and route through
+     * its _rpcInnerDoFetch RPC method, which runs ctx.facets.get(...) in
+     * its own context and forwards the request.
+     */
+    fetch(request: Request): Promise<Response>;
+}
+export {};
+//# sourceMappingURL=bindings.d.ts.map

package/dist/bindings.d.ts.map

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