@nimbus-sh/worker 0.1.0

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

@@ -0,0 +1,88 @@
+import type { WorkerLoader } from './types.js';
+import type { WorkerCodeOptions } from './codegen.js';
+export interface ResilienceOptions {
+    timeout?: number;
+    /** Retry attempts after initial failure. 0 = no retries (default). */
+    retries?: number;
+    /** Base delay (ms) between retries. Doubles each attempt. Default: 100. */
+    retryDelay?: number;
+}
+export interface PoolOptions {
+    workerOptions?: WorkerCodeOptions;
+    /**
+     * Bindings forwarded to dynamic workers (KV, R2, AI, D1, etc.).
+     * When set, each function receives an `env` object as its last argument.
+     */
+    bindings?: Record<string, unknown>;
+    /**
+     * Values injected as module-level constants into every generated worker.
+     * Must be JSON-serializable.
+     */
+    context?: Record<string, unknown>;
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+}
+export interface SubmitOptions extends ResilienceOptions {
+    /** Per-call context. Merged with (and overrides) pool-level context. */
+    context?: Record<string, unknown>;
+}
+export type OnErrorStrategy = 'throw' | 'skip' | 'null';
+export interface MapOptions extends ResilienceOptions {
+    concurrency?: number;
+    context?: Record<string, unknown>;
+    /**
+     * Per-item failure handling:
+     * - `'throw'` (default): reject on first failure.
+     * - `'skip'`: omit failed items from results.
+     * - `'null'`: replace failed items with `null`.
+     */
+    onError?: OnErrorStrategy;
+}
+export interface PmapOptions {
+    chunks?: number;
+}
+export interface StreamOptions extends ResilienceOptions {
+    concurrency?: number;
+    context?: Record<string, unknown>;
+}
+export interface StreamResult<T> {
+    index: number;
+    value: T;
+}
+export interface ScatterOptions extends ResilienceOptions {
+    context?: Record<string, unknown>;
+    onError?: OnErrorStrategy;
+}
+export declare class WorkerPool {
+    #private;
+    constructor(loader: WorkerLoader, opts?: PoolOptions);
+    submit<T>(fn: (...args: any[]) => T, ...rest: unknown[]): Promise<Awaited<T>>;
+    map<T, R>(fn: (item: T) => R, items: T[], opts?: MapOptions): Promise<Awaited<R>[]>;
+    /** Tree-parallel reduce: O(log n) depth instead of O(n). */
+    reduce<T>(fn: (a: T, b: T) => T, items: T[], initial: T): Promise<Awaited<T>>;
+    /**
+     * Chunked parallel map. Returns a curried function that splits input
+     * into chunks and maps each chunk on a separate isolate.
+     */
+    pmap<T, R>(fn: (batch: T[]) => R[]): (items: T[], opts?: PmapOptions) => Promise<Awaited<R>[]>;
+    /**
+     * Sequential pipeline where each stage runs on its own isolate.
+     * Output of one stage feeds into the next.
+     */
+    pipe<A, B>(f1: (a: A) => B): (input: A) => Promise<Awaited<B>>;
+    pipe<A, B, C>(f1: (a: A) => B, f2: (b: Awaited<B>) => C): (input: A) => Promise<Awaited<C>>;
+    pipe<A, B, C, D>(f1: (a: A) => B, f2: (b: Awaited<B>) => C, f3: (c: Awaited<C>) => D): (input: A) => Promise<Awaited<D>>;
+    pipe<A, B, C, D, E>(f1: (a: A) => B, f2: (b: Awaited<B>) => C, f3: (c: Awaited<C>) => D, f4: (d: Awaited<D>) => E): (input: A) => Promise<Awaited<E>>;
+    pipe<A, B, C, D, E, F>(f1: (a: A) => B, f2: (b: Awaited<B>) => C, f3: (c: Awaited<C>) => D, f4: (d: Awaited<D>) => E, f5: (e: Awaited<E>) => F): (input: A) => Promise<Awaited<F>>;
+    pipe(...fns: ((...args: any[]) => any)[]): (input: any) => Promise<any>;
+    scatter<T, R>(fn: (items: T[]) => R, items: T[], chunks: number, opts?: ScatterOptions): Promise<Awaited<R>[]>;
+    gather<T>(promises: Promise<T>[]): Promise<T[]>;
+    mapStream<T, R>(fn: (item: T) => R, items: T[], opts?: StreamOptions): AsyncIterable<StreamResult<Awaited<R>>>;
+    /**
+     * Ordered streaming map: yields values in original input order,
+     * buffering out-of-order completions internally.
+     */
+    mapOrdered<T, R>(fn: (item: T) => R, items: T[], opts?: StreamOptions): AsyncIterable<Awaited<R>>;
+}
+//# sourceMappingURL=pool.d.ts.map

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

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

package/dist/loaders/vendor/pool.js

@@ -0,0 +1,353 @@
+import { buildWorkerCode } from './codegen.js';
+import { serializeFunction, hashSource } from './serialize.js';
+import { ExecutionError, BindingError, TimeoutError, RetryExhaustedError, } from './errors.js';
+export class WorkerPool {
+    #loader;
+    #workerOpts;
+    #bindings;
+    #poolContext;
+    #defaultTimeout;
+    #defaultRetries;
+    #defaultRetryDelay;
+    #counter = 0;
+    constructor(loader, opts) {
+        if (!loader || typeof loader.get !== 'function') {
+            throw new BindingError('WorkerPool requires a Worker Loader binding. ' +
+                'Add `[[worker_loaders]]` to your wrangler.toml and pass `env.LOADER`.');
+        }
+        this.#loader = loader;
+        this.#bindings = opts?.bindings;
+        this.#poolContext = opts?.context;
+        this.#defaultTimeout = opts?.timeout;
+        this.#defaultRetries = opts?.retries ?? 0;
+        this.#defaultRetryDelay = opts?.retryDelay ?? 100;
+        // Merge bindings into workerOptions.env so the dynamic worker
+        // receives them as `this.env` (the Worker Loader pattern).
+        if (opts?.bindings) {
+            const existingEnv = opts?.workerOptions?.env ?? {};
+            this.#workerOpts = {
+                ...opts?.workerOptions,
+                env: { ...existingEnv, ...opts.bindings },
+            };
+        }
+        else {
+            this.#workerOpts = opts?.workerOptions;
+        }
+    }
+    #mergeContext(perCall) {
+        if (!this.#poolContext && !perCall)
+            return undefined;
+        if (!this.#poolContext)
+            return perCall;
+        if (!perCall)
+            return this.#poolContext;
+        return { ...this.#poolContext, ...perCall };
+    }
+    #sourceOpts(perCallContext) {
+        const context = this.#mergeContext(perCallContext);
+        const passEnv = !!this.#bindings;
+        if (!context && !passEnv)
+            return undefined;
+        return { context, passEnv };
+    }
+    #resolveResilience(perCall) {
+        return {
+            timeout: perCall?.timeout ?? this.#defaultTimeout,
+            retries: perCall?.retries ?? this.#defaultRetries,
+            retryDelay: perCall?.retryDelay ?? this.#defaultRetryDelay,
+        };
+    }
+    // Core dispatch
+    async #dispatch(fnSource, fnHash, args, perCallContext) {
+        const id = `cfp:${fnHash}:${this.#counter++}`;
+        const workerCode = buildWorkerCode(fnSource, this.#workerOpts, this.#sourceOpts(perCallContext));
+        const stub = this.#loader.get(id, async () => workerCode);
+        const entrypoint = stub.getEntrypoint();
+        try {
+            return await entrypoint.execute(...args);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                throw new ExecutionError(err.message, err.stack);
+            }
+            throw new ExecutionError(String(err));
+        }
+    }
+    async #dispatchWithResilience(fnSource, fnHash, args, resilience, perCallContext) {
+        const { timeout, retries, retryDelay } = this.#resolveResilience(resilience);
+        const maxAttempts = 1 + (retries ?? 0);
+        let lastError;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                const taskPromise = this.#dispatch(fnSource, fnHash, args, perCallContext);
+                if (timeout !== undefined && timeout > 0) {
+                    const result = await Promise.race([
+                        taskPromise,
+                        new Promise((_, reject) => setTimeout(() => reject(new TimeoutError(timeout)), timeout)),
+                    ]);
+                    return result;
+                }
+                return await taskPromise;
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                if (attempt < maxAttempts - 1) {
+                    const delay = (retryDelay ?? 100) * Math.pow(2, attempt);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+        }
+        if (maxAttempts > 1) {
+            throw new RetryExhaustedError(maxAttempts, lastError);
+        }
+        throw lastError;
+    }
+    #prepare(fn) {
+        const fnSource = serializeFunction(fn);
+        const fnHash = hashSource(fnSource);
+        return { fnSource, fnHash };
+    }
+    // Public API
+    async submit(fn, ...rest) {
+        // Last element of `rest` may be a SubmitOptions object.
+        let args;
+        let opts;
+        const last = rest[rest.length - 1];
+        if (rest.length > 0 && isSubmitOptions(last)) {
+            opts = last;
+            args = rest.slice(0, -1);
+        }
+        else {
+            args = rest;
+        }
+        const { fnSource, fnHash } = this.#prepare(fn);
+        return this.#dispatchWithResilience(fnSource, fnHash, args, opts ?? {}, opts?.context);
+    }
+    async map(fn, items, opts) {
+        if (items.length === 0)
+            return [];
+        const { fnSource, fnHash } = this.#prepare(fn);
+        const concurrency = opts?.concurrency ?? items.length;
+        const onError = opts?.onError ?? 'throw';
+        const resilience = {
+            timeout: opts?.timeout,
+            retries: opts?.retries,
+            retryDelay: opts?.retryDelay,
+        };
+        if (onError === 'throw' && concurrency >= items.length) {
+            return Promise.all(items.map((item) => this.#dispatchWithResilience(fnSource, fnHash, [item], resilience, opts?.context)));
+        }
+        // Bounded concurrency and/or partial failure handling.
+        const settled = new Array(items.length);
+        let cursor = 0;
+        const runNext = async () => {
+            while (cursor < items.length) {
+                const idx = cursor++;
+                try {
+                    const value = await this.#dispatchWithResilience(fnSource, fnHash, [items[idx]], resilience, opts?.context);
+                    settled[idx] = { ok: true, value };
+                }
+                catch (err) {
+                    if (onError === 'throw')
+                        throw err;
+                    settled[idx] = {
+                        ok: false,
+                        error: err instanceof Error ? err : new Error(String(err)),
+                    };
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => runNext()));
+        if (onError === 'null') {
+            return settled.map((s) => (s.ok ? s.value : null));
+        }
+        return settled.filter((s) => s.ok).map((s) => s.value);
+    }
+    /** Tree-parallel reduce: O(log n) depth instead of O(n). */
+    async reduce(fn, items, initial) {
+        if (items.length === 0)
+            return initial;
+        const { fnSource, fnHash } = this.#prepare(fn);
+        let current = [initial, ...items];
+        while (current.length > 1) {
+            const tasks = [];
+            const carryForward = [];
+            for (let i = 0; i < current.length; i += 2) {
+                if (i + 1 < current.length) {
+                    tasks.push(this.#dispatch(fnSource, fnHash, [current[i], current[i + 1]]));
+                }
+                else {
+                    carryForward.push({ index: tasks.length, value: current[i] });
+                    tasks.push(Promise.resolve(current[i]));
+                }
+            }
+            const round = await Promise.all(tasks);
+            current = round;
+        }
+        return current[0];
+    }
+    /**
+     * Chunked parallel map. Returns a curried function that splits input
+     * into chunks and maps each chunk on a separate isolate.
+     */
+    pmap(fn) {
+        const { fnSource, fnHash } = this.#prepare(fn);
+        return async (items, opts) => {
+            if (items.length === 0)
+                return [];
+            const numChunks = opts?.chunks ?? items.length;
+            const chunkSize = Math.ceil(items.length / numChunks);
+            const chunks = [];
+            for (let i = 0; i < items.length; i += chunkSize) {
+                chunks.push(items.slice(i, i + chunkSize));
+            }
+            const chunkResults = await Promise.all(chunks.map((chunk) => this.#dispatch(fnSource, fnHash, [chunk])));
+            return chunkResults.flat();
+        };
+    }
+    pipe(...fns) {
+        const stages = fns.map((fn) => this.#prepare(fn));
+        return async (input) => {
+            let value = input;
+            for (const { fnSource, fnHash } of stages) {
+                value = await this.#dispatch(fnSource, fnHash, [value]);
+            }
+            return value;
+        };
+    }
+    async scatter(fn, items, chunks, opts) {
+        if (items.length === 0)
+            return [];
+        const { fnSource, fnHash } = this.#prepare(fn);
+        const chunkSize = Math.ceil(items.length / chunks);
+        const batches = [];
+        for (let i = 0; i < items.length; i += chunkSize) {
+            batches.push(items.slice(i, i + chunkSize));
+        }
+        const onError = opts?.onError ?? 'throw';
+        const resilience = {
+            timeout: opts?.timeout,
+            retries: opts?.retries,
+            retryDelay: opts?.retryDelay,
+        };
+        if (onError === 'throw') {
+            return Promise.all(batches.map((batch) => this.#dispatchWithResilience(fnSource, fnHash, [batch], resilience, opts?.context)));
+        }
+        const results = await Promise.all(batches.map(async (batch) => {
+            try {
+                const value = await this.#dispatchWithResilience(fnSource, fnHash, [batch], resilience, opts?.context);
+                return { ok: true, value };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    error: err instanceof Error ? err : new Error(String(err)),
+                };
+            }
+        }));
+        if (onError === 'null') {
+            return results.map((r) => (r.ok ? r.value : null));
+        }
+        return results.filter((r) => r.ok).map((r) => r.value);
+    }
+    async gather(promises) {
+        return Promise.all(promises);
+    }
+    // Streaming iterators
+    async *mapStream(fn, items, opts) {
+        if (items.length === 0)
+            return;
+        const { fnSource, fnHash } = this.#prepare(fn);
+        const concurrency = opts?.concurrency ?? items.length;
+        const resilience = {
+            timeout: opts?.timeout,
+            retries: opts?.retries,
+            retryDelay: opts?.retryDelay,
+        };
+        // Channel: pre-allocate a promise per item. Producers resolve them
+        // in completion order; the consumer awaits them sequentially.
+        const queue = [];
+        for (let i = 0; i < items.length; i++) {
+            let resolve;
+            let reject;
+            const promise = new Promise((res, rej) => {
+                resolve = res;
+                reject = rej;
+            });
+            queue.push({ resolve, reject, promise });
+        }
+        let completionSlot = 0;
+        let cursor = 0;
+        const dispatchNext = async () => {
+            while (cursor < items.length) {
+                const itemIdx = cursor++;
+                const slot = completionSlot++;
+                try {
+                    const value = await this.#dispatchWithResilience(fnSource, fnHash, [items[itemIdx]], resilience, opts?.context);
+                    queue[slot].resolve({ index: itemIdx, value });
+                }
+                catch (err) {
+                    queue[slot].reject(err instanceof Error ? err : new Error(String(err)));
+                }
+            }
+        };
+        const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => dispatchNext());
+        for (let i = 0; i < items.length; i++) {
+            yield await queue[i].promise;
+        }
+        await Promise.all(workers);
+    }
+    /**
+     * Ordered streaming map: yields values in original input order,
+     * buffering out-of-order completions internally.
+     */
+    async *mapOrdered(fn, items, opts) {
+        if (items.length === 0)
+            return;
+        const { fnSource, fnHash } = this.#prepare(fn);
+        const concurrency = opts?.concurrency ?? items.length;
+        const resilience = {
+            timeout: opts?.timeout,
+            retries: opts?.retries,
+            retryDelay: opts?.retryDelay,
+        };
+        // One promise per item, indexed by original position.
+        // Lets us yield in order regardless of completion order.
+        const slots = new Array(items.length);
+        let cursor = 0;
+        const dispatchNext = async () => {
+            while (cursor < items.length) {
+                const idx = cursor++;
+                slots[idx] = this.#dispatchWithResilience(fnSource, fnHash, [items[idx]], resilience, opts?.context);
+                await slots[idx].catch(() => { });
+            }
+        };
+        const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => dispatchNext());
+        for (let i = 0; i < items.length; i++) {
+            // Spin-wait for slot assignment if a slow worker hasn't dispatched yet.
+            while (slots[i] === undefined) {
+                await new Promise((r) => setTimeout(r, 1));
+            }
+            yield await slots[i];
+        }
+        await Promise.all(workers);
+    }
+}
+/**
+ * Heuristic: detect whether the last argument to submit() is a SubmitOptions
+ * object rather than a regular argument. Checks for a plain object with at
+ * least one recognized option key.
+ */
+function isSubmitOptions(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    if (value instanceof Date || value instanceof RegExp || value instanceof Map) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    const optionKeys = new Set([
+        'timeout', 'retries', 'retryDelay', 'context',
+    ]);
+    return keys.length > 0 && keys.some((k) => optionKeys.has(k));
+}

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

@@ -0,0 +1,11 @@
+export type Pure<F> = F & {
+    readonly __pure: true;
+};
+export declare function pure<F extends Function>(fn: F): Pure<F>;
+export declare function isPure(fn: Function): fn is Pure<typeof fn>;
+/**
+ * Identity function that signals a value is intended as a serializable
+ * constant for remote execution. No-op at runtime.
+ */
+export declare function constant<T>(value: T): T;
+//# sourceMappingURL=primitives.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../../src/loaders/vendor/primitives.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC;AAEpD,wBAAgB,IAAI,CAAC,CAAC,SAAS,QAAQ,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CA+BvD;AAED,wBAAgB,MAAM,CAAC,EAAE,EAAE,QAAQ,GAAG,EAAE,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC,CAE1D;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEvC"}

package/dist/loaders/vendor/primitives.js

@@ -0,0 +1,33 @@
+import { SerializationError } from './errors.js';
+export function pure(fn) {
+    if (typeof fn !== 'function') {
+        throw new SerializationError(`pure() expected a function, got ${typeof fn}`);
+    }
+    const source = fn.toString();
+    if (source.includes('[native code]')) {
+        throw new SerializationError(`pure(): cannot brand native function "${fn.name || '(anonymous)'}"`);
+    }
+    if (/\bthis\b/.test(source)) {
+        throw new SerializationError(`pure(): function "${fn.name || '(anonymous)'}" references \`this\`, ` +
+            'which is not available in a remote isolate. Remove `this` usage or ' +
+            'pass the value as an explicit argument.');
+    }
+    const branded = fn;
+    Object.defineProperty(branded, '__pure', {
+        value: true,
+        writable: false,
+        enumerable: false,
+        configurable: false,
+    });
+    return branded;
+}
+export function isPure(fn) {
+    return fn.__pure === true;
+}
+/**
+ * Identity function that signals a value is intended as a serializable
+ * constant for remote execution. No-op at runtime.
+ */
+export function constant(value) {
+    return value;
+}

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,60 @@
+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;
+}
+/** Plain string = type inferred from file extension (.js or .py). */
+export type ModuleContent = string | JsModule | CjsModule | PyModule | TextModule | DataModule | JsonModule;
+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

@@ -0,0 +1 @@
+{"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;AAE7C,qEAAqE;AACrE,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,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

@@ -0,0 +1,4 @@
+// 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 {};