@nimbus-sh/worker 0.2.2 → 0.3.0

package/dist/loaders/workerd-facet-host.d.ts

@@ -1,141 +0,0 @@
-/**
- * workerd-facet-host.ts — how a resident process is actually made, on workerd.
- *
- * `loaders/process-fabric.ts` says what a resident process IS, in terms no
- * runtime owns: a boot spec, a start contract, a handle that can be routed to
- * and released. This module is the one implementation of that on Cloudflare,
- * and everything here is a workerd mechanism rather than a Nimbus concept —
- * `ctx.facets`, the Worker Loader, `ctx.exports`, and the facet-index
- * arithmetic the slot book exists to satisfy.
- *
- * The split is what lets the contract be read without the platform: a host
- * that is not a Durable Object implements `ProcessHost` against the same
- * `HostedProcess` and never imports this file.
- */
-import { type OpencodeAssetsEnv, type OpencodeStageSpec } from '../facets/opencode-staging.js';
-import { type HostedProcess, type OneShotParams, type ProcessHostParams, type ResidentDiskReader, type ResidentSupervisorProps } from './process-fabric.js';
-/** Structural surface of a NimbusLoadedEntrypoint RPC stub. */
-export interface LoadedWorkerEntrypointStub {
-    handleHttpRequest?: (request: Request) => Promise<Response>;
-    fetch?(request: Request): Promise<Response>;
-}
-export interface NimbusCtxExports {
-    SupervisorRPC?: (options: {
-        props: {
-            doId: string;
-            pid: number;
-            writerId: string;
-        };
-    }) => unknown;
-    NimbusLoadedEntrypoint?: (options: {
-        props: {
-            key: string;
-            name: string | null;
-            depth: number;
-            supervisor: {
-                doId: string;
-                pid: number;
-                writerId: string;
-            };
-            stage?: OpencodeStageSpec;
-        };
-    }) => LoadedWorkerEntrypointStub;
-}
-export declare function getNimbusCtxExports(): NimbusCtxExports;
-/**
- * Mint a NimbusLoadedEntrypoint stub for a keyed dynamic worker. Used by the
- * one-shot runtime paths, which run a program to completion inside a single
- * request rather than leaving it resident: their module map is assembled in
- * that stateless entrypoint's own isolate, never in a session DO.
- */
-export declare function createLoadedWorkerEntrypoint(ctxExports: NimbusCtxExports, supervisor: {
-    doId: string;
-    pid: number;
-    writerId: string;
-}, stage: OpencodeStageSpec, name?: string | null): Promise<LoadedWorkerEntrypointStub>;
-/**
- * Total bytes a dynamic Worker's module map may carry, across every member of
- * it. A hard platform limit, not a policy knob: 62 MiB lands and 64 MiB is
- * refused with "Dynamic Worker code size (N bytes) exceeds the maximum allowed
- * size of 67108864 bytes", confirmed at five sizes with two trials each. The
- * budget is shared, so a ruby process is already 34.3 MiB down before its disk
- * is counted.
- */
-export declare const DYNAMIC_WORKER_CODE_LIMIT_BYTES = 67108864;
-/** What an unkeyed `LOADER.load` hands back. */
-interface LoadedWorkerStub {
-    getEntrypoint(): LoadedWorkerEntrypointStub;
-}
-/**
- * `env.LOADER` — the Worker Loader binding, as used from inside a DO.
- *
- * Both arms are here because both are the same platform affordance seen from
- * the two lifetimes Nimbus runs programs under: `get` is keyed and yields a
- * Durable Object class, so a resident process can be re-entered; `load` is
- * unkeyed and yields a stateless entrypoint, which is all a program that ends
- * with its call can ever need.
- */
-interface WorkerLoaderBinding {
-    get(id: string, code: () => Promise<unknown>): {
-        getDurableObjectClass(name: string): unknown;
-    };
-    load(code: unknown): LoadedWorkerStub;
-}
-/** The bindings `openResidentFacet` needs off whichever DO is hosting. */
-export interface ResidentFacetEnv extends Partial<OpencodeAssetsEnv> {
-    LOADER?: WorkerLoaderBinding;
-}
-/**
- * The facet name for a slot. Reused, and that is the entire point.
- *
- * A Durable Object admits 65,536 facets over its LIFETIME: the IDs are
- * append-only and are never reclaimed, so the bound is on facets ever CREATED,
- * not facets alive at once. Naming a facet after its pid, when pids never
- * repeat, therefore burned one of those IDs on every spawn — a long-lived
- * session would eventually exhaust its facet index with no way back, and the
- * failure is unrecoverable rather than merely slow.
- *
- * Reusing a NAME costs no new ID. So the name comes from a free list and the
- * pid stays what it always was: the process identity in the ProcessTable. The
- * two were only ever conflated because one of them happened to be handy.
- */
-export declare function residentFacetName(slot: number): string;
-/**
- * What `openResidentFacet` hands back: a running process, minus its placement.
- *
- * `slot` rides along because the caller's `describe` needs the facet's real
- * name and the slot is not derivable from the pid — that indirection is the
- * whole point of the free list. Reading it back out of the book later would
- * also race the release that empties it.
- */
-export type ResidentFacet = Omit<HostedProcess, 'describe'> & {
-    slot: number;
-};
-/**
- * Open a resident process as a facet of the actor whose `ctx` and `env` are
- * given, and start its runner.
- *
- * This is the ONE way a resident process comes into existence, and every
- * substrate goes through it: the facet host calls it with the coordinator's
- * own `ctx`, the peer host calls it — over one RPC — with a sibling session
- * DO's. Everything a substrate could plausibly want to special-case is a
- * PARAMETER here rather than a branch: which actor hosts the child, and how
- * the boot spec's by-path members are read.
- */
-export declare function openResidentFacet(ctx: DurableObjectState, env: ResidentFacetEnv, disk: () => ResidentDiskReader, supervisor: ResidentSupervisorProps, params: ProcessHostParams): ResidentFacet;
-/**
- * Run one program to completion as an UNKEYED dynamic worker.
- *
- * Unkeyed is the whole difference from `openResidentFacet`: nothing can
- * re-resolve this worker into a later request's context, so it can never be a
- * routeable target and never has to be released by name. It exists for the
- * duration of one call and its stubs are dropped as that call unwinds.
- *
- * Shared by both substrates on purpose. `peer` places processes that have a
- * residency to place; a one-shot has none, and shipping its fully-inline map
- * across a sibling hop would meet the 32 MiB RPC ceiling that by-path boot
- * specs exist to avoid — for a run that gains nothing by moving.
- */
-export declare function runOneShotWorker<T>(env: ResidentFacetEnv, supervisor: ResidentSupervisorProps, params: OneShotParams, consume: (response: Response) => Promise<T>): Promise<T>;
-export {};
-//# sourceMappingURL=workerd-facet-host.d.ts.map

package/dist/loaders/workerd-facet-host.d.ts.map

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

package/dist/loaders/workerd-facet-host.js

@@ -1,284 +0,0 @@
-/**
- * workerd-facet-host.ts — how a resident process is actually made, on workerd.
- *
- * `loaders/process-fabric.ts` says what a resident process IS, in terms no
- * runtime owns: a boot spec, a start contract, a handle that can be routed to
- * and released. This module is the one implementation of that on Cloudflare,
- * and everything here is a workerd mechanism rather than a Nimbus concept —
- * `ctx.facets`, the Worker Loader, `ctx.exports`, and the facet-index
- * arithmetic the slot book exists to satisfy.
- *
- * The split is what lets the contract be read without the platform: a host
- * that is not a Durable Object implements `ProcessHost` against the same
- * `HostedProcess` and never imports this file.
- */
-import { disposeRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
-import { assembleOpencodeFacetConfig, } from '../facets/opencode-staging.js';
-import { getCtxExports } from '../session/ctx-exports.js';
-import { RESIDENT_PROCESS_CLASS, residentLoaderConfig, } from './process-fabric.js';
-export function getNimbusCtxExports() {
-    const ctxExports = getCtxExports();
-    if (!ctxExports || typeof ctxExports !== 'object') {
-        throw new Error('Nimbus: ctx.exports unavailable');
-    }
-    return ctxExports;
-}
-/**
- * Mint a NimbusLoadedEntrypoint stub for a keyed dynamic worker. Used by the
- * one-shot runtime paths, which run a program to completion inside a single
- * request rather than leaving it resident: their module map is assembled in
- * that stateless entrypoint's own isolate, never in a session DO.
- */
-export async function createLoadedWorkerEntrypoint(ctxExports, supervisor, stage, name = null) {
-    if (!ctxExports.NimbusLoadedEntrypoint) {
-        throw new Error('Nimbus: ctx.exports.NimbusLoadedEntrypoint unavailable');
-    }
-    return await ctxExports.NimbusLoadedEntrypoint({
-        props: {
-            key: `nimbus-process:${supervisor.doId}:${supervisor.pid}`,
-            name,
-            depth: 0,
-            supervisor,
-            stage,
-        },
-    });
-}
-/**
- * Total bytes a dynamic Worker's module map may carry, across every member of
- * it. A hard platform limit, not a policy knob: 62 MiB lands and 64 MiB is
- * refused with "Dynamic Worker code size (N bytes) exceeds the maximum allowed
- * size of 67108864 bytes", confirmed at five sizes with two trials each. The
- * budget is shared, so a ruby process is already 34.3 MiB down before its disk
- * is counted.
- */
-export const DYNAMIC_WORKER_CODE_LIMIT_BYTES = 67_108_864;
-function facetContainer(ctx) {
-    const facets = ctx.facets;
-    if (!facets || typeof facets.get !== 'function') {
-        throw new Error('Nimbus: ctx.facets is unavailable in this Durable Object; '
-            + 'resident processes cannot be hosted');
-    }
-    return facets;
-}
-/**
- * The facet name for a slot. Reused, and that is the entire point.
- *
- * A Durable Object admits 65,536 facets over its LIFETIME: the IDs are
- * append-only and are never reclaimed, so the bound is on facets ever CREATED,
- * not facets alive at once. Naming a facet after its pid, when pids never
- * repeat, therefore burned one of those IDs on every spawn — a long-lived
- * session would eventually exhaust its facet index with no way back, and the
- * failure is unrecoverable rather than merely slow.
- *
- * Reusing a NAME costs no new ID. So the name comes from a free list and the
- * pid stays what it always was: the process identity in the ProcessTable. The
- * two were only ever conflated because one of them happened to be handy.
- */
-export function residentFacetName(slot) {
-    return `proc-slot-${slot}`;
-}
-/**
- * Slot books, per hosting actor, because the facet index is per Durable
- * Object.
- *
- * Keyed weakly off `ctx`, and that is sound rather than lossy: a facet cannot
- * outlive the Durable Object hosting it, so a book that goes away with its
- * host describes nothing that still exists. A fresh incarnation restarts at
- * slot 0 and re-attaches to the SQLite a previous incarnation left there —
- * which is safe for the reason the store is sealed until it has reconciled.
- * Its persisted cursor is either datable against the current authority, in
- * which case the ACQUIRE delta brings it current, or it carries a different
- * VFS epoch, in which case `invalidatedSince` can only answer poison and the
- * whole store is dropped. A process therefore cannot boot onto a previous
- * tenant's filesystem even when release never ran.
- */
-const slotBooks = new WeakMap();
-function slotBook(ctx) {
-    let book = slotBooks.get(ctx);
-    if (!book) {
-        book = { free: [], next: 0, held: new Map() };
-        slotBooks.set(ctx, book);
-    }
-    return book;
-}
-/** Take a slot for `pid`, reusing a returned one before minting a new name. */
-function acquireSlot(ctx, pid) {
-    const book = slotBook(ctx);
-    const existing = book.held.get(pid);
-    if (existing !== undefined)
-        return existing;
-    const slot = book.free.length > 0 ? book.free.shift() : book.next++;
-    book.held.set(pid, slot);
-    return slot;
-}
-/** Return `pid`'s slot to the free list. */
-function releaseSlot(ctx, pid) {
-    const book = slotBook(ctx);
-    const slot = book.held.get(pid);
-    if (slot === undefined)
-        return;
-    book.held.delete(pid);
-    book.free.push(slot);
-    book.free.sort((a, b) => a - b);
-}
-/**
- * Open a resident process as a facet of the actor whose `ctx` and `env` are
- * given, and start its runner.
- *
- * This is the ONE way a resident process comes into existence, and every
- * substrate goes through it: the facet host calls it with the coordinator's
- * own `ctx`, the peer host calls it — over one RPC — with a sibling session
- * DO's. Everything a substrate could plausibly want to special-case is a
- * PARAMETER here rather than a branch: which actor hosts the child, and how
- * the boot spec's by-path members are read.
- */
-export function openResidentFacet(ctx, env, disk, supervisor, params) {
-    const facets = facetContainer(ctx);
-    const slot = acquireSlot(ctx, params.pid);
-    const name = residentFacetName(slot);
-    // The start callback is the ONLY way this facet is ever created, and it
-    // fires AT MOST ONCE. Every later use goes through the stub below, so the
-    // callback running a second time means the facet was released or died —
-    // and re-running it would evaluate the user's program again, answering a
-    // request from a process they never started while the one they did start
-    // is gone. Both cases are reported instead.
-    let evaluated = false;
-    let released = false;
-    const start = async () => {
-        if (released) {
-            throw new Error(`Nimbus: resident process ${params.pid} is no longer running`);
-        }
-        if (evaluated) {
-            throw new Error(`Nimbus: resident process ${params.pid} is no longer loaded (its facet was lost); `
-                + 'it is not restarted');
-        }
-        evaluated = true;
-        return { class: residentProcessClass(env, disk, supervisor, params) };
-    };
-    const facet = facets.get(name, start);
-    let disposed = false;
-    const release = async () => {
-        if (disposed)
-            return;
-        disposed = true;
-        released = true;
-        try {
-            facets.abort(name, new Error('Nimbus: resident process released'));
-        }
-        catch { /* already gone */ }
-        try {
-            facets.delete(name);
-        }
-        catch { /* already gone */ }
-        // Only after the facet is gone. A slot handed out while its previous
-        // tenant were still being torn down would have two processes on one name.
-        releaseSlot(ctx, params.pid);
-    };
-    let started;
-    try {
-        started = facet.startProcess(params.startArgs);
-    }
-    catch (error) {
-        void release();
-        throw error;
-    }
-    // A caller reads whichever of `started` and the lifecycle it needs, so keep
-    // the runtime from reporting the other as an unhandled rejection.
-    started.catch(() => { });
-    return {
-        started,
-        // A facet cannot die without taking its Durable Object — and this object —
-        // with it, so there is no independent death to report.
-        lost: new Promise(() => { }),
-        handleHttpRequest: (request) => facet.handleHttpRequest(request),
-        release,
-        slot,
-    };
-}
-/**
- * The dynamic worker's Durable Object class, minted in the caller's request
- * context. `LOADER.get` runs its callback only on a cache miss, so a process
- * assembles its module map at most once and the bytes never stay resident in
- * the hosting DO's heap.
- */
-function residentProcessClass(env, disk, supervisor, params) {
-    const loader = env.LOADER;
-    if (!loader || typeof loader.get !== 'function') {
-        throw new Error('Nimbus: env.LOADER binding missing or invalid. Resident processes require '
-            + 'the Worker Loader binding; add it via worker_loaders in wrangler.jsonc.');
-    }
-    return loader
-        .get(params.workerKey, () => residentWorkerConfig(env, disk, supervisor, params.boot))
-        .getDurableObjectClass(RESIDENT_PROCESS_CLASS);
-}
-/**
- * Run one program to completion as an UNKEYED dynamic worker.
- *
- * Unkeyed is the whole difference from `openResidentFacet`: nothing can
- * re-resolve this worker into a later request's context, so it can never be a
- * routeable target and never has to be released by name. It exists for the
- * duration of one call and its stubs are dropped as that call unwinds.
- *
- * Shared by both substrates on purpose. `peer` places processes that have a
- * residency to place; a one-shot has none, and shipping its fully-inline map
- * across a sibling hop would meet the 32 MiB RPC ceiling that by-path boot
- * specs exist to avoid — for a run that gains nothing by moving.
- */
-export async function runOneShotWorker(env, supervisor, params, consume) {
-    const loader = env.LOADER;
-    if (!loader || typeof loader.load !== 'function') {
-        throw new Error('Nimbus: env.LOADER binding missing or invalid. Running a program requires '
-            + 'the Worker Loader binding; add it via worker_loaders in wrangler.jsonc.');
-    }
-    const ctxExports = getCtxExports();
-    let supervisorBinding;
-    let worker;
-    let entrypoint;
-    try {
-        // Built before the capability is minted: nothing can write as this writer
-        // until there is a program to do the writing, and a map that fails to
-        // assemble should not have granted append authority on its way out.
-        let spec = await params.code();
-        if (ctxExports?.SupervisorRPC) {
-            params.onWriterActivated(params.writerId);
-            supervisorBinding = ctxExports.SupervisorRPC({ props: supervisor });
-        }
-        worker = loader.load({
-            compatibilityDate: spec.compatibilityDate,
-            compatibilityFlags: spec.compatibilityFlags,
-            mainModule: spec.mainModule,
-            modules: spec.modules,
-            ...(supervisorBinding ? { env: { SUPERVISOR: supervisorBinding } } : {}),
-        });
-        // The loader has taken the map; holding it here would keep a second full
-        // copy of the program alive for as long as the program runs.
-        spec = undefined;
-        entrypoint = worker.getEntrypoint();
-        if (typeof entrypoint.fetch !== 'function') {
-            throw new Error('Nimbus: one-shot runtime entrypoint has no fetch method');
-        }
-        params.onLoaded?.();
-        const response = await entrypoint.fetch(params.request);
-        try {
-            return await consume(response);
-        }
-        finally {
-            disposeRpcResource(response);
-        }
-    }
-    finally {
-        disposeRpcResource(entrypoint);
-        disposeRpcResource(worker);
-        disposeRpcResource(supervisorBinding);
-    }
-}
-async function residentWorkerConfig(env, disk, supervisor, boot) {
-    const config = boot.kind === 'staged'
-        ? await assembleOpencodeFacetConfig(env, boot.stage)
-        : await residentLoaderConfig(boot.code, disk());
-    const ctxExports = getNimbusCtxExports();
-    if (!ctxExports.SupervisorRPC) {
-        throw new Error('Nimbus: ctx.exports.SupervisorRPC unavailable');
-    }
-    return { ...config, env: { SUPERVISOR: ctxExports.SupervisorRPC({ props: supervisor }) } };
-}

package/dist/session/bindings.d.ts

@@ -1,209 +0,0 @@
-/**
- * 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.
- *
- * Exports re-shipped from nimbus-session.ts so existing import paths work:
- *   NimbusAssetsRPC, NimbusLoaderRPC, NimbusLoadedWorker,
- *   NimbusLoadedEntrypoint, NimbusDurableObjectNamespace, NimbusDOStub.
- *
- * Bundle-graph note: these classes must remain reachable from `src/index.ts`
- * for Wrangler to bundle the WorkerEntrypoint exports.
- */
-import { WorkerEntrypoint } from 'cloudflare:workers';
-import { z } from 'zod/v4';
-/**
- * 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 {
-    /**
-     * 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;
-};
-/** Hop 1: env.LOADER.{load,get} forwarded to the outer loader. */
-export declare class NimbusLoaderRPC extends WorkerEntrypoint {
-    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: any): any;
-    /**
-     * 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: () => any): Promise<any>;
-}
-/** Hop 2: the returned "worker" stub. Exposes .getEntrypoint(). */
-export declare class NimbusLoadedWorker extends WorkerEntrypoint {
-    /**
-     * 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): any;
-    /**
-     * 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): any;
-}
-/** Hop 3: a named-or-default entrypoint. Exposes .fetch(). */
-export declare class NimbusLoadedEntrypoint extends WorkerEntrypoint {
-    _props(): NimbusLoadedEntrypointProps;
-    _supervisorBinding(props: NimbusLoadedEntrypointProps): Promise<unknown>;
-    _resolveEntrypoint(): Promise<any>;
-    /**
-     * 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 (opencode'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>;
-}
-/**
- * `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 {
-    /** 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): any;
-}
-/**
- * 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 {
-    /**
-     * 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/session/bindings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bindings.d.ts","sourceRoot":"","sources":["../../src/session/bindings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAmB3B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;IACnD;;;;OAIG;IACG,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;CA2DjD;AA2FD,QAAA,MAAM,iCAAiC;;;;;;;;;;iBAgBvB,CAAC;AAEjB,KAAK,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AA4CrF;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAMhG;AAiBD,kEAAkE;AAClE,qBAAa,eAAgB,SAAQ,gBAAgB;IACnD,OAAO,CAAC,aAAa;IAKrB,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,cAAc;IAWtB;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,GAAG,GAAG,GAAG;IAmBpB;;;;OAIG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;CAiBzD;AAED,mEAAmE;AACnE,qBAAa,kBAAmB,SAAQ,gBAAgB;IACtD;;;;;;OAMG;IACH,aAAa,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,GAAG;IAWjC;;;;;;;;OAQG;IACH,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG;CAQzC;AAED,8DAA8D;AAC9D,qBAAa,sBAAuB,SAAQ,gBAAgB;IAC1D,MAAM,IAAI,2BAA2B;IAI/B,kBAAkB,CAAC,KAAK,EAAE,2BAA2B,GAAG,OAAO,CAAC,OAAO,CAAC;IAUxE,kBAAkB,IAAI,OAAO,CAAC,GAAG,CAAC;IAkCxC;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;IAyB/B;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,gBAAgB;IAMlB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;IAe5D;;;;;OAKG;IACG,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;CAUjD;AAqBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,4BAA6B,SAAQ,gBAAgB;IAChE,mEAAmE;IACnE,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAiBhC,sEAAsE;IACtE,WAAW,IAAI,MAAM;IAIrB,kDAAkD;IAClD,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAI/B,2CAA2C;IAC3C,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,GAAG;CAYrB;AAED;;;;;;;GAOG;AACH,qBAAa,YAAa,SAAQ,gBAAgB;IAChD;;;;OAIG;IACG,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC;CAuCjD"}