@nimbus-sh/worker 0.2.3 → 0.4.0

package/dist/loaders/process-fabric.js

@@ -1,360 +0,0 @@
-/**
- * process-fabric.ts — the resident-process scheduler, and the process half of
- * the substrate it runs on.
- *
- * Every long-lived process Nimbus runs — node servers, python/ruby socket
- * servers, the opencode TUI and its headless server — runs as a **DO Facet**:
- * a named child actor whose class comes from a dynamic worker, opened by
- * `openResidentFacet` in `loaders/workerd-facet-host.ts`.
- *
- *   ctx.facets.get(`proc-${pid}`, () => ({
- *     class: env.LOADER.get(workerKey, buildConfig)
- *              .getDurableObjectClass('NimbusProcess'),
- *   }))
- *
- * There is ONE process implementation. What varies is WHOSE `ctx` and `env`
- * that call runs against — the user's own session DO, or a sibling DO acting
- * as a host — and that choice is a single deployment-wide config value read in
- * `loaders/process-host.ts`. Nothing here, and nothing above here, branches on
- * which program is running: no spawn site picks its own substrate, and no
- * program name, mode or payload size reaches the selection.
- *
- * What each substrate costs, all of it measured on the production
- * compatibility shape (see `loaders/process-host.ts` for the operator-facing
- * version of this table):
- *
- *   facet  — spawn 8-16 ms warm. Memory independent: its OWN ~208 MiB
- *            envelope, identical whether the coordinator holds 0 or 128 MiB,
- *            with 1,664 MiB live across 8 facets + parent. CPU SHARED with
- *            its siblings, because facets are separate isolates inside one
- *            actor thread: awaiting I/O yields that thread completely (a
- *            sibling's RPC latency while a facet parks on a socket, on stdin
- *            or on an outbound call is indistinguishable from idle) but
- *            sustained CPU stalls every sibling for its full duration —
- *            a python HTTP server at 32-way saturation held siblings under
- *            1.06 s (p50 231 ms), the opencode attach TUI held them at the
- *            77 ms idle baseline, and a deliberate 9,956 ms CPU burn stalled
- *            them for 9,966 ms.
- *   peer   — spawn 242-359 ms, because every spawn pays a DO create plus a
- *            SQLite open. Memory AND CPU both independent: the process runs
- *            in a different workerd process, verified per placement rather
- *            than assumed (see `_place` in `loaders/process-host.ts`).
- *
- * Both give the process its own SQLite. Neither changes what the process is:
- * the runner, the boot spec, the class name, the writer handshake and the
- * lifecycle contract are the same code either way.
- *
- * The facet's SUPERVISOR binding is minted for the COORDINATOR's doId, so
- * every syscall — VFS read/write, stdout/stderr frames, stdin pump,
- * registerPort, loopback HTTP — lands on the user's session DO wherever the
- * process runs. Because that binding is minted by an actor rather than by a
- * stateless entrypoint, it lives as long as the process does; nothing has to
- * hold a call open to keep it alive.
- *
- * Boot specs
- * ──────────
- * A resident process boots from one of two specs, and in both cases the module
- * map is assembled LAZILY inside the loader's cache-miss callback — so the
- * artifact sources are materialized only when the facet actually starts, and
- * only for as long as the load takes:
- *
- *   staged — an OpencodeStageSpec; `assembleOpencodeFacetConfig` fetches the
- *            artifact sources from ASSETS.
- *   code   — a generated module map (node / python / ruby runners). Fixed-size
- *            module text rides inline; anything sized by the user's disk is
- *            named BY VFS PATH and read through the injected disk reader. A
- *            ruby server's `ruby+stdlib.wasm` alone is 34.3 MiB and a node
- *            facet's disk snapshot reached 44 MB for pi.
- *
- * By-path is what lets a boot spec reach EITHER substrate. Inline, pi's node
- * snapshot serialized to 44,252,709 bytes and died at workerd's 32 MiB RPC
- * ceiling the moment it had to cross to a peer; named by path it sends zero
- * bytes, and the host reads them off the coordinator's own disk through the
- * `ResidentDiskReader` it was given.
- */
-import { z } from 'zod/v4';
-import { OpencodeStageSpecSchema } from '../facets/opencode-staging.js';
-/**
- * The class every generated resident runner exports. One name for every
- * runtime: the fabric names it unconditionally, so nothing about which program
- * is running reaches this module.
- */
-export const RESIDENT_PROCESS_CLASS = 'NimbusProcess';
-/**
- * A generated module map. Only bounded, fixed-size module text rides inline;
- * anything whose size is a function of the user's disk is named by VFS path
- * and read when the facet loads, so the bytes are transient rather than
- * resident in the coordinator's heap.
- */
-export const ResidentCodeSpecSchema = z.object({
-    compatibilityDate: z.string().min(1),
-    compatibilityFlags: z.array(z.string()),
-    mainModule: z.string().min(1),
-    /**
-     * Inline modules: fixed-size generated source, plus small wasm sidecars that
-     * come from the worker's own ASSETS rather than the user's disk.
-     */
-    modules: z.record(z.string(), z.union([z.string(), z.object({ wasm: z.instanceof(ArrayBuffer) })])),
-    /**
-     * Module name → absolute VFS path of a wasm image to materialize at load.
-     * This is how the big user-installed runtimes travel: ruby's
-     * interpreter+stdlib image alone is 34.3 MiB.
-     */
-    vfsWasmModules: z.record(z.string(), z.string()).optional(),
-    /**
-     * Module name → absolute VFS path of a GENERATED module source, read as
-     * UTF-8 at load. The same by-path posture as `vfsWasmModules`, for module
-     * text whose size is a function of the user's disk.
-     *
-     * A node facet carries a snapshot of that disk, and it is the largest thing
-     * Nimbus generates: pi's is 3096 cells and inline it serialized to
-     * 44,252,709 bytes. That text cannot be rebuilt from the user's files at
-     * load time either — two thirds of the cells are esbuild ESM→CJS output, and
-     * the manifest and metadata members are walks of the tree rather than files
-     * in it. So the generator materializes its output in the content-addressed
-     * image store below and the spec names it.
-     */
-    vfsTextModules: z.record(z.string(), z.string()).optional(),
-});
-export const ResidentBootSpecSchema = z.discriminatedUnion('kind', [
-    z.object({ kind: z.literal('staged'), stage: OpencodeStageSpecSchema }),
-    z.object({ kind: z.literal('code'), code: ResidentCodeSpecSchema }),
-]);
-// ── Boot-image store ────────────────────────────────────────────────────────
-/**
- * Where a generated module source is materialized so a boot spec can name it.
- *
- * Outside any user working tree on purpose. The passes that build a node
- * facet's snapshot enumerate the process's cwd, so an image written under one
- * would be swept into the next snapshot — and that snapshot is what produced
- * the image, so each spawn would grow the thing it just wrote.
- *
- * Kernel-owned and world-readable: the generator writes as CRED_KERNEL, and
- * every process reads through a supervisor binding that enforces its own
- * credential. Mode 0644 is what makes the read succeed for any process by
- * construction rather than by a privilege carve-out in the permission layer,
- * and leaves the bytes beyond reach of the user whose program they encode.
- */
-export const FACET_IMAGE_DIR = 'var/lib/nimbus/facet-images';
-/**
- * An image is named by the SHA-256 of its own bytes, so its name IS its
- * integrity check and a stale image is not something to invalidate but
- * something that cannot be addressed: different generated text is a different
- * path.
- *
- * What that actually dedups, measured on a deployed worker rather than
- * assumed: a RESTART resolves to the image already there, because the fabric
- * replays one unchanged boot spec. Two separate spawns of the same tool do
- * NOT, whenever the generated text carries anything per-process: an
- * attached-TTY spawn bakes `NIMBUS_CP_CHILD_PID` into `__NIMBUS_ARGS`, so `pi`
- * twice wrote two images (2c3a90ad… then c5b74f1a…). A spawn with no attached
- * TTY has no pid in its args and does dedup. Lifting argv/env/pid out of the
- * generated text into `startArgs` would make every image per-PROGRAM and
- * shareable across spawns and sessions; the sweep bounds the store either way.
- */
-export async function facetImageDigest(source) {
-    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(source));
-    return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, '0')).join('');
-}
-export function facetImagePath(digest) {
-    return `/${FACET_IMAGE_DIR}/${digest}.js`;
-}
-/**
- * The digest an image path claims, for the reader's verify-on-read. Content
- * addressing only holds if the bytes are checked against the name they were
- * fetched under; without that a truncated or overwritten image boots as
- * silently-wrong code, which in a facet surfaces as an unattributable
- * "Cannot find module" a long way from the corruption.
- */
-export function facetImagePathDigest(path) {
-    const match = /(?:^|\/)([0-9a-f]{64})\.js$/.exec(path);
-    return match ? match[1] : null;
-}
-/**
- * Complete a resident-process module map: read every member the spec named by
- * path, verifying each generated image against the digest its own path claims.
- * Runs inside the loader's cache-miss callback, so the bytes exist only for
- * the duration of the load.
- */
-export async function residentLoaderConfig(spec, disk) {
-    const resolved = {};
-    for (const [moduleName, path] of Object.entries(spec.vfsWasmModules ?? {})) {
-        const bytes = await disk.readFile(path);
-        resolved[moduleName] = {
-            wasm: bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),
-        };
-    }
-    for (const [moduleName, path] of Object.entries(spec.vfsTextModules ?? {})) {
-        resolved[moduleName] = await readFacetImage(disk, path);
-    }
-    return {
-        compatibilityDate: spec.compatibilityDate,
-        compatibilityFlags: spec.compatibilityFlags,
-        mainModule: spec.mainModule,
-        modules: { ...spec.modules, ...resolved },
-    };
-}
-/**
- * Read one content-addressed facet image and verify it against the digest its
- * path claims. Content addressing is only a guarantee if the bytes are checked
- * against the name they arrived under: an image that was truncated, or
- * replaced by something the generator never wrote, would otherwise be loaded
- * as the program and fail somewhere inside it with no way back to the cause.
- */
-async function readFacetImage(disk, path) {
-    const expected = facetImagePathDigest(path);
-    if (!expected) {
-        throw new Error(`Nimbus: '${path}' is not a content-addressed facet image path`);
-    }
-    const source = new TextDecoder().decode(await disk.readFile(path));
-    const actual = await facetImageDigest(source);
-    if (actual !== expected) {
-        throw new Error(`Nimbus: facet image '${path}' does not match its digest (read ${actual}); `
-            + 'the image store is corrupt and the process cannot boot from it');
-    }
-    return source;
-}
-// ── Handle ──────────────────────────────────────────────────────────────────
-/**
- * Resource handle for one resident process — the whole surface the kernel
- * above this module sees: `booted()` for the boot payload, `done` for death,
- * `kill()` for teardown, `routeTarget` for inbound HTTP. Substrate-free: the
- * kernel cannot tell from it where the process is running, and never asks.
- *
- * `done` settles when the process ends: for a `lifetime` runner that is its
- * held-open startProcess settling (resolve on exit, reject on host death);
- * for a `boot` runner it is the kill that releases the host.
- *
- * The handle is disposable so FacetManager's existing per-pid resource
- * tracking tears a process down exactly the way it releases any other
- * per-process resource.
- */
-export class ResidentProcessHandle {
-    done;
-    /**
-     * Inbound-HTTP target for PortRegistry: the running facet's own stub. A
-     * facet is a child actor, so its stub stays usable in request contexts long
-     * after the one that created it — which is the whole reason a resident
-     * process can serve a port at all.
-     */
-    routeTarget;
-    #booted;
-    #kill;
-    #killed = false;
-    #describe;
-    constructor(init) {
-        this.done = init.done;
-        this.#booted = init.booted;
-        this.routeTarget = init.routeTarget;
-        this.#kill = init.kill;
-        this.#describe = init.describe;
-        // Symbol.dispose may be absent from older lib targets; wire defensively
-        // so disposeRpcResource() (which probes for it) finds the disposer.
-        const disposeSym = Symbol.dispose;
-        if (disposeSym) {
-            Object.defineProperty(this, disposeSym, { value: () => this.kill() });
-        }
-    }
-    /**
-     * The runner's startProcess payload. The runner is started as part of the
-     * spawn, so this is a handle on that one boot — awaiting it twice is safe
-     * and never re-starts anything. For a `lifetime` runner it settles at exit.
-     */
-    booted() {
-        return this.#booted();
-    }
-    get killed() {
-        return this.#killed;
-    }
-    /** Human-readable placement, for the NIMBUS_DEBUG process-log line. */
-    describePlacement() {
-        return this.#describe();
-    }
-    /** Idempotent: abort the facet and release its isolate. */
-    kill() {
-        if (this.#killed)
-            return;
-        this.#killed = true;
-        try {
-            this.#kill();
-        }
-        catch { /* best-effort teardown */ }
-    }
-}
-/** A promise that settles only when the process is killed. */
-function heldUntilKilled() {
-    let release = () => { };
-    const promise = new Promise((resolve) => { release = resolve; });
-    return { promise, release };
-}
-export class ProcessFabric {
-    host;
-    constructor(host) {
-        this.host = host;
-    }
-    /**
-     * Boot a resident process on this deployment's substrate and return its
-     * handle. Resolves once the process is up and its runner has been started;
-     * rejects on boot failure.
-     *
-     * There is no decision in here. The substrate was chosen once, for the
-     * deployment, and the only thing this method knows about it is the
-     * `ProcessHost` interface.
-     */
-    async startResidentProcess(spawn) {
-        // The facet-local append sequence starts at one when its module evaluates.
-        // Bind that sequence to this concrete incarnation, then retire it only
-        // after the host is released; a later incarnation must use a fresh one.
-        const writerId = crypto.randomUUID();
-        spawn.onWriterActivated(writerId);
-        let hosted;
-        try {
-            hosted = await this.host.open({
-                pid: spawn.pid,
-                workerKey: spawn.workerKey,
-                boot: spawn.boot,
-                writerId,
-                startArgs: spawn.startArgs,
-            });
-        }
-        catch (error) {
-            spawn.onWriterRetired(writerId);
-            throw error;
-        }
-        const held = heldUntilKilled();
-        // Runs at most once, however it is reached — the lifecycle ending, a kill,
-        // or both. Retiring the writer twice would revoke an identity a later
-        // incarnation had already been granted.
-        let releasing = null;
-        const release = () => {
-            if (!releasing) {
-                releasing = (async () => {
-                    try {
-                        await hosted.release();
-                    }
-                    finally {
-                        spawn.onWriterRetired(writerId);
-                    }
-                })();
-                releasing.catch(() => { });
-            }
-            return releasing;
-        };
-        // `lifetime`: the runner's startProcess IS the process, so its settlement
-        // is the lifecycle — a host that dies under it rejects `started`.
-        // `boot`: the runner returns once it is up and the process stays resident
-        // on its host, so residency ends at a kill — or at the host dying, which
-        // is the same thing happening to the process without anyone asking for it.
-        const done = (spawn.startContract === 'lifetime'
-            ? hosted.started.then(() => undefined)
-            : hosted.started.then(() => Promise.race([held.promise, hosted.lost]))).finally(() => release());
-        done.catch(() => { });
-        return new ResidentProcessHandle({
-            done,
-            booted: () => hosted.started,
-            routeTarget: { handleHttpRequest: (request) => hosted.handleHttpRequest(request) },
-            kill: () => { held.release(); void release(); },
-            describe: () => hosted.describe(),
-        });
-    }
-}

package/dist/loaders/vendor/errors.d.ts

@@ -1,24 +0,0 @@
-export declare class ParallelError extends Error {
-    constructor(message: string);
-}
-export declare class SerializationError extends ParallelError {
-    constructor(message: string);
-}
-export declare class ExecutionError extends ParallelError {
-    readonly remoteMessage: string;
-    readonly remoteStack?: string;
-    constructor(message: string, remoteStack?: string);
-}
-export declare class TimeoutError extends ParallelError {
-    readonly deadlineMs: number;
-    constructor(deadlineMs: number);
-}
-export declare class RetryExhaustedError extends ParallelError {
-    readonly lastError: Error;
-    readonly attempts: number;
-    constructor(attempts: number, lastError: Error);
-}
-export declare class BindingError extends ParallelError {
-    constructor(message: string);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/loaders/vendor/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/loaders/vendor/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,kBAAmB,SAAQ,aAAa;gBACvC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,cAAe,SAAQ,aAAa;IAC/C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;gBAElB,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM;CAMlD;AAED,qBAAa,YAAa,SAAQ,aAAa;IAC7C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAEhB,UAAU,EAAE,MAAM;CAK/B;AAED,qBAAa,mBAAoB,SAAQ,aAAa;IACpD,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK;CAQ/C;AAED,qBAAa,YAAa,SAAQ,aAAa;gBACjC,OAAO,EAAE,MAAM;CAI5B"}

package/dist/loaders/vendor/errors.js

@@ -1,46 +0,0 @@
-export class ParallelError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ParallelError';
-    }
-}
-export class SerializationError extends ParallelError {
-    constructor(message) {
-        super(message);
-        this.name = 'SerializationError';
-    }
-}
-export class ExecutionError extends ParallelError {
-    remoteMessage;
-    remoteStack;
-    constructor(message, remoteStack) {
-        super(message);
-        this.name = 'ExecutionError';
-        this.remoteMessage = message;
-        this.remoteStack = remoteStack;
-    }
-}
-export class TimeoutError extends ParallelError {
-    deadlineMs;
-    constructor(deadlineMs) {
-        super(`Task exceeded ${deadlineMs}ms deadline`);
-        this.name = 'TimeoutError';
-        this.deadlineMs = deadlineMs;
-    }
-}
-export class RetryExhaustedError extends ParallelError {
-    lastError;
-    attempts;
-    constructor(attempts, lastError) {
-        super(`Task failed after ${attempts} attempt(s): ${lastError.message}`);
-        this.name = 'RetryExhaustedError';
-        this.attempts = attempts;
-        this.lastError = lastError;
-    }
-}
-export class BindingError extends ParallelError {
-    constructor(message) {
-        super(message);
-        this.name = 'BindingError';
-    }
-}

package/dist/loaders/vendor/serialize.d.ts

@@ -1,3 +0,0 @@
-export declare function serializeFunction(fn: Function): string;
-export declare function hashSource(source: string): string;
-//# sourceMappingURL=serialize.d.ts.map

package/dist/loaders/vendor/serialize.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../../src/loaders/vendor/serialize.ts"],"names":[],"mappings":"AAEA,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,QAAQ,GAAG,MAAM,CAyBtD;AAGD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAMjD"}

package/dist/loaders/vendor/serialize.js

@@ -1,25 +0,0 @@
-import { SerializationError } from './errors.js';
-export function serializeFunction(fn) {
-    if (typeof fn !== 'function') {
-        throw new SerializationError(`Expected a function, got ${typeof fn}`);
-    }
-    const source = fn.toString();
-    if (source.includes('[native code]')) {
-        throw new SerializationError(`Cannot serialize native function: ${fn.name || '(anonymous)'}. ` +
-            'Only user-defined functions can be dispatched to remote isolates.');
-    }
-    // `this` has no receiver in the remote isolate — reject it early.
-    if (/\bthis\b/.test(source)) {
-        throw new SerializationError(`Function "${fn.name || '(anonymous)'}" references \`this\`, which is ` +
-            'not available in a remote isolate. Pass values as explicit arguments instead.');
-    }
-    return source;
-}
-// djb2 hash — fast, deterministic, not cryptographic. Used only for loader cache key differentiation.
-export function hashSource(source) {
-    let hash = 5381;
-    for (let i = 0; i < source.length; i++) {
-        hash = ((hash << 5) + hash + source.charCodeAt(i)) | 0;
-    }
-    return (hash >>> 0).toString(36);
-}

package/dist/loaders/vendor/types.d.ts

@@ -1,69 +0,0 @@
-export interface JsModule {
-    js: string;
-}
-export interface CjsModule {
-    cjs: string;
-}
-export interface PyModule {
-    py: string;
-}
-export interface TextModule {
-    text: string;
-}
-export interface DataModule {
-    data: ArrayBuffer;
-}
-export interface JsonModule {
-    json: unknown;
-}
-/**
- * A compiled WebAssembly module, importable from a facet by module name.
- * Nimbus ships these on every path — sql.js for node:sqlite, the interpreter
- * images for python and ruby — so the omission here was the type lagging the
- * API, not a kind the loader lacks.
- */
-export interface WasmModule {
-    wasm: ArrayBuffer;
-}
-/** Plain string = type inferred from file extension (.js or .py). */
-export type ModuleContent = string | JsModule | CjsModule | PyModule | TextModule | DataModule | JsonModule | WasmModule;
-export interface WorkerCode {
-    compatibilityDate: string;
-    compatibilityFlags?: string[];
-    allowExperimental?: boolean;
-    mainModule: string;
-    modules: Record<string, ModuleContent>;
-    env?: Record<string, unknown>;
-    /**
-     * Network access control:
-     * - `undefined`: inherit parent's network access.
-     * - `null`: block all outbound (fetch/connect throw).
-     * - A service stub: redirect outbound through that binding.
-     */
-    globalOutbound?: ServiceStub | null;
-    tails?: ServiceStub[];
-}
-export interface ServiceStub {
-    fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
-}
-export interface EntrypointOptions {
-    props?: Record<string, unknown>;
-}
-export interface WorkerStub {
-    getEntrypoint(): EntrypointStub;
-    getEntrypoint(name: string, opts?: EntrypointOptions): EntrypointStub;
-}
-export interface EntrypointStub {
-    fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
-    execute(...args: unknown[]): Promise<unknown>;
-}
-export type GetCodeCallback = () => Promise<WorkerCode>;
-export interface WorkerLoader {
-    /**
-     * Load or reuse an isolate by ID. Same ID + same code may reuse an isolate;
-     * different IDs always get fresh isolates. `getCodeCallback` must return
-     * the same content for the same ID.
-     */
-    get(id: string, getCodeCallback: GetCodeCallback): WorkerStub;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/loaders/vendor/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/loaders/vendor/types.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,QAAQ;IAAG,EAAE,EAAE,MAAM,CAAA;CAAE;AACxC,MAAM,WAAW,SAAS;IAAG,GAAG,EAAE,MAAM,CAAA;CAAE;AAC1C,MAAM,WAAW,QAAQ;IAAG,EAAE,EAAE,MAAM,CAAA;CAAE;AACxC,MAAM,WAAW,UAAU;IAAG,IAAI,EAAE,MAAM,CAAA;CAAE;AAC5C,MAAM,WAAW,UAAU;IAAG,IAAI,EAAE,WAAW,CAAA;CAAE;AACjD,MAAM,WAAW,UAAU;IAAG,IAAI,EAAE,OAAO,CAAA;CAAE;AAC7C;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IAAG,IAAI,EAAE,WAAW,CAAA;CAAE;AAEjD,qEAAqE;AACrE,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,UAAU,GACV,UAAU,GACV,UAAU,GACV,UAAU,CAAC;AAEf,MAAM,WAAW,UAAU;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACvC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE9B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IACpC,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CAClE;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,UAAU;IACzB,aAAa,IAAI,cAAc,CAAC;IAChC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,iBAAiB,GAAG,cAAc,CAAC;CACvE;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IACjE,OAAO,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/C;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC;AAExD,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,eAAe,GAAG,UAAU,CAAC;CAC/D"}

package/dist/loaders/vendor/types.js

@@ -1,4 +0,0 @@
-// Types for the Cloudflare Worker Loader API (closed beta).
-// Not yet in @cloudflare/workers-types. Remove this file when they ship.
-// https://developers.cloudflare.com/workers/runtime-apis/bindings/worker-loader/
-export {};