@nimbus-sh/core 0.5.0 → 0.7.0

package/dist/_shared/weighted-credit-pool.d.ts

@@ -1,61 +0,0 @@
-export interface CreditLease {
-    readonly bytes: number;
-    release(): void;
-}
-export interface ResizableCreditLease extends CreditLease {
-    shrinkTo(bytes: number): void;
-}
-export interface WeightedCreditPoolStats {
-    readonly current: number;
-    readonly peak: number;
-    readonly queued: number;
-}
-export interface WeightedCreditPoolOptions {
-    /**
-     * Requests at or below this size draw from `reserve` instead of the shared
-     * capacity. Omit to keep a single lane.
-     */
-    readonly smallRequestBytes?: number;
-    /**
-     * Bytes set aside for small requests. Held apart from `capacity` so a
-     * full-capacity owner stays grantable and small requests stay servable
-     * while it works.
-     */
-    readonly reserve?: number;
-}
-/**
- * FIFO byte-credit pool shared by concurrent allocation owners.
- * Capacity is measured in retained bytes, not operation count.
- *
- * One FIFO queue makes every request wait behind the one ahead of it even
- * when the pool has room to spare — `tryAcquire` refuses outright while
- * anyone is queued — so a single multi-megabyte owner parks every request
- * behind it for as long as it holds. Between owners of comparable size that
- * is the point. For a chunk-sized filesystem read it means a wait with
- * nothing to do with its own cost.
- *
- * So a request at or below `smallRequestBytes` takes shared capacity when
- * that can be granted outright, and otherwise falls back to a separate
- * `reserve` where it queues only among its own kind. It never joins the
- * shared queue, so it is never parked behind a larger owner.
- *
- * Neither side can starve the other. Shared capacity stops admitting small
- * requests the moment anything is queued for it, so a large waiter is never
- * overtaken; and the reserve is held apart from `capacity`, so a
- * full-capacity owner stays grantable while small requests stay servable.
- * Peak occupancy only reaches `capacity + reserve` while the shared lane is
- * contended.
- */
-export declare class WeightedCreditPool {
-    readonly capacity: number;
-    private readonly general;
-    private readonly small;
-    private readonly smallRequestBytes;
-    constructor(capacity: number, options?: WeightedCreditPoolOptions);
-    get stats(): WeightedCreditPoolStats;
-    private isSmall;
-    tryAcquire(bytes: number): ResizableCreditLease | null;
-    acquire(bytes: number, signal?: AbortSignal): Promise<ResizableCreditLease>;
-    private validateRequest;
-}
-//# sourceMappingURL=weighted-credit-pool.d.ts.map

package/dist/_shared/weighted-credit-pool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"weighted-credit-pool.d.ts","sourceRoot":"","sources":["../../src/_shared/weighted-credit-pool.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,oBAAqB,SAAQ,WAAW;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAkHD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,kBAAkB;IAKjB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAJrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;gBAEtB,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B;IAoB9E,IAAI,KAAK,IAAI,uBAAuB,CASnC;IAED,OAAO,CAAC,OAAO;IAIf,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI;IAOtD,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAiB3E,OAAO,CAAC,eAAe;CAOxB"}

package/dist/_shared/weighted-credit-pool.js

@@ -1,196 +0,0 @@
-/** One FIFO queue over one byte capacity. */
-class CreditLane {
-    capacity;
-    current = 0;
-    peak = 0;
-    waiters = [];
-    constructor(capacity) {
-        this.capacity = capacity;
-    }
-    get stats() {
-        return { current: this.current, peak: this.peak, queued: this.waiters.length };
-    }
-    tryAcquire(bytes) {
-        if (this.waiters.length > 0 || this.current + bytes > this.capacity)
-            return null;
-        return this.grant(bytes);
-    }
-    acquire(bytes, signal) {
-        if (signal?.aborted)
-            return Promise.reject(abortError(signal));
-        const immediate = this.tryAcquire(bytes);
-        if (immediate)
-            return Promise.resolve(immediate);
-        return new Promise((resolve, reject) => {
-            const waiter = {
-                bytes,
-                resolve,
-                reject,
-                signal,
-                onAbort: signal
-                    ? () => {
-                        const index = this.waiters.indexOf(waiter);
-                        if (index < 0)
-                            return;
-                        this.waiters.splice(index, 1);
-                        signal.removeEventListener('abort', waiter.onAbort);
-                        reject(abortError(signal));
-                        this.drain();
-                    }
-                    : undefined,
-            };
-            this.waiters.push(waiter);
-            signal?.addEventListener('abort', waiter.onAbort, { once: true });
-            if (signal?.aborted) {
-                waiter.onAbort();
-                return;
-            }
-            this.drain();
-        });
-    }
-    grant(bytes) {
-        this.current += bytes;
-        this.peak = Math.max(this.peak, this.current);
-        let leasedBytes = bytes;
-        let released = false;
-        return {
-            get bytes() {
-                return leasedBytes;
-            },
-            shrinkTo: (nextBytes) => {
-                if (released) {
-                    throw new Error('cannot shrink a released weighted credit lease');
-                }
-                if (!Number.isSafeInteger(nextBytes)
-                    || nextBytes <= 0
-                    || nextBytes > leasedBytes) {
-                    throw new RangeError(`weighted credit lease can only shrink to a positive safe integer no larger than ${leasedBytes}: ${nextBytes}`);
-                }
-                this.current -= leasedBytes - nextBytes;
-                leasedBytes = nextBytes;
-                this.drain();
-            },
-            release: () => {
-                if (released)
-                    return;
-                released = true;
-                this.current -= leasedBytes;
-                if (this.current < 0) {
-                    throw new Error('weighted credit accounting underflow');
-                }
-                this.drain();
-            },
-        };
-    }
-    drain() {
-        while (this.waiters.length > 0) {
-            const waiter = this.waiters[0];
-            if (waiter.signal?.aborted) {
-                this.waiters.shift();
-                waiter.signal.removeEventListener('abort', waiter.onAbort);
-                waiter.reject(abortError(waiter.signal));
-                continue;
-            }
-            if (this.current + waiter.bytes > this.capacity)
-                return;
-            this.waiters.shift();
-            waiter.signal?.removeEventListener('abort', waiter.onAbort);
-            waiter.resolve(this.grant(waiter.bytes));
-        }
-    }
-}
-/**
- * FIFO byte-credit pool shared by concurrent allocation owners.
- * Capacity is measured in retained bytes, not operation count.
- *
- * One FIFO queue makes every request wait behind the one ahead of it even
- * when the pool has room to spare — `tryAcquire` refuses outright while
- * anyone is queued — so a single multi-megabyte owner parks every request
- * behind it for as long as it holds. Between owners of comparable size that
- * is the point. For a chunk-sized filesystem read it means a wait with
- * nothing to do with its own cost.
- *
- * So a request at or below `smallRequestBytes` takes shared capacity when
- * that can be granted outright, and otherwise falls back to a separate
- * `reserve` where it queues only among its own kind. It never joins the
- * shared queue, so it is never parked behind a larger owner.
- *
- * Neither side can starve the other. Shared capacity stops admitting small
- * requests the moment anything is queued for it, so a large waiter is never
- * overtaken; and the reserve is held apart from `capacity`, so a
- * full-capacity owner stays grantable while small requests stay servable.
- * Peak occupancy only reaches `capacity + reserve` while the shared lane is
- * contended.
- */
-export class WeightedCreditPool {
-    capacity;
-    general;
-    small;
-    smallRequestBytes;
-    constructor(capacity, options = {}) {
-        this.capacity = capacity;
-        if (!Number.isSafeInteger(capacity) || capacity <= 0) {
-            throw new RangeError(`weighted credit capacity must be a positive safe integer: ${capacity}`);
-        }
-        const smallRequestBytes = options.smallRequestBytes ?? 0;
-        const reserve = options.reserve ?? 0;
-        if (!Number.isSafeInteger(smallRequestBytes) || smallRequestBytes < 0
-            || !Number.isSafeInteger(reserve) || reserve < 0) {
-            throw new RangeError('weighted credit reserve and small-request size must be non-negative safe integers');
-        }
-        if (smallRequestBytes > reserve) {
-            throw new RangeError(`a small request (${smallRequestBytes}) must fit in the reserve (${reserve}) or it could never be granted`);
-        }
-        this.general = new CreditLane(capacity);
-        this.smallRequestBytes = smallRequestBytes;
-        this.small = smallRequestBytes > 0 ? new CreditLane(reserve) : null;
-    }
-    get stats() {
-        const general = this.general.stats;
-        if (!this.small)
-            return general;
-        const small = this.small.stats;
-        return {
-            current: general.current + small.current,
-            peak: general.peak + small.peak,
-            queued: general.queued + small.queued,
-        };
-    }
-    isSmall(bytes) {
-        return this.small !== null && bytes <= this.smallRequestBytes;
-    }
-    tryAcquire(bytes) {
-        this.validateRequest(bytes);
-        const shared = this.general.tryAcquire(bytes);
-        if (shared || !this.isSmall(bytes))
-            return shared;
-        return this.small.tryAcquire(bytes);
-    }
-    acquire(bytes, signal) {
-        try {
-            this.validateRequest(bytes);
-        }
-        catch (error) {
-            return Promise.reject(error);
-        }
-        if (this.isSmall(bytes)) {
-            // Shared capacity while it is free — a small request should get the
-            // same concurrency as any other when nothing is contending. It never
-            // joins the shared queue, so it cannot be parked behind a large owner.
-            const shared = this.general.tryAcquire(bytes);
-            if (shared)
-                return Promise.resolve(shared);
-            return this.small.acquire(bytes, signal);
-        }
-        return this.general.acquire(bytes, signal);
-    }
-    validateRequest(bytes) {
-        if (!Number.isSafeInteger(bytes) || bytes <= 0 || bytes > this.capacity) {
-            throw new RangeError(`weighted credit request must be a positive safe integer no larger than ${this.capacity}: ${bytes}`);
-        }
-    }
-}
-function abortError(signal) {
-    const reason = signal.reason;
-    return new DOMException(reason instanceof Error ? reason.message : String(reason ?? 'The operation was aborted'), 'AbortError');
-}

package/dist/observability/diag-counters.d.ts

@@ -1,236 +0,0 @@
-/**
- * diag-counters.ts — application-level memory + phase observability.
- *
- * Why: workerd's `process.memoryUsage()` returns 0 for all fields inside
- * a Durable Object class context (only dynamic-worker isolates under
- * nodejs_compat get the real implementation). Without a working heap
- * probe we have no way to confirm OOM hypotheses or verify a fix.
- *
- * Replacement: deterministic counters bumped at known allocation sites.
- * Cumulative bytes decoded, in-flight stub counts, and phase markers
- * give us the same operational signal as a heap probe — and they're
- * exact, not estimated.
- *
- * Singleton-per-isolate. Lives at module scope so any code path in the
- * supervisor bundle can write to it (installer and RPC handlers) and
- * the request handler in nimbus-session.ts:/api/_diag/memory can read
- * it. Survives across requests within the same isolate; resets on DO
- * reboot — itself a useful signal (counters at 0 immediately after the
- * banner reprinted = the killed isolate took its state with it).
- */
-/**
- * Phase tags surfaced via /api/_diag/memory. Strings are ASCII so
- * humans can grep for them in logs.
- *
- * installPhase tracks the high-level npm-install state machine:
- *   idle → resolve → hoist → diff → fetch → write → link-bins → bundle → done
- *
- */
-import type { InstallPhase } from '../_shared/install-phase.js';
-export interface DiagCounters {
-    /** Top-level install phase. */
-    installPhase: InstallPhase;
-    /**
-     * Sum of payload bytes claimed by RPCs currently in flight on the
-     * SUPERVISOR boundary [Phase 2 A'.2].
-     *
-     * Bumped at RPC entry by `rpcPayloadStart(bytes)` in the DO-side
-     * byte-returning handlers in src/session/rpc.ts; debited at exit by
-     * `rpcPayloadEnd(bytes)`. Goes back to zero after every RPC settles.
-     *
-     * The C'.1 heap estimator surfaces this as
-     * `breakdown.streamingBuffersBytes` so any RPC path that buffers
-     * MORE than the W7 streaming guarantee shows up as supervisor heap
-     * pressure rather than disappearing into the bundle baseline.
-     *
-     * Streamed payloads (writeBatchStream over W7 frames) report -1
-     * up-front; we substitute 0 here because the bytes flow with
-     * backpressure and the supervisor-resident buffer is bounded by
-     * the W7 chunk size (a few KiB), not by the total payload.
-     */
-    inFlightRpcPayloadBytes: number;
-    /**
-     * Bytes reserved by prefetch-bundle builds currently in flight.
-     *
-     * `buildPrefetchBundle` accumulates raw VFS file contents into an in-heap
-     * bundle object, and used to do so with nothing observing it: the estimator
-     * read 9.4 MiB while those bytes were resetting the DO. Each build now takes
-     * an `acquireSupervisorAllocation` lease for the budget it may use and bumps
-     * this alongside it, so the reservation is ATTRIBUTED to the bundle path
-     * rather than landing in `unattributedReservationBytes`.
-     *
-     * Surfaced as `breakdown.prefetchBundleBytes`. Back to zero between builds.
-     */
-    prefetchBundleBytes: number;
-    /**
-     * Bytes retained by the FacetManager's prefetch-bundle LRU right now.
-     *
-     * Unlike the counter above these bytes persist ACROSS execs — each entry
-     * holds the raw bundle plus its serialized source, manifest and metadata.
-     * The LRU used to be bounded by entry count alone, which bounded nothing:
-     * 16 pi-sized entries exceed the supervisor ceiling several times over. It
-     * is now bounded by PREFETCH_CACHE_MAX_BYTES and reports its live total
-     * here, so the retained cost is a measurement rather than a cap.
-     *
-     * Surfaced as `breakdown.prefetchCacheBytes`. A gauge, not a delta.
-     */
-    prefetchCacheBytes: number;
-    /** Install-facet counters. Populated by npm-installer after a
-     *  successful batch-facet dispatch returns. Confirms the install ran
-     *  in the facet (tarballsCompleted > 0) and surfaces the
-     *  facet-internal byte count. */
-    installFacet: {
-        /** Number of tarballs the install-batch-facet successfully streamed. */
-        tarballsCompleted: number;
-        /** Cumulative tarball body bytes the facet decoded (gunzip input). */
-        cumulativeBytesDecoded: number;
-        /** Peak in-flight tarball pipelines inside the facet at any one moment. */
-        peakInFlight: number;
-    };
-    /** Pre-bundle facet counters. Tracks the fire-and-forget pre-bundle
-     *  phase. Aggregates across all dispatches in this DO's lifetime. */
-    preBundleFacet: {
-        /** Specifiers attempted (queue depth at start of phase). */
-        attempted: number;
-        /** Bundles that completed successfully (esmCode produced). */
-        bundlesCompleted: number;
-        /** Bundles that failed (errorText set on PrebundleResult). */
-        errors: number;
-        /** Bundles skipped before facet dispatch (e.g. slice cap exceeded). */
-        skipped: number;
-        /** First-call wasm-fetch payload size. 0 until first successful dispatch
-         *  records it; stays at first-seen value (RPC returns the same Module
-         *  every time, but the cumulativeBytes the FACET reports may grow on
-         *  retries). */
-        wasmBootBytes: number;
-        /** Per-module errors from the MOST RECENT pre-bundle batch, keyed by
-         *  specifier (e.g. "lucide-react", "framer-motion"). REPLACED on each
-         *  recordPreBundleSummary() call so the map is bounded by the batch
-         *  size (≤ pending.length, typically <20).
-         *
-         *  Example: { "lucide-react": "Worker exceeded memory limit." }
-         *
-         *  Empty when the most recent batch had zero errors. */
-        errorsByModule: Record<string, string>;
-    };
-    /** Pipelined R2 race outcomes. All counts are cumulative since
-     *  DO-isolate start. Per-tier cache statistics live in cache-stats. */
-    r2: {
-        /** Pipelined-RPC race wins for tarballs (R2 came back first; network
-         *  was cancelled). */
-        pipelinedTarballRaceWins: number;
-        /** Pipelined-RPC race losses for tarballs (R2 came back too slow or
-         *  empty; network response used). */
-        pipelinedTarballRaceLosses: number;
-        /** Pipelined-RPC race wins for packuments. */
-        pipelinedPackumentRaceWins: number;
-        /** Pipelined-RPC race losses for packuments. */
-        pipelinedPackumentRaceLosses: number;
-    };
-}
-/** Read a snapshot — caller-side mutations don't affect the singleton. */
-export declare function readDiagCounters(): DiagCounters;
-/** Set the install phase. */
-export declare function setInstallPhase(p: InstallPhase): void;
-/**
- * Track an in-flight supervisor RPC payload [Phase 2 A'.2].
- *
- * Call at RPC entry, BEFORE awaiting any work that depends on
- * `payload`. Pair with `rpcPayloadEnd(bytes)` in the matching `finally`
- * so the counter goes back to zero on both success and failure.
- *
- * `bytes` is the supervisor-resident byte cost of the RPC's argument
- * (or return value, whichever is bigger). For structured-clone RPCs
- * this is the size of the cloned payload in bytes.
- *
- * Streamed payloads (ReadableStream-over-RPC) flow with backpressure
- * and the supervisor-resident bound is the chunk size, not the total
- * payload. Pass the chunk-size estimate (typically ≤ 1 MiB) — never
- * the unknown total. -1 is silently coerced to 0 to keep the counter
- * non-negative; callers that don't know the size should call this
- * with 0 explicitly rather than relying on coercion.
- */
-export declare function rpcPayloadStart(bytes: number): void;
-/**
- * Release an in-flight supervisor RPC payload [Phase 2 A'.2].
- * Pass the same byte count given to the matching `rpcPayloadStart`.
- *
- * Floors at 0 to absorb arithmetic drift (e.g. if a payload-byte
- * counter rounding gave a slightly different number on entry vs.
- * exit). Drift in routine paths should be zero — a non-zero floor
- * hit is a bug worth investigating.
- */
-export declare function rpcPayloadEnd(bytes: number): void;
-/**
- * Track an in-flight prefetch-bundle build. Call with the byte reservation the
- * build took from the supervisor allocation budget, and pair with
- * `prefetchBundleEnd` in the matching `finally` so it returns to zero whether
- * the build succeeded or threw.
- */
-export declare function prefetchBundleStart(bytes: number): void;
-/** Release an in-flight prefetch-bundle reservation. Floors at 0. */
-export declare function prefetchBundleEnd(bytes: number): void;
-/**
- * Publish the prefetch-bundle LRU's live retained total. A gauge: the cache
- * owns the number and reports it whenever it admits or evicts an entry.
- */
-export declare function setPrefetchCacheBytes(bytes: number): void;
-/** Fold facet-returned counters into the supervisor's diag state.
- *  Called by npm-installer after the batch-facet returns; aggregates
- *  rather than replaces so multiple install runs in the same DO
- *  lifetime accumulate in cumulativeBytesDecoded. */
-export declare function recordInstallFacetCounters(c: {
-    tarballsCompleted: number;
-    cumulativeBytesDecoded: number;
-    peakInFlight: number;
-}): void;
-/** Record pre-bundle phase summary. Aggregates lifetime totals across
- *  all phases run in this DO's lifetime, but REPLACES the
- *  errorsByModule map every call so it reflects only the most recent
- *  batch. Losing prior-batch errors is fine — they're already aggregated
- *  into `errors` (count); the map is for "which modules failed this
- *  time." */
-export declare function recordPreBundleSummary(s: {
-    attempted: number;
-    bundlesCompleted: number;
-    errors: number;
-    skipped: number;
-    wasmBootBytes?: number;
-    errorsByModule?: Record<string, string>;
-}): void;
-/** Bump pipelined-RPC race outcome counters. The facet returns these
- *  in its result counters; the supervisor folds them in alongside the
- *  existing installFacet counters. */
-export declare function recordR2RaceCounters(c: {
-    pipelinedTarballRaceWins: number;
-    pipelinedTarballRaceLosses: number;
-    pipelinedPackumentRaceWins: number;
-    pipelinedPackumentRaceLosses: number;
-}): void;
-/**
- * cache-obs-2: fold facet-collected per-tier cache events into the
- * DO-side cache-stats singleton. Called from installer.ts after a
- * batch-facet / resolve-facet returns — mirrors recordR2RaceCounters
- * (the facet collects metrics in its result and the supervisor folds
- * them into the DO isolate).
- *
- * Each event has shape:
- *   { kind: 'hit', tier: 'L2'|'L3'|'L4', cacheKind: 'tarball'|'packument'|'asset', bytes: number }
- *   { kind: 'miss', tier: ..., cacheKind: ... }
- *
- * The recordHit/recordMiss surface is defined in
- * src/_shared/cache-stats.ts.
- */
-import { type CacheTier, type CacheKind } from '../_shared/cache-stats.js';
-export type CacheStatEvent = {
-    kind: 'hit';
-    tier: CacheTier;
-    cacheKind: CacheKind;
-    bytes: number;
-} | {
-    kind: 'miss';
-    tier: CacheTier;
-    cacheKind: CacheKind;
-};
-export declare function recordCacheStatEvents(events: readonly CacheStatEvent[] | undefined): void;
-//# sourceMappingURL=diag-counters.d.ts.map

package/dist/observability/diag-counters.d.ts.map

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