@nimbus-sh/worker 0.6.0 → 0.8.0

package/dist/facets/on-demand-bundle-gate.js

@@ -1,125 +0,0 @@
-/**
- * OnDemandBundleGate — memory-bounded admission control for on-demand
- * /@modules/ bundling.
- *
- * Why this exists
- * ───────────────
- * The dev server bundles user packages on demand by building a file
- * "slice" in the supervisor heap (up to SLICE_CAP_BYTES ≈ 28 MiB) and
- * shipping it to a facet isolate over RPC. The facet RPC round-trip is
- * the dominant wall time; the supervisor just holds the slice array
- * alive until the clone completes. A fresh React app first-load requests
- * many distinct /@modules/ concurrently, so the naive path either:
- *   - builds all slices at once → peak heap = N × 28 MiB → supervisor
- *     OOM on a shared DO isolate (the install-time pre-bundler proved
- *     concurrency=2 of max slices crashes a Mossaic-scale isolate), or
- *   - serializes everything behind one slot → multi-second first load.
- *
- * This gate threads the needle: it bounds the TOTAL slice BYTES resident
- * at once (not a count), so many SMALL slices' RPC round-trips overlap
- * while a single LARGE slice still serializes the rest — peak resident
- * slice bytes never exceed `budgetBytes`, which is set to one slice cap.
- *
- * How it bounds peak heap
- * ───────────────────────
- *   - Only ONE slice is ever mid-BUILD (a build lock): the slice array
- *     does not exist until built, so we can't reserve its real size up
- *     front. Serializing the (fast, synchronous) build means at most one
- *     un-accounted slice exists at any instant.
- *   - The moment a build finishes, the caller `admit(realBytes)`s: that
- *     reserves the slice's actual size against the byte budget (blocking
- *     if the budget is full) and only THEN releases the build lock for
- *     the next builder.
- *   - Reserved bytes are released when the caller's work (the facet
- *     submit) settles.
- *
- * Invariant: at any instant, Σ(reserved bytes of in-flight submits) +
- * (one building slice, already counted the moment it admits) ≤
- * budgetBytes. With budgetBytes = SLICE_CAP_BYTES the peak matches the
- * single-slot serialization it replaces — no heap regression — while
- * small slices proceed concurrently.
- */
-export class OnDemandBundleGate {
-    budgetBytes;
-    buildLock = Promise.resolve();
-    reservedBytes = 0;
-    /** FIFO queue of callers blocked on byte-budget headroom. */
-    byteWaiters = [];
-    constructor(budgetBytes) {
-        this.budgetBytes = budgetBytes;
-        if (budgetBytes <= 0)
-            throw new Error('OnDemandBundleGate budgetBytes must be > 0');
-    }
-    /**
-     * Run a build-then-submit job under the gate.
-     *
-     * `job` receives an `admit(bytes)` callback it MUST call exactly once,
-     * after its slice is built and its real byte size is known, before the
-     * long-running submit. `admit` reserves the bytes and releases the
-     * build lock so the next job can start building. Jobs that bail before
-     * building a slice (early return / error) simply never call `admit`;
-     * the build lock is released when `job` settles either way.
-     */
-    async run(job) {
-        // Acquire the build lock (serialize slice construction).
-        const prev = this.buildLock;
-        let releaseBuild;
-        this.buildLock = new Promise((res) => { releaseBuild = res; });
-        await prev;
-        let admittedBytes = 0;
-        let buildReleased = false;
-        const releaseBuildOnce = () => {
-            if (!buildReleased) {
-                buildReleased = true;
-                releaseBuild();
-            }
-        };
-        const admit = async (bytes) => {
-            const clamped = Math.max(0, Math.min(bytes, this.budgetBytes));
-            await this.acquireBytes(clamped);
-            admittedBytes = clamped;
-            // Slice is now accounted against the budget — let the next slice build.
-            releaseBuildOnce();
-        };
-        try {
-            return await job(admit);
-        }
-        finally {
-            // If the job never admitted (bailed pre-build), free the build lock now.
-            releaseBuildOnce();
-            if (admittedBytes > 0)
-                this.releaseBytes(admittedBytes);
-        }
-    }
-    acquireBytes(bytes) {
-        // Admit when the reservation fits, OR when nothing is reserved (so a
-        // single slice larger than the budget still makes progress instead of
-        // deadlocking). FIFO: a waiter that doesn't fit blocks later waiters
-        // even if they would, to avoid starving large slices.
-        if (this.byteWaiters.length === 0 &&
-            (this.reservedBytes + bytes <= this.budgetBytes || this.reservedBytes === 0)) {
-            this.reservedBytes += bytes;
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => {
-            this.byteWaiters.push({ bytes, resolve });
-        });
-    }
-    releaseBytes(bytes) {
-        this.reservedBytes = Math.max(0, this.reservedBytes - bytes);
-        // Wake head-of-line waiters that now fit. Strict FIFO: stop at the
-        // first waiter that doesn't fit (unless nothing is reserved, in which
-        // case admit it anyway so an oversized slice can't deadlock).
-        while (this.byteWaiters.length > 0) {
-            const head = this.byteWaiters[0];
-            const fits = this.reservedBytes + head.bytes <= this.budgetBytes || this.reservedBytes === 0;
-            if (!fits)
-                break;
-            this.byteWaiters.shift();
-            this.reservedBytes += head.bytes;
-            head.resolve();
-        }
-    }
-    /** Test/diagnostic snapshot. */
-    get inFlightBytes() { return this.reservedBytes; }
-}

package/dist/npm/install-args.d.ts

@@ -1,21 +0,0 @@
-import { type NpmLogLevel } from './npm-log.js';
-export interface NpmInstallInvocation {
-    packages: string[];
-    global: boolean;
-    prefix: string | null;
-    /** `--loglevel`, when it names a level npm recognises; null otherwise. */
-    loglevel: NpmLogLevel | null;
-    /**
-     * `--production` / `-p` / `--omit=dev`: install dependencies only.
-     *
-     * Both npm and bun honour this, and it is the one answer a project has to a
-     * devDependency Nimbus cannot run — a headless-browser driver, a native
-     * toolchain — when the thing being installed is the runtime, not the test
-     * suite. The flag was in the arg spec but its value was dropped, so it
-     * silently did nothing and the install failed on a package the caller had
-     * already said to skip.
-     */
-    production: boolean;
-}
-export declare function parseNpmInstallInvocation(args: string[]): NpmInstallInvocation;
-//# sourceMappingURL=install-args.d.ts.map

package/dist/npm/install-args.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"install-args.d.ts","sourceRoot":"","sources":["../../src/npm/install-args.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAElE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;IAC7B;;;;;;;;;OASG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAmCD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,oBAAoB,CAS9E"}

package/dist/npm/install-args.js

@@ -1,70 +0,0 @@
-import { parseArgs } from '@nimbus-sh/core/substrate/lifo/utils/args.js';
-import { parseNpmLogLevel } from './npm-log.js';
-const INSTALL_ARG_SPEC = {
-    global: { type: 'boolean', short: 'g' },
-    prefix: { type: 'string' },
-    loglevel: { type: 'string' },
-    registry: { type: 'string' },
-    tag: { type: 'string' },
-    cache: { type: 'string' },
-    omit: { type: 'string' },
-    include: { type: 'string' },
-    workspace: { type: 'string', short: 'w' },
-    'min-release-age': { type: 'string' },
-    'save-prefix': { type: 'string' },
-    'ignore-scripts': { type: 'boolean' },
-    'no-fund': { type: 'boolean' },
-    fund: { type: 'boolean' },
-    'no-audit': { type: 'boolean' },
-    audit: { type: 'boolean' },
-    progress: { type: 'boolean' },
-    save: { type: 'boolean', short: 'S' },
-    'save-dev': { type: 'boolean', short: 'D' },
-    'save-prod': { type: 'boolean', short: 'P' },
-    'save-optional': { type: 'boolean', short: 'O' },
-    'save-exact': { type: 'boolean', short: 'E' },
-    'package-lock': { type: 'boolean' },
-    'dry-run': { type: 'boolean' },
-    force: { type: 'boolean', short: 'f' },
-    'legacy-peer-deps': { type: 'boolean' },
-    workspaces: { type: 'boolean' },
-    // bun spells it `-p`; npm's `-P` is --save-prod, and the short map is
-    // case-sensitive, so both tools' spellings land where they should.
-    production: { type: 'boolean', short: 'p' },
-};
-export function parseNpmInstallInvocation(args) {
-    const parsed = parseArgs(args, INSTALL_ARG_SPEC);
-    return {
-        packages: parsed.positional,
-        global: parsed.flags.global === true,
-        prefix: stringFlag(parsed.flags.prefix),
-        loglevel: parseNpmLogLevel(parsed.flags.loglevel),
-        production: parsed.flags.production === true || omittedDependencyTypes(args).has('dev'),
-    };
-}
-/**
- * Every `--omit` in the invocation. npm allows the flag more than once
- * (`--omit=dev --omit=optional`), and the generic parser keeps only the last
- * value — so the one spelling that matters would be missed whenever a caller
- * omitted more than one kind.
- */
-function omittedDependencyTypes(args) {
-    const omitted = new Set();
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === '--')
-            break;
-        if (arg === '--omit') {
-            const value = args[++i];
-            if (value)
-                omitted.add(value);
-        }
-        else if (arg.startsWith('--omit=')) {
-            omitted.add(arg.slice('--omit='.length));
-        }
-    }
-    return omitted;
-}
-function stringFlag(value) {
-    return typeof value === 'string' && value.length > 0 ? value : null;
-}

package/dist/npm/npm-log.d.ts

@@ -1,31 +0,0 @@
-/**
- * npm's own log protocol, as emitted under `--loglevel`.
- *
- * Third-party tooling parses these lines rather than any prose we invent:
- * pi's `install.sh` runs `npm install --loglevel=verbose`, tees the output
- * to a file and advances its spinner label off `npm verbose title`,
- * `npm http fetch GET …` and `npm http cache …`. Discarding the flag left
- * that label frozen at "starting npm install" for the whole install, so
- * honouring it means speaking npm's wire format on the same stream.
- */
-export type NpmLogLevel = 'silent' | 'error' | 'warn' | 'notice' | 'http' | 'info' | 'verbose' | 'silly';
-/** The level a line is reported at; the caller decides whether to print it. */
-export type NpmLogEmitter = (level: NpmLogLevel, line: string) => void;
-export declare function parseNpmLogLevel(value: unknown): NpmLogLevel | null;
-export declare function npmLogEnabled(configured: NpmLogLevel | null, line: NpmLogLevel): boolean;
-/**
- * `npm verbose title npm install …` — npm's first verbose line, and the one
- * that tells a watcher the resolution phase has begun.
- */
-export declare function npmTitleLine(packages: readonly string[]): string;
-/** `npm http fetch GET 200 <url> <ms>ms (cache miss)` — served from the registry. */
-export declare function npmHttpFetchLine(url: string, elapsedMs: number): string;
-/**
- * `npm http cache <url>` — served from a cache tier without a registry
- * request. Tarball lines carry the integrity prefix npm uses as the cache
- * key, which is also how a watcher tells a tarball from a packument.
- */
-export declare function npmHttpCacheLine(url: string, integrity?: string): string;
-/** `added N packages in Xs` — npm's install summary, unstyled. */
-export declare function npmAddedLine(packages: number, elapsedMs: number): string;
-//# sourceMappingURL=npm-log.d.ts.map

package/dist/npm/npm-log.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"npm-log.d.ts","sourceRoot":"","sources":["../../src/npm/npm-log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,MAAM,WAAW,GACnB,QAAQ,GACR,OAAO,GACP,MAAM,GACN,QAAQ,GACR,MAAM,GACN,MAAM,GACN,SAAS,GACT,OAAO,CAAC;AAcZ,+EAA+E;AAC/E,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;AAEvE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAEnE;AAED,wBAAgB,aAAa,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAExF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAEhE;AAED,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAExE;AAED,kEAAkE;AAClE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAGxE"}

package/dist/npm/npm-log.js

@@ -1,51 +0,0 @@
-/**
- * npm's own log protocol, as emitted under `--loglevel`.
- *
- * Third-party tooling parses these lines rather than any prose we invent:
- * pi's `install.sh` runs `npm install --loglevel=verbose`, tees the output
- * to a file and advances its spinner label off `npm verbose title`,
- * `npm http fetch GET …` and `npm http cache …`. Discarding the flag left
- * that label frozen at "starting npm install" for the whole install, so
- * honouring it means speaking npm's wire format on the same stream.
- */
-/** npm's own ordering: a level enables itself and everything quieter. */
-const LEVEL_RANK = {
-    silent: 0,
-    error: 1,
-    warn: 2,
-    notice: 3,
-    http: 4,
-    info: 5,
-    verbose: 6,
-    silly: 7,
-};
-export function parseNpmLogLevel(value) {
-    return typeof value === 'string' && value in LEVEL_RANK ? value : null;
-}
-export function npmLogEnabled(configured, line) {
-    return configured !== null && LEVEL_RANK[configured] >= LEVEL_RANK[line];
-}
-/**
- * `npm verbose title npm install …` — npm's first verbose line, and the one
- * that tells a watcher the resolution phase has begun.
- */
-export function npmTitleLine(packages) {
-    return `npm verbose title npm install${packages.map((p) => ` ${p}`).join('')}`;
-}
-/** `npm http fetch GET 200 <url> <ms>ms (cache miss)` — served from the registry. */
-export function npmHttpFetchLine(url, elapsedMs) {
-    return `npm http fetch GET 200 ${url} ${Math.max(0, Math.round(elapsedMs))}ms (cache miss)`;
-}
-/**
- * `npm http cache <url>` — served from a cache tier without a registry
- * request. Tarball lines carry the integrity prefix npm uses as the cache
- * key, which is also how a watcher tells a tarball from a packument.
- */
-export function npmHttpCacheLine(url, integrity) {
-    return `npm http cache ${integrity ? `${integrity}@${url}` : url}`;
-}
-/** `added N packages in Xs` — npm's install summary, unstyled. */
-export function npmAddedLine(packages, elapsedMs) {
-    const unit = packages === 1 ? 'package' : 'packages';
-    return `added ${packages} ${unit} in ${(elapsedMs / 1000).toFixed(1)}s`;
-}