@nimbus-sh/worker 0.1.0

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 { SqliteVFS } 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: SqliteVFS, 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,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,uEAAuE;AACvE,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,SAAO,GAAG,MAAM,CAgBpF;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/barrel-synthesizer.d.ts

@@ -0,0 +1,181 @@
+/**
+ * barrel-synthesizer.ts — generate synthetic entry files for "barrel"
+ * packages so they tree-shake cleanly through esbuild.
+ *
+ * Why this exists
+ * ───────────────
+ * Some npm packages ship as a "barrel" — a single index file that
+ * re-exports hundreds or thousands of named exports, each living in
+ * its own source file. Examples observed in the wild:
+ *
+ *   lucide-react@0.460:        ~3940 files (~1500 icons × 2 entry forms)
+ *   @phosphor-icons/react:     thousands of icon components
+ *   react-icons:               thousands of icons across icon families
+ *   @mui/icons-material:       thousands of Material icons
+ *   @heroicons/react:          hundreds of icons (split by style)
+ *
+ * Bundling the whole barrel as if it were a normal browser module OOMs
+ * esbuild's WASM facet — the compiler tries to ingest the entire
+ * source tree into one ESM output. We previously fell back to
+ * `https://esm.sh/<pkg>?deps=react@<v>,react-dom@<v>` (commit fc17847)
+ * which violated the 100% edge contract: every preview load fetched
+ * tree-shaken bytes from a third-party CDN.
+ *
+ * The fix is structural. Instead of bundling `import * from 'pkg'`,
+ * we scan the user's source code for the SET of named imports the
+ * project actually uses
+ *
+ *   import { Home, FileText, Zap } from 'lucide-react'
+ *
+ * and synthesize a tiny entry module
+ *
+ *   export { Home, FileText, Zap } from 'lucide-react';
+ *
+ * which esbuild bundles in milliseconds because reachability prunes
+ * everything else. The output is small (5–20 KiB for typical icon
+ * sets) and ships from our edge.
+ *
+ * Generality
+ * ──────────
+ * This is NOT lucide-react-specific. Any barrel package whose author
+ * marked `sideEffects: false` (or whose individual icon files are
+ * side-effect-free) works automatically — esbuild's tree-shake takes
+ * care of selecting the actually-used exports. Packages without
+ * sideEffects: false may still tree-shake because esbuild's static
+ * analysis of `export { X } from './x.js'` is conservative-correct.
+ *
+ * Failure mode
+ * ────────────
+ * If the scanner can't enumerate the set (dynamic imports, computed
+ * member access like `Icons[name]`, etc.), the synthesizer returns
+ * null and the caller MUST hard-error. NO CDN fallback. The user
+ * sees a clear remediation: "add a static import for the
+ * dynamically-referenced icon."
+ */
+import type { SqliteVFS } from '../vfs/sqlite-vfs.js';
+import type { SliceEntry } from '../npm/pre-bundle-facet.js';
+/**
+ * Map of package name → set of named imports observed across the
+ * project's source files. Top-level package only — subpath imports
+ * (e.g. `lucide-react/icons/Home`) are skipped because the user is
+ * already opting into per-file resolution and esbuild handles them
+ * directly without barrel pressure.
+ */
+export type NamedImportMap = Map<string, Set<string>>;
+/**
+ * Static-import scanner. Walks the user's source tree under projDir
+ * and extracts named-import sets. Returns a map keyed by package name.
+ *
+ * Recognized syntax:
+ *   import { A } from 'pkg'
+ *   import { A, B } from 'pkg'
+ *   import { A as X, B as Y } from 'pkg'
+ *   import D, { A } from 'pkg'   // only A is captured (D is default)
+ *
+ * NOT recognized (intentional — these can't be statically tree-shaken):
+ *   import * as M from 'pkg'             — caller must bundle whole pkg
+ *   import('pkg')                         — dynamic; runtime resolution
+ *   const { A } = require('pkg')          — CJS at runtime
+ *
+ * The scanner is intentionally conservative-text-based. We do NOT
+ * parse a full AST — that would require shipping acorn or esbuild's
+ * parser at runtime in the supervisor. The regex covers the >99% case
+ * for browser source code in TS/JS/JSX/TSX.
+ *
+ * Costs: O(files × content_length). For Mossaic (199 source files,
+ * ~150 KiB total source) this is single-digit ms.
+ */
+export declare function scanNamedImports(vfs: SqliteVFS, projDir: string): NamedImportMap;
+/**
+ * Synthesize a tiny ESM entry that re-exports the given names from
+ * the package. We do NOT emit `export { X } from 'pkg'` — that resolves
+ * to the package's barrel-index file, which typically pulls in EVERY
+ * export via `import * as ns from '../index.js'` and breaks
+ * esbuild's tree-shake (the namespace expansion balloons the
+ * reachability graph and OOMs the WASM facet on icon-libraries
+ * that ship 1500+ exports).
+ *
+ * Instead we PARSE the barrel-index file, build a map of
+ * `<exportedName> → <relative path inside the package>`, and emit
+ * direct file imports:
+ *
+ *   export { default as Home } from 'lucide-react/dist/esm/icons/house.js';
+ *   export { default as FileText } from 'lucide-react/dist/esm/icons/file-text.js';
+ *
+ * esbuild's bundler now ingests only the per-icon files we directly
+ * reference (plus their transitive dependencies). The unused 1499
+ * icons never enter the build graph at all.
+ *
+ * Supported re-export forms in the barrel index:
+ *   export { default as Name } from './icons/x.js';
+ *   export { default as Name1, default as Name2 } from './icons/x.js';
+ *   export { Name } from './icons/x.js';
+ *   export { Name as Alias } from './icons/x.js';
+ *
+ * NOT supported (rare in barrels — caller falls back if encountered):
+ *   export * from './foo.js';
+ *   export * as ns from './foo.js';
+ *   import { X } from './foo.js'; export { X };  (split form)
+ *
+ * Returns null if:
+ *   - input set empty, OR
+ *   - the barrel index file isn't found, OR
+ *   - none of the user's requested names appear in the parsed map.
+ *     (Caller should then hard-error, NOT fall back to a CDN.)
+ *
+ * `vfs` + `nmDir` (project's node_modules path) are required so we
+ * can read the barrel index. `pkgName` is the top-level package; the
+ * synthesizer resolves the package's main ESM entry by reading
+ * `package.json`.
+ */
+/**
+ * Result of a synthetic-entry build. `code` is the ESM source ready
+ * for esbuild. `referencedFiles` is the set of absolute VFS paths
+ * (no leading slash, like the rest of our VFS surface) the entry
+ * imports — useful for callers building a SCOPED slice that contains
+ * only those files instead of the whole package directory (which can
+ * exceed the 28 MiB slice cap for icon-libraries with thousands of
+ * files).
+ */
+export interface SyntheticEntryResult {
+    code: string;
+    referencedFiles: string[];
+}
+export declare function buildSyntheticEntry(vfs: SqliteVFS, nmDir: string, pkgName: string, names: ReadonlySet<string>): SyntheticEntryResult | null;
+/**
+ * Build a SCOPED slice for a synthetic-entry bundle: include only
+ * the files the synthetic entry directly references (+ their
+ * transitive imports walked via static analysis), plus the package
+ * root's `package.json` (esbuild's resolver reads it for exports/main
+ * fields). This bypasses the standard `walkDir` over the whole
+ * package, which for icon-libraries with thousands of files can
+ * exceed the 28 MiB slice cap.
+ *
+ * Caller still appends the synthetic entry file itself to the slice
+ * (we don't include it here because it lives in a synthetic
+ * directory the caller already manages).
+ *
+ * Returns the list of `SliceEntry`-shaped objects to push into the
+ * existing slice, plus the total bytes added (for cap-tracking).
+ *
+ * `transitiveCap`: how many files we'll walk in total. Bounded so a
+ * pathological barrel-of-barrels can't blow the cap. Default 800,
+ * which empirically covers icon-libraries with up to ~400 imported
+ * icons (each pulling 1-2 transitive shared utility files).
+ */
+export declare function buildScopedSliceForSynthetic(vfs: SqliteVFS, nmDir: string, pkgName: string, referencedFiles: string[], transitiveCap?: number): {
+    entries: SliceEntry[];
+    totalBytes: number;
+};
+/**
+ * VFS path where synthetic entries are written. Lives under the
+ * project's node_modules in a Nimbus-private namespace so package
+ * managers don't collide with real package directories.
+ *
+ * Format: <projDir>/node_modules/.nimbus-synthetic/<safeName>.entry.js
+ *
+ * Safe name = pkgName with '@' and '/' replaced by '__' so scoped
+ * packages produce a valid filesystem path.
+ */
+export declare function syntheticEntryPath(projDir: string, pkgName: string): string;
+//# sourceMappingURL=barrel-synthesizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"barrel-synthesizer.d.ts","sourceRoot":"","sources":["../../src/runtime/barrel-synthesizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAG7D;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,SAAS,EACd,OAAO,EAAE,MAAM,GACd,cAAc,CAgFhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,SAAS,EACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GACzB,oBAAoB,GAAG,IAAI,CAmL7B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,SAAS,EACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,MAAM,EAAE,EACzB,aAAa,SAAM,GAClB;IAAE,OAAO,EAAE,UAAU,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAiE/C;AA0DD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAG3E"}