@nimbus-sh/core 0.1.0

package/dist/observability/oom-discriminator.js

@@ -0,0 +1,272 @@
+/**
+ * oom-discriminator.ts — singleton ring buffer for OOM / failure
+ * forensics + last-known-RPC-frame + last-known-facet-id +
+ * session-recovery-event ring, plus snapshot/rehydrate hooks for DO
+ * storage persistence.
+ *
+ * W5 (Lever 5 / J.1.1) — original module. Pairs with oom-classify.ts.
+ * C'.2 — added the recovery_event ring.
+ *
+ * Why singleton-per-isolate
+ * ─────────────────────────
+ * Same pattern as src/observability/diag-counters.ts. The supervisor bundle
+ * is the consumer; all writers (sqlite-vfs, facet-pool, facet-manager,
+ * supervisor-rpc, npm-installer, nimbus-session) live in the same
+ * isolate. Module scope provides one process-local diagnostic without
+ * threading a handle through each writer.
+ *
+ * Two distinct rings
+ * ──────────────────
+ * - failures: things that failed (the original W5 ring).
+ * - recoveryEvents: lifecycle transitions of the session. Cold isolate
+ *   boot → 'cold' → 'hydrated' → 'active' → 'drained'.
+ *
+ * Bounded-size guarantees
+ * ───────────────────────
+ *   - failures ring: 50 entries (RING_SIZE).
+ *   - recoveryEvents ring: 50 entries (RECOVERY_RING_SIZE).
+ *   - per-message cap: 200 chars (truncated at insert).
+ *   - per-RPC-frame: single slot, one object.
+ *   - per-facet-id: single slot, one object.
+ *
+ * Snapshot size stays bounded even with both rings full.
+ */
+import { isOomCause } from './oom-classify.js';
+const RING_SIZE = 50;
+const RECOVERY_RING_SIZE = 50;
+const MESSAGE_CAP = 200;
+const state = {
+    failures: [],
+    recoveryEvents: [],
+    lastRpcFrame: null,
+    lastFacetId: null,
+};
+function getState() {
+    return state;
+}
+/** Append a failure to the ring. Newest first. Capped at RING_SIZE. */
+export function recordFailure(f) {
+    const s = getState();
+    // Defensive copy + message cap.
+    const entry = {
+        at: Number(f.at) || Date.now(),
+        phase: String(f.phase ?? 'unknown'),
+        cause: f.cause,
+        rssEstimateBytes: Number(f.rssEstimateBytes) || 0,
+        heapUsedBytes: Number(f.heapUsedBytes) || 0,
+        lruBytes: Number(f.lruBytes) || 0,
+        inFlightBytes: Number(f.inFlightBytes) || 0,
+        lastRpcFrame: f.lastRpcFrame ?? s.lastRpcFrame,
+        lastFacetId: f.lastFacetId ?? s.lastFacetId,
+    };
+    if (typeof f.exitCode === 'number')
+        entry.exitCode = f.exitCode;
+    if (typeof f.pid === 'number')
+        entry.pid = f.pid;
+    if (f.message) {
+        const m = String(f.message);
+        entry.message = m.length > MESSAGE_CAP ? m.slice(0, MESSAGE_CAP) : m;
+    }
+    s.failures.unshift(entry);
+    if (s.failures.length > RING_SIZE)
+        s.failures.length = RING_SIZE;
+}
+/** Read a snapshot of the ring. Newest first. Caller-side mutations
+ *  do not affect the singleton. */
+export function getFailures() {
+    return getState().failures.slice(0);
+}
+/** Record the current RPC frame (called at every RPC entry). Bounded
+ *  to a single slot — the LATEST frame wins. */
+export function setLastRpcFrame(method, payloadBytes) {
+    const s = getState();
+    s.lastRpcFrame = {
+        method: String(method),
+        payloadBytes: Number(payloadBytes) || 0,
+        atMs: Date.now(),
+    };
+}
+export function getLastRpcFrame() {
+    return getState().lastRpcFrame;
+}
+/** Record the most recent facet dispatch. */
+export function setLastFacetId(codeId, slotIndex) {
+    const s = getState();
+    s.lastFacetId = {
+        codeId: String(codeId),
+        slotIndex: Number(slotIndex) || 0,
+        atMs: Date.now(),
+    };
+}
+export function getLastFacetId() {
+    return getState().lastFacetId;
+}
+// ── C'.2 recovery_event ring ────────────────────────────────────────────
+//
+// The ring is bounded at RECOVERY_RING_SIZE; the diag endpoint reads via
+// getRecoveryEvents() (newest first).
+/** Append a recovery event to the ring. Newest first. Capped at
+ *  RECOVERY_RING_SIZE. */
+export function recordRecoveryEvent(e) {
+    const s = getState();
+    // Defensive copy + notes cap. We intentionally do NOT validate the
+    // state-machine direction here (e.g. that 'drained' only follows
+    // 'active') — the state machine lives elsewhere; this ring is a
+    // recorder, not an enforcer. If a probe sees an impossible
+    // transition, that's a real bug in the state machine and the
+    // probe must fail.
+    const entry = {
+        at: Number(e.at) || Date.now(),
+        fromState: e.fromState,
+        toState: e.toState,
+        trigger: String(e.trigger ?? 'unknown'),
+        isolateGen: Number(e.isolateGen) || 0,
+        dataLoss: !!e.dataLoss,
+        snapshotKeysRehydrated: Number(e.snapshotKeysRehydrated) || 0,
+    };
+    if (e.notes) {
+        const n = String(e.notes);
+        entry.notes = n.length > MESSAGE_CAP ? n.slice(0, MESSAGE_CAP) : n;
+    }
+    s.recoveryEvents.unshift(entry);
+    if (s.recoveryEvents.length > RECOVERY_RING_SIZE) {
+        s.recoveryEvents.length = RECOVERY_RING_SIZE;
+    }
+}
+/** Read a snapshot of the recovery ring. Newest first. */
+export function getRecoveryEvents() {
+    return getState().recoveryEvents.slice(0);
+}
+/** Reset the recovery ring. Tests + manual operator use only. */
+export function resetRecoveryEvents() {
+    getState().recoveryEvents.length = 0;
+}
+export function snapshotForStorage() {
+    const s = getState();
+    return {
+        v: 2,
+        failures: s.failures.slice(0),
+        recoveryEvents: s.recoveryEvents.slice(0),
+        lastRpcFrame: s.lastRpcFrame,
+        lastFacetId: s.lastFacetId,
+    };
+}
+/**
+ * Restore from a snapshot. Garbage / null / wrong-shape input is
+ * silently ignored. Does NOT throw — constructor-time rehydration must
+ * never block DO startup.
+ *
+ * Only the current v2 schema is accepted.
+ */
+export function rehydrateFromStorage(blob) {
+    if (!isRecord(blob) || blob.v !== 2)
+        return;
+    const b = blob;
+    if (!Array.isArray(b.failures))
+        return;
+    const s = getState();
+    s.failures.length = 0;
+    for (const f of b.failures) {
+        const entry = parseFailure(f);
+        if (!entry)
+            continue;
+        s.failures.push(entry);
+        if (s.failures.length >= RING_SIZE)
+            break;
+    }
+    s.recoveryEvents.length = 0;
+    if (Array.isArray(b.recoveryEvents)) {
+        for (const e of b.recoveryEvents) {
+            const entry = parseRecoveryEvent(e);
+            if (!entry)
+                continue;
+            s.recoveryEvents.push(entry);
+            if (s.recoveryEvents.length >= RECOVERY_RING_SIZE)
+                break;
+        }
+    }
+    const lastRpcFrame = parseRpcFrame(b.lastRpcFrame);
+    if (lastRpcFrame)
+        s.lastRpcFrame = lastRpcFrame;
+    const lastFacetId = parseFacetId(b.lastFacetId);
+    if (lastFacetId)
+        s.lastFacetId = lastFacetId;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function parseRpcFrame(value) {
+    if (!isRecord(value)
+        || typeof value.method !== 'string'
+        || typeof value.payloadBytes !== 'number'
+        || typeof value.atMs !== 'number')
+        return null;
+    return { method: value.method, payloadBytes: value.payloadBytes, atMs: value.atMs };
+}
+function parseFacetId(value) {
+    if (!isRecord(value)
+        || typeof value.codeId !== 'string'
+        || typeof value.slotIndex !== 'number'
+        || typeof value.atMs !== 'number')
+        return null;
+    return { codeId: value.codeId, slotIndex: value.slotIndex, atMs: value.atMs };
+}
+function parseFailure(value) {
+    if (!isRecord(value)
+        || typeof value.at !== 'number'
+        || typeof value.phase !== 'string'
+        || !isOomCause(value.cause)
+        || typeof value.rssEstimateBytes !== 'number'
+        || typeof value.heapUsedBytes !== 'number'
+        || typeof value.lruBytes !== 'number'
+        || typeof value.inFlightBytes !== 'number')
+        return null;
+    const entry = {
+        at: value.at,
+        phase: value.phase,
+        cause: value.cause,
+        rssEstimateBytes: value.rssEstimateBytes,
+        heapUsedBytes: value.heapUsedBytes,
+        lruBytes: value.lruBytes,
+        inFlightBytes: value.inFlightBytes,
+        lastRpcFrame: parseRpcFrame(value.lastRpcFrame),
+        lastFacetId: parseFacetId(value.lastFacetId),
+    };
+    if (typeof value.exitCode === 'number')
+        entry.exitCode = value.exitCode;
+    if (typeof value.pid === 'number')
+        entry.pid = value.pid;
+    if (typeof value.message === 'string')
+        entry.message = value.message.slice(0, MESSAGE_CAP);
+    return entry;
+}
+const SESSION_STATES = [
+    'cold', 'hydrated', 'active', 'drained',
+    'rehydrate', 'build', 'wire', 'online',
+];
+function isSessionState(value) {
+    return SESSION_STATES.some((state) => state === value);
+}
+function parseRecoveryEvent(value) {
+    if (!isRecord(value)
+        || typeof value.at !== 'number'
+        || !isSessionState(value.fromState)
+        || !isSessionState(value.toState)
+        || typeof value.trigger !== 'string'
+        || typeof value.isolateGen !== 'number'
+        || typeof value.dataLoss !== 'boolean'
+        || typeof value.snapshotKeysRehydrated !== 'number')
+        return null;
+    const entry = {
+        at: value.at,
+        fromState: value.fromState,
+        toState: value.toState,
+        trigger: value.trigger,
+        isolateGen: value.isolateGen,
+        dataLoss: value.dataLoss,
+        snapshotKeysRehydrated: value.snapshotKeysRehydrated,
+    };
+    if (typeof value.notes === 'string')
+        entry.notes = value.notes.slice(0, MESSAGE_CAP);
+    return entry;
+}

package/dist/runtime/assets-loader.d.ts

@@ -0,0 +1,71 @@
+/**
+ * runtime/assets-loader.ts — Lazy fetch of large static blobs from the
+ * ASSETS binding.
+ *
+ * Background: the Worker bundle ships ~9.8 MB of generated TypeScript
+ * blobs (cirrus-npm-cjs, cirrus-plugin-react, real-vite-bundle, ...).
+ * Inlining them at module-load doubles cold-start parse time and
+ * inflates deploy uploads. The ASSETS binding lets us serve them as
+ * static files (cached at the edge), fetched on first use, kept in a
+ * per-isolate cache for subsequent calls.
+ *
+ * Same pattern as `esbuild-wasm-bytes.ts` (proven in production —
+ * see esbuild-wasm-bundle.generated.ts header for history). We
+ * generalize it here so future asset promotions are one-line.
+ *
+ * @example a bundle script writes the big string to
+ * `public/_assets/cirrus-plugin-react.bundle.js` and emits a thin
+ * `.generated.ts` that re-exports {@link loadAssetText} bound to that
+ * path:
+ *
+ * ```ts
+ * // src/cirrus-plugin-react.generated.ts (post-promotion)
+ * import { loadAssetText } from './runtime/assets-loader.js';
+ * export const CIRRUS_PLUGIN_REACT_VERSION = "4.3.4";
+ * export const CIRRUS_PLUGIN_REACT_BUNDLE_PATH = '/_assets/cirrus-plugin-react.bundle.js';
+ * export async function getCirrusPluginReactBundle(env: { ASSETS: Fetcher }): Promise<string> {
+ *   return loadAssetText(env.ASSETS, CIRRUS_PLUGIN_REACT_BUNDLE_PATH);
+ * }
+ * ```
+ *
+ * Cache discipline: keyed by `${path}` (no env or origin in the key)
+ * because ASSETS is content-addressed at the deploy level — a redeploy
+ * generates new asset bundles and the new isolate sees no stale cache.
+ * Within a single isolate's lifetime, the same path always returns the
+ * same content.
+ */
+/**
+ * Asset fetch error. Thrown when ASSETS binding is missing or returns
+ * a non-200.
+ */
+export declare class NimbusAssetLoadError extends Error {
+    readonly code: 'E_ASSETS_BINDING_MISSING' | 'E_ASSET_NOT_FOUND' | 'E_ASSET_FETCH_FAILED';
+    readonly status?: number;
+    readonly path: string;
+    constructor(message: string, code: NimbusAssetLoadError['code'], path: string, status?: number);
+}
+/** Minimal fetcher shape so callers don't need to import a Cloudflare type. */
+export interface AssetsFetcher {
+    fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+}
+/**
+ * Load an asset's bytes by path. Subsequent calls in the same isolate
+ * return from cache.
+ *
+ * @param assets `env.ASSETS` binding.
+ * @param path Asset path (e.g. `/_assets/foo.bin`). Leading `/`
+ *             required.
+ * @throws {NimbusAssetLoadError} on binding missing or non-2xx.
+ */
+export declare function loadAssetBytes(assets: AssetsFetcher | undefined, path: string): Promise<Uint8Array>;
+/**
+ * Load an asset as a UTF-8 string. Same caching discipline as
+ * {@link loadAssetBytes}.
+ */
+export declare function loadAssetText(assets: AssetsFetcher | undefined, path: string): Promise<string>;
+/**
+ * Test-only: drop the per-isolate cache. Real isolates never call this;
+ * the cache exists for the isolate's lifetime.
+ */
+export declare function _resetAssetsCacheForTests(): void;
+//# sourceMappingURL=assets-loader.d.ts.map

package/dist/runtime/assets-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets-loader.d.ts","sourceRoot":"","sources":["../../src/runtime/assets-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAYH;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,EAAE,0BAA0B,GAAG,mBAAmB,GAAG,sBAAsB,CAAC;IACzF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEpB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAC,EAClC,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM;CAQlB;AAED,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CAClE;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,aAAa,GAAG,SAAS,EACjC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,UAAU,CAAC,CA4CrB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,aAAa,GAAG,SAAS,EACjC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,CAAC,CAwCjB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAGhD"}

package/dist/runtime/assets-loader.js

@@ -0,0 +1,139 @@
+/**
+ * runtime/assets-loader.ts — Lazy fetch of large static blobs from the
+ * ASSETS binding.
+ *
+ * Background: the Worker bundle ships ~9.8 MB of generated TypeScript
+ * blobs (cirrus-npm-cjs, cirrus-plugin-react, real-vite-bundle, ...).
+ * Inlining them at module-load doubles cold-start parse time and
+ * inflates deploy uploads. The ASSETS binding lets us serve them as
+ * static files (cached at the edge), fetched on first use, kept in a
+ * per-isolate cache for subsequent calls.
+ *
+ * Same pattern as `esbuild-wasm-bytes.ts` (proven in production —
+ * see esbuild-wasm-bundle.generated.ts header for history). We
+ * generalize it here so future asset promotions are one-line.
+ *
+ * @example a bundle script writes the big string to
+ * `public/_assets/cirrus-plugin-react.bundle.js` and emits a thin
+ * `.generated.ts` that re-exports {@link loadAssetText} bound to that
+ * path:
+ *
+ * ```ts
+ * // src/cirrus-plugin-react.generated.ts (post-promotion)
+ * import { loadAssetText } from './runtime/assets-loader.js';
+ * export const CIRRUS_PLUGIN_REACT_VERSION = "4.3.4";
+ * export const CIRRUS_PLUGIN_REACT_BUNDLE_PATH = '/_assets/cirrus-plugin-react.bundle.js';
+ * export async function getCirrusPluginReactBundle(env: { ASSETS: Fetcher }): Promise<string> {
+ *   return loadAssetText(env.ASSETS, CIRRUS_PLUGIN_REACT_BUNDLE_PATH);
+ * }
+ * ```
+ *
+ * Cache discipline: keyed by `${path}` (no env or origin in the key)
+ * because ASSETS is content-addressed at the deploy level — a redeploy
+ * generates new asset bundles and the new isolate sees no stale cache.
+ * Within a single isolate's lifetime, the same path always returns the
+ * same content.
+ */
+import { disposeRpcResource } from '../_shared/rpc-dispose.js';
+/**
+ * Per-isolate cache. Keys are asset paths (e.g. `/_assets/foo.js`).
+ * Values are settled promises so concurrent callers share the same
+ * fetch.
+ */
+const __assetTextCache = new Map();
+const __assetBytesCache = new Map();
+/**
+ * Asset fetch error. Thrown when ASSETS binding is missing or returns
+ * a non-200.
+ */
+export class NimbusAssetLoadError extends Error {
+    code;
+    status;
+    path;
+    constructor(message, code, path, status) {
+        super(message);
+        this.name = 'NimbusAssetLoadError';
+        this.code = code;
+        this.path = path;
+        this.status = status;
+    }
+}
+/**
+ * Load an asset's bytes by path. Subsequent calls in the same isolate
+ * return from cache.
+ *
+ * @param assets `env.ASSETS` binding.
+ * @param path Asset path (e.g. `/_assets/foo.bin`). Leading `/`
+ *             required.
+ * @throws {NimbusAssetLoadError} on binding missing or non-2xx.
+ */
+export function loadAssetBytes(assets, path) {
+    if (!assets || typeof assets.fetch !== 'function') {
+        return Promise.reject(new NimbusAssetLoadError(`ASSETS binding missing — cannot load ${path}. Did you forget the assets.binding=ASSETS in wrangler.jsonc?`, 'E_ASSETS_BINDING_MISSING', path));
+    }
+    const cached = __assetBytesCache.get(path);
+    if (cached)
+        return cached;
+    const promise = (async () => {
+        // ASSETS.fetch requires an absolute URL, but the origin is ignored
+        // — it just routes by pathname. Use a stable sentinel origin.
+        const url = `https://assets.invalid${path}`;
+        const r = await assets.fetch(url);
+        try {
+            if (r.status === 404) {
+                throw new NimbusAssetLoadError(`Asset not found: ${path}`, 'E_ASSET_NOT_FOUND', path, 404);
+            }
+            if (!r.ok) {
+                throw new NimbusAssetLoadError(`Asset fetch failed: ${path} → ${r.status}`, 'E_ASSET_FETCH_FAILED', path, r.status);
+            }
+            const buf = await r.arrayBuffer();
+            return new Uint8Array(buf);
+        }
+        finally {
+            disposeRpcResource(r);
+        }
+    })();
+    __assetBytesCache.set(path, promise);
+    // Evict on failure so subsequent calls retry.
+    promise.catch(() => __assetBytesCache.delete(path));
+    return promise;
+}
+/**
+ * Load an asset as a UTF-8 string. Same caching discipline as
+ * {@link loadAssetBytes}.
+ */
+export function loadAssetText(assets, path) {
+    if (!assets || typeof assets.fetch !== 'function') {
+        return Promise.reject(new NimbusAssetLoadError(`ASSETS binding missing — cannot load ${path}. Did you forget the assets.binding=ASSETS in wrangler.jsonc?`, 'E_ASSETS_BINDING_MISSING', path));
+    }
+    const cached = __assetTextCache.get(path);
+    if (cached)
+        return cached;
+    const promise = (async () => {
+        const url = `https://assets.invalid${path}`;
+        const r = await assets.fetch(url);
+        try {
+            if (r.status === 404) {
+                throw new NimbusAssetLoadError(`Asset not found: ${path}`, 'E_ASSET_NOT_FOUND', path, 404);
+            }
+            if (!r.ok) {
+                throw new NimbusAssetLoadError(`Asset fetch failed: ${path} → ${r.status}`, 'E_ASSET_FETCH_FAILED', path, r.status);
+            }
+            return await r.text();
+        }
+        finally {
+            disposeRpcResource(r);
+        }
+    })();
+    __assetTextCache.set(path, promise);
+    promise.catch(() => __assetTextCache.delete(path));
+    return promise;
+}
+/**
+ * Test-only: drop the per-isolate cache. Real isolates never call this;
+ * the cache exists for the isolate's lifetime.
+ */
+export function _resetAssetsCacheForTests() {
+    __assetTextCache.clear();
+    __assetBytesCache.clear();
+}

package/dist/runtime/barrel-detect.d.ts

@@ -0,0 +1,46 @@
+/**
+ * barrel-detect.ts — heuristic for "barrel" packages whose source tree
+ * is too large for esbuild's facet to bundle without OOM.
+ *
+ * Barrel packages ship one .js per icon/component (e.g. lucide-react
+ * with 1500 icons → 4000+ files). esbuild's bundler ingests the whole
+ * tree into a single ESM module, which routinely OOMs the 128 MiB
+ * facet isolate during JS heap allocation.
+ *
+ * Both the install-time pre-bundle path (npm-installer.prebundleUsedModules)
+ * and the on-demand path (vite-dev-server.serveModule) use this to
+ * route the package through `barrel-synthesizer.ts`: scan the user's
+ * source for static named imports, generate a tiny synthetic entry
+ * (`export { Home, FileText } from 'pkg'`), and bundle THAT through
+ * the standard facet path. esbuild's tree-shaking + the package's
+ * sideEffects:false produces a small per-app bundle without ever
+ * reaching for a third-party CDN (100% edge contract).
+ *
+ * Threshold rationale (1500 files):
+ *   lucide-react@0.460:    4069 files (synthesizes)
+ *   framer-motion@11.11:    ~250 files (bundles whole)
+ *   react-router-dom@6.26:  ~80  files (bundles whole)
+ *   react-dom@18.3:         ~150 files (bundles whole)
+ *
+ * The cap (5000) prevents pathological deep walks; we only need to
+ * know "clearly a barrel" vs. not.
+ */
+import type { CredentialedVfs } from '../vfs/sqlite-vfs.js';
+/** A package with more than this many files is treated as a barrel. */
+export declare const BARREL_PKG_FILE_THRESHOLD = 1500;
+/**
+ * Recursively count files under `pkgDir`, excluding nested node_modules
+ * (those are walked separately by the slice walker as transitive deps).
+ *
+ * Stops counting once we exceed `cap` to avoid pathological walks. Cost:
+ * VFS readdir is sync + in-memory inode lookup. For lucide-react
+ * (4069 files), measured at <2 ms in dev.
+ */
+export declare function countPackageFiles(vfs: CredentialedVfs, pkgDir: string, cap?: number): number;
+/**
+ * Convenience: derive top-level package name from a bare specifier
+ * (e.g. "lucide-react/icons/Cloud" → "lucide-react", "@radix-ui/react"
+ * → "@radix-ui/react"). Used by callers building the pkgDir path.
+ */
+export declare function packageNameFromSpecifier(specifier: string): string;
+//# sourceMappingURL=barrel-detect.d.ts.map

package/dist/runtime/barrel-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"barrel-detect.d.ts","sourceRoot":"","sources":["../../src/runtime/barrel-detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,uEAAuE;AACvE,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,SAAO,GAAG,MAAM,CAgB1F;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAIlE"}

package/dist/runtime/barrel-detect.js

@@ -0,0 +1,73 @@
+/**
+ * barrel-detect.ts — heuristic for "barrel" packages whose source tree
+ * is too large for esbuild's facet to bundle without OOM.
+ *
+ * Barrel packages ship one .js per icon/component (e.g. lucide-react
+ * with 1500 icons → 4000+ files). esbuild's bundler ingests the whole
+ * tree into a single ESM module, which routinely OOMs the 128 MiB
+ * facet isolate during JS heap allocation.
+ *
+ * Both the install-time pre-bundle path (npm-installer.prebundleUsedModules)
+ * and the on-demand path (vite-dev-server.serveModule) use this to
+ * route the package through `barrel-synthesizer.ts`: scan the user's
+ * source for static named imports, generate a tiny synthetic entry
+ * (`export { Home, FileText } from 'pkg'`), and bundle THAT through
+ * the standard facet path. esbuild's tree-shaking + the package's
+ * sideEffects:false produces a small per-app bundle without ever
+ * reaching for a third-party CDN (100% edge contract).
+ *
+ * Threshold rationale (1500 files):
+ *   lucide-react@0.460:    4069 files (synthesizes)
+ *   framer-motion@11.11:    ~250 files (bundles whole)
+ *   react-router-dom@6.26:  ~80  files (bundles whole)
+ *   react-dom@18.3:         ~150 files (bundles whole)
+ *
+ * The cap (5000) prevents pathological deep walks; we only need to
+ * know "clearly a barrel" vs. not.
+ */
+/** A package with more than this many files is treated as a barrel. */
+export const BARREL_PKG_FILE_THRESHOLD = 1500;
+/**
+ * Recursively count files under `pkgDir`, excluding nested node_modules
+ * (those are walked separately by the slice walker as transitive deps).
+ *
+ * Stops counting once we exceed `cap` to avoid pathological walks. Cost:
+ * VFS readdir is sync + in-memory inode lookup. For lucide-react
+ * (4069 files), measured at <2 ms in dev.
+ */
+export function countPackageFiles(vfs, pkgDir, cap = 5000) {
+    if (!vfs.exists(pkgDir) || !vfs.isDirectory(pkgDir))
+        return 0;
+    let count = 0;
+    const stack = [pkgDir];
+    while (stack.length > 0 && count <= cap) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = vfs.readdir(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (e.name === 'node_modules')
+                continue;
+            const child = dir + '/' + e.name;
+            if (e.type === 'directory')
+                stack.push(child);
+            else
+                count++;
+        }
+    }
+    return count;
+}
+/**
+ * Convenience: derive top-level package name from a bare specifier
+ * (e.g. "lucide-react/icons/Cloud" → "lucide-react", "@radix-ui/react"
+ * → "@radix-ui/react"). Used by callers building the pkgDir path.
+ */
+export function packageNameFromSpecifier(specifier) {
+    return specifier.startsWith('@')
+        ? specifier.split('/').slice(0, 2).join('/')
+        : specifier.split('/')[0];
+}

package/dist/runtime/bash/preamble.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=preamble.d.ts.map

package/dist/runtime/bash/preamble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preamble.d.ts","sourceRoot":"","sources":["../../../src/runtime/bash/preamble.ts"],"names":[],"mappings":""}