@nimbus-sh/worker 0.10.0 → 0.11.0

package/dist/facets/data-plan.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Which file contents a resident node process holds from its first
+ * instruction, besides its module map.
+ *
+ * A synchronous read cannot wait for bytes, so whatever a process reads
+ * synchronously has to be in its facet before it runs; the namespace (every
+ * name and stat) is always there, content is not. This decides content by
+ * rule, from the namespace and the module closure, without reading file
+ * contents except a few package.json files:
+ *
+ *   package-json   every package.json
+ *   project        the working tree, minus dependency, VCS and build-cache dirs
+ *   convention     config and lockfile names in the working dir and above it
+ *   package-data   non-code files under 256 KiB in every package the closure uses
+ *   home           $HOME's dot entries (tool config, skills), minus caches
+ *   typescript     when the closure has typescript: its lib .d.ts, @types/**,
+ *                  and the declaration files of the packages @types depends on
+ *   static         what the closure's own code names by a foldable path
+ *                  (static-fs-refs.ts), resolved against the namespace:
+ *                  under 256 KiB, or any size when the code reads it with
+ *                  readFileSync (or a read-only openSync) by that path,
+ *                  through any symlinks on it
+ *   learned        paths earlier launches of the same package versions missed
+ *
+ * Code the closure loads is in the module map already; the store adopts it,
+ * so it is readable as data too.
+ */
+import type { StaticFsRefs } from '@nimbus-sh/core/runtime/static-fs-refs.js';
+export interface DataPlanEntry {
+    path: string;
+    kind: string;
+    size: number;
+    linkTarget?: string;
+}
+export interface DataPlanSource {
+    /** One page of the namespace in path order; `next === null` ends it. */
+    list(after: string | null): Promise<{
+        entries: DataPlanEntry[];
+        next: string | null;
+    }>;
+    /** A file's text, or null when it cannot be read. */
+    readText(path: string): Promise<string | null>;
+    /** A symlink's target as stored, or null when the path is not a symlink. */
+    readlink(path: string): Promise<string | null>;
+    /** What is at a path, following symlinks, or null. */
+    stat(path: string): Promise<{
+        kind: string;
+        size: number;
+    } | null>;
+}
+export interface DataPlanInput {
+    cwd: string;
+    home: string;
+    /** Module map paths. */
+    closure: Iterable<string>;
+    refs: readonly StaticFsRefs[];
+    /** Paths learned from earlier misses (absolute or keys). */
+    learned?: Iterable<string>;
+    /** Called with the bytes of each listed page, to pace a long walk. */
+    spend?: (units: number) => Promise<void>;
+}
+export type DataPlanRule = 'package-json' | 'project' | 'convention' | 'package-data' | 'home' | 'typescript' | 'static' | 'learned';
+export interface DataPlan {
+    paths: string[];
+    bytes: number;
+    rules: Record<DataPlanRule, {
+        files: number;
+        bytes: number;
+    }>;
+}
+/** Package data this size or larger is a bundle or a binary, not configuration. */
+export declare const PACKAGE_DATA_MAX_BYTES: number;
+/** The package directory a path sits in: up to the name after its last node_modules. */
+export declare function packageRootOf(k: string): string | null;
+/**
+ * The plan for one launch. Walks the namespace once, in pages.
+ */
+export declare function planFacetData(source: DataPlanSource, input: DataPlanInput): Promise<DataPlan>;
+//# sourceMappingURL=data-plan.d.ts.map

package/dist/facets/data-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-plan.d.ts","sourceRoot":"","sources":["../../src/facets/data-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC;AAE9E,MAAM,WAAW,aAAa;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE;AAEhG,MAAM,WAAW,cAAc;IAC7B,wEAAwE;IACxE,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,aAAa,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;IACvF,qDAAqD;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC/C,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC/C,sDAAsD;IACtD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;CACpE;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC1B,IAAI,EAAE,SAAS,YAAY,EAAE,CAAC;IAC9B,4DAA4D;IAC5D,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC3B,sEAAsE;IACtE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED,MAAM,MAAM,YAAY,GACpB,cAAc,GAAG,SAAS,GAAG,YAAY,GAAG,cAAc,GAAG,MAAM,GAAG,YAAY,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE9G,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC,YAAY,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC/D;AAED,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,QAAa,CAAC;AAkCjD,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOtD;AA0GD;;GAEG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CAiQnG"}

package/dist/facets/data-plan.js

@@ -0,0 +1,477 @@
+/** Package data this size or larger is a bundle or a binary, not configuration. */
+export const PACKAGE_DATA_MAX_BYTES = 256 * 1024;
+const CODE_FILE = /\.(?:c|m)?(?:j|t)sx?$|\.map$|\.d\.(?:c|m)?ts$|\.node$|\.wasm$/;
+const DECLARATION_FILE = /\.d\.(?:c|m)?ts$/;
+/** Directory names whose contents are dependencies, VCS state or regenerable caches. */
+const PROJECT_EXCLUDED = new Set([
+    'node_modules', '.git', '.hg', '.svn', '.nimbus', '.next', '.nuxt', '.output', '.astro',
+    '.svelte-kit', '.turbo', '.cache', '.parcel-cache', '.vite', '.vercel', '.wrangler', 'coverage',
+]);
+/** $HOME-relative caches: package stores and regenerable state, not configuration. */
+const HOME_EXCLUDED = [
+    '.cache/', '.npm/', '.bun/install/', '.nimbus/', '.pnpm-store/', '.yarn/cache/', '.yarn/berry/', '.node-gyp/',
+    '.local/share/pnpm/', '.local/state/',
+];
+const CONVENTION = [
+    /^package\.json$/, /^(?:ts|js)config(?:\..*)?\.json$/, /^\.env(?:\..*)?$/, /^\.npmrc$/, /^\.nvmrc$/,
+    /\.config\.(?:c|m)?(?:j|t)s$/, /\.config\.json$/, /^\.[\w-]+rc(?:\.(?:json|js|cjs|mjs|ya?ml|toml))?$/,
+    /^(?:package-lock\.json|pnpm-lock\.yaml|pnpm-workspace\.yaml|yarn\.lock|bun\.lockb?|\.package-lock\.json|\.modules\.yaml)$/,
+    /^\.browserslistrc$/, /^\.editorconfig$/, /^\.gitignore$/,
+];
+function key(path) {
+    return path.replace(/^\/+/, '').replace(/\/+$/, '');
+}
+function parentOf(k) {
+    const i = k.lastIndexOf('/');
+    return i < 0 ? '' : k.slice(0, i);
+}
+function baseOf(k) {
+    return k.slice(k.lastIndexOf('/') + 1);
+}
+/** The package directory a path sits in: up to the name after its last node_modules. */
+export function packageRootOf(k) {
+    const at = k.lastIndexOf('node_modules/');
+    if (at < 0)
+        return null;
+    const rest = k.slice(at + 'node_modules/'.length).split('/');
+    const take = rest[0]?.startsWith('@') ? 2 : 1;
+    if (rest.length <= take)
+        return null;
+    return k.slice(0, at) + 'node_modules/' + rest.slice(0, take).join('/');
+}
+function joinKey(base, rel) {
+    const out = base ? base.split('/') : [];
+    for (const seg of rel.split('/')) {
+        if (seg === '' || seg === '.')
+            continue;
+        if (seg === '..')
+            out.pop();
+        else
+            out.push(seg);
+    }
+    return out.join('/');
+}
+/** One `exports` target: a string, or the first usable branch of a conditions object. */
+function exportTarget(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value)) {
+        for (const v of value) {
+            const t = exportTarget(v);
+            if (t)
+                return t;
+        }
+        return null;
+    }
+    if (value && typeof value === 'object') {
+        for (const cond of ['node', 'import', 'module', 'default', 'require']) {
+            if (cond in value) {
+                const t = exportTarget(value[cond]);
+                if (t)
+                    return t;
+            }
+        }
+    }
+    return null;
+}
+/** Map `./sub` through a package.json `exports` field; null when it does not export it. */
+function mapExports(exportsField, sub) {
+    if (typeof exportsField !== 'object' || exportsField === null || Array.isArray(exportsField)) {
+        return sub === '.' ? exportTarget(exportsField) : null;
+    }
+    const table = exportsField;
+    if (!Object.keys(table).some((k) => k.startsWith('.')))
+        return sub === '.' ? exportTarget(table) : null;
+    if (sub in table)
+        return exportTarget(table[sub]);
+    let best = null;
+    for (const [pattern, target] of Object.entries(table)) {
+        const star = pattern.indexOf('*');
+        if (star < 0)
+            continue;
+        const prefix = pattern.slice(0, star);
+        const suffix = pattern.slice(star + 1);
+        if (!sub.startsWith(prefix) || !sub.endsWith(suffix) || sub.length < prefix.length + suffix.length)
+            continue;
+        if (!best || prefix.length > best.prefix.length)
+            best = { prefix, suffix, target };
+    }
+    if (!best)
+        return null;
+    const t = exportTarget(best.target);
+    if (!t)
+        return null;
+    return t.replaceAll('*', sub.slice(best.prefix.length, sub.length - best.suffix.length));
+}
+async function resolveSpecifier(source, fromDir, spec, manifests) {
+    const parts = spec.split('/');
+    const nameLen = spec.startsWith('@') ? 2 : 1;
+    if (parts.length < nameLen)
+        return null;
+    const name = parts.slice(0, nameLen).join('/');
+    const sub = parts.slice(nameLen).join('/');
+    for (let dir = fromDir;; dir = parentOf(dir)) {
+        if (baseOf(dir) !== 'node_modules') {
+            const pkgDir = joinKey(dir, 'node_modules/' + name);
+            let manifest = manifests.get(pkgDir);
+            if (manifest === undefined) {
+                const text = await source.readText(pkgDir + '/package.json');
+                try {
+                    manifest = text === null ? null : JSON.parse(text);
+                }
+                catch {
+                    manifest = null;
+                }
+                manifests.set(pkgDir, manifest);
+            }
+            if (manifest) {
+                const mapped = manifest.exports !== undefined ? mapExports(manifest.exports, sub ? './' + sub : '.') : null;
+                if (mapped)
+                    return joinKey(pkgDir, mapped);
+                return sub ? joinKey(pkgDir, sub) : null;
+            }
+        }
+        if (dir === '')
+            return null;
+    }
+}
+/** Symlinks a lookup follows before it gives up (Linux's MAXSYMLINKS). */
+const MAX_LINK_HOPS = 40;
+/**
+ * A key with every symlink along it replaced by its target, as a lookup
+ * resolves it, asking the source one component at a time; null past
+ * MAX_LINK_HOPS (ELOOP).
+ */
+async function throughLinks(source, k) {
+    let path = k;
+    for (let hops = 0; hops <= MAX_LINK_HOPS; hops++) {
+        const segs = path.split('/');
+        let followed = false;
+        for (let i = 1; i <= segs.length; i++) {
+            const at = segs.slice(0, i).join('/');
+            const target = await source.readlink('/' + at);
+            if (target === null)
+                continue;
+            const base = target.startsWith('/') ? key(target) : joinKey(parentOf(at), target);
+            path = joinKey(base, segs.slice(i).join('/'));
+            followed = true;
+            break;
+        }
+        if (!followed)
+            return path;
+    }
+    return null;
+}
+/**
+ * The plan for one launch. Walks the namespace once, in pages.
+ */
+export async function planFacetData(source, input) {
+    const cwd = key(input.cwd);
+    const home = key(input.home);
+    const cwdPrefix = cwd ? cwd + '/' : '';
+    const homeDot = home ? home + '/.' : '.';
+    const closureRoots = new Set();
+    let typescriptRoot = null;
+    for (const path of input.closure) {
+        const root = packageRootOf(key(path));
+        if (root === null)
+            continue;
+        closureRoots.add(root);
+        if (typescriptRoot === null && root.endsWith('node_modules/typescript'))
+            typescriptRoot = root;
+    }
+    const conventionDirs = new Set([joinKey(cwd, 'node_modules')]);
+    for (let d = cwd;; d = parentOf(d)) {
+        conventionDirs.add(d);
+        if (d === '')
+            break;
+    }
+    const closure = new Set();
+    for (const path of input.closure)
+        closure.add(key(path));
+    // Static references, as keys: each exact path, and whether any site reads
+    // it synchronously.
+    const exact = new Map();
+    const note = (k, sync) => exact.set(k, exact.get(k) === true || sync);
+    const listed = new Set();
+    const patterns = [];
+    const manifests = new Map();
+    for (const refs of input.refs) {
+        for (const r of refs.exact)
+            note(key(r.path), r.sync);
+        for (const r of refs.cwdRelative)
+            note(joinKey(cwd, r.path), r.sync);
+        for (const p of refs.listed)
+            listed.add(key(p));
+        for (const p of refs.patterns)
+            patterns.push({ dir: key(p.dir), prefix: p.prefix, suffix: p.suffix });
+    }
+    const learned = new Set();
+    for (const p of input.learned ?? [])
+        learned.add(key(p));
+    const rules = Object.fromEntries(['package-json', 'project', 'convention', 'package-data', 'home', 'typescript', 'static', 'learned']
+        .map((r) => [r, { files: 0, bytes: 0 }]));
+    const paths = [];
+    const planned = new Set();
+    let bytes = 0;
+    const take = (entry, rule) => {
+        if (planned.has(entry.path))
+            return;
+        planned.add(entry.path);
+        paths.push(entry.path);
+        bytes += entry.size;
+        rules[rule].files++;
+        rules[rule].bytes += entry.size;
+    };
+    // Directories a reference expands to: a listed directory.
+    const expanded = new Set();
+    const underExpanded = (k) => {
+        for (let d = parentOf(k); d !== ''; d = parentOf(d)) {
+            if (expanded.has(d))
+                return true;
+            if (baseOf(d) === 'node_modules')
+                return false;
+        }
+        return false;
+    };
+    const homeKept = (k) => {
+        const rel = k.slice(home ? home.length + 1 : 0) + '/';
+        return !HOME_EXCLUDED.some((prefix) => rel.startsWith(prefix));
+    };
+    /**
+     * Whether a file lies in a dependency, VCS or cache directory below `dir`,
+     * or in a cache of the home directory it is in ($HOME, or /home/<user>).
+     */
+    const excludedBelow = (dir, k) => {
+        const rel = k.slice(dir === '' ? 0 : dir.length + 1).split('/');
+        if (rel.slice(0, -1).some((seg) => PROJECT_EXCLUDED.has(seg)))
+            return true;
+        const segs = k.split('/');
+        const userHome = home !== '' && k.startsWith(home + '/') ? home
+            : segs[0] === 'home' && segs.length > 2 ? 'home/' + segs[1] : null;
+        if (userHome === null)
+            return false;
+        const inHome = k.slice(userHome.length + 1) + '/';
+        return HOME_EXCLUDED.some((prefix) => inHome.startsWith(prefix));
+    };
+    /**
+     * Whether a file is one a pattern `dir/prefix*suffix` can name. A hole with
+     * a known prefix or suffix fills one name in `dir`: a file there, or the
+     * files directly in a directory there. A bare hole under a
+     * named directory (`join(dir, x)`) may be a relative path of any depth: the
+     * directory's files, minus dependency, VCS and cache directories. A bare
+     * hole at the root (`'/' + x`) names the whole filesystem, which nothing
+     * static bounds: it matches nothing and the read is a run-time one.
+     */
+    const patternMatch = (k) => {
+        const dir = parentOf(k);
+        const name = baseOf(k);
+        for (const p of patterns) {
+            if (p.prefix === '' && p.suffix === '') {
+                if (p.dir !== '' && k.startsWith(p.dir + '/') && !excludedBelow(p.dir, k))
+                    return true;
+                continue;
+            }
+            const named = (n) => n.startsWith(p.prefix) && n.endsWith(p.suffix) && n.length >= p.prefix.length + p.suffix.length;
+            if (p.dir === dir && named(name))
+                return true;
+            // A matched name may be a directory the code lists: its own files, one level.
+            if (dir !== '' && p.dir === parentOf(dir) && named(baseOf(dir)) && !excludedBelow(p.dir, k))
+                return true;
+        }
+        return false;
+    };
+    const declarations = [];
+    const packageRoots = new Set();
+    // Directories a home or project symlink points at, whose files the rule
+    // that took the link would have taken had they been in place.
+    const linkedDirs = [];
+    /**
+     * A statically named file is worth holding when the module map does not
+     * already hold it, and it is data-sized or the code reads it synchronously
+     * by that name: such a read cannot wait for bytes of any size. Its bytes
+     * count toward the plan's storage, which the launch admits or refuses.
+     */
+    /** Sync-read paths the walk found as files under their own name. */
+    const seenFiles = new Set();
+    const staticWorthy = (entry) => !closure.has(entry.path)
+        && (entry.size < PACKAGE_DATA_MAX_BYTES || exact.get(entry.path) === true);
+    let after = null;
+    for (;;) {
+        const page = await source.list(after);
+        if (input.spend)
+            await input.spend(page.entries.length * 64);
+        for (const raw of page.entries) {
+            const k = key(raw.path);
+            const entry = { path: k, kind: raw.kind, size: raw.size };
+            if (entry.kind === 'directory') {
+                if (listed.has(k))
+                    expanded.add(k);
+                if (packageRootOf(k + '/x') === k)
+                    packageRoots.add(k);
+                continue;
+            }
+            const segs = k.split('/');
+            if (entry.kind === 'symlink') {
+                if (raw.linkTarget === undefined)
+                    continue;
+                const inProject = (cwdPrefix === '' || k.startsWith(cwdPrefix))
+                    && !(cwdPrefix === '' ? segs : k.slice(cwdPrefix.length).split('/')).slice(0, -1).some((x) => PROJECT_EXCLUDED.has(x));
+                const inHome = k.startsWith(homeDot) && homeKept(k) && !segs.includes('node_modules');
+                if (inProject || inHome) {
+                    const target = raw.linkTarget.startsWith('/') ? key(raw.linkTarget) : joinKey(parentOf(k), raw.linkTarget);
+                    linkedDirs.push({ target, rule: inProject ? 'project' : 'home' });
+                }
+                continue;
+            }
+            if (entry.kind !== 'file')
+                continue;
+            if (exact.get(k) === true)
+                seenFiles.add(k);
+            const name = baseOf(k);
+            if (name === 'package.json' && !segs.includes('.git')) {
+                take(entry, 'package-json');
+                continue;
+            }
+            if (cwdPrefix === '' || k.startsWith(cwdPrefix)) {
+                const rel = cwdPrefix === '' ? segs : k.slice(cwdPrefix.length).split('/');
+                if (!rel.slice(0, -1).some((s) => PROJECT_EXCLUDED.has(s))) {
+                    take(entry, 'project');
+                    continue;
+                }
+            }
+            if (conventionDirs.has(parentOf(k)) && CONVENTION.some((re) => re.test(name))) {
+                take(entry, 'convention');
+                continue;
+            }
+            const root = packageRootOf(k);
+            if (root !== null && closureRoots.has(root) && !CODE_FILE.test(name) && entry.size < PACKAGE_DATA_MAX_BYTES
+                && !k.slice(root.length + 1).includes('node_modules/')) {
+                take(entry, 'package-data');
+                continue;
+            }
+            if (k.startsWith(homeDot) && homeKept(k) && !segs.includes('node_modules') && !segs.includes('.git')) {
+                take(entry, 'home');
+                continue;
+            }
+            if (typescriptRoot !== null) {
+                if (root === typescriptRoot && parentOf(k) === typescriptRoot + '/lib' && /^lib\..*\.d\.ts$/.test(name)) {
+                    take(entry, 'typescript');
+                    continue;
+                }
+                if (k.includes('node_modules/@types/')) {
+                    take(entry, 'typescript');
+                    continue;
+                }
+                if (root !== null && DECLARATION_FILE.test(name))
+                    declarations.push(entry);
+            }
+            if ((exact.has(k) || listed.has(parentOf(k)) || patternMatch(k) || underExpanded(k)) && staticWorthy(entry)) {
+                take(entry, 'static');
+                continue;
+            }
+            if (learned.has(k)) {
+                take(entry, 'learned');
+                continue;
+            }
+        }
+        if (page.next === null)
+            break;
+        after = page.next;
+    }
+    // What @types depends on (undici-types for @types/node): their declarations.
+    if (typescriptRoot !== null && declarations.length > 0) {
+        const typeDeps = new Set();
+        const typesRoots = new Set();
+        for (const p of paths) {
+            if (!p.endsWith('/package.json') || !p.includes('node_modules/@types/'))
+                continue;
+            const root = packageRootOf(p);
+            if (root !== null && root + '/package.json' === p)
+                typesRoots.add(root);
+        }
+        for (const root of typesRoots) {
+            const text = await source.readText(root + '/package.json');
+            try {
+                const deps = JSON.parse(text ?? '{}').dependencies ?? {};
+                for (const dep of Object.keys(deps))
+                    typeDeps.add(dep);
+            }
+            catch { /* not a manifest */ }
+        }
+        for (const entry of declarations) {
+            const root = packageRootOf(entry.path);
+            const name = root.slice(root.lastIndexOf('node_modules/') + 'node_modules/'.length);
+            if (typeDeps.has(name))
+                take(entry, 'typescript');
+        }
+    }
+    // A synchronous read of a path through a symlink reads the file the link
+    // leads to, which the walk saw under its own name: hold that file. Only
+    // such a read's own path is resolved, one component at a time; the
+    // namespace's links are never collected.
+    for (const [k, sync] of exact) {
+        if (!sync || planned.has(k) || seenFiles.has(k))
+            continue;
+        const target = await throughLinks(source, k);
+        if (target === null || target === k || planned.has(target))
+            continue;
+        const found = await source.stat(target);
+        if (found === null || found.kind !== 'file')
+            continue;
+        const entry = { path: target, kind: 'file', size: found.size };
+        if (!closure.has(target))
+            take(entry, 'static');
+    }
+    // Specifiers resolve through package.json files, so only those whose
+    // package exists are looked up.
+    for (const refs of input.refs) {
+        for (const r of refs.resolves) {
+            const name = r.spec.split('/').slice(0, r.spec.startsWith('@') ? 2 : 1).join('/');
+            let exists = false;
+            for (let d = key(r.from); !exists; d = parentOf(d)) {
+                if (packageRoots.has(joinKey(d, 'node_modules/' + name)))
+                    exists = true;
+                if (d === '')
+                    break;
+            }
+            if (!exists)
+                continue;
+            const resolved = await resolveSpecifier(source, key(r.from), r.spec, manifests);
+            if (resolved === null || planned.has(resolved))
+                continue;
+            const found = await source.stat(resolved);
+            if (found === null || found.kind !== 'file')
+                continue;
+            const entry = { path: resolved, kind: 'file', size: found.size };
+            if (staticWorthy(entry))
+                take(entry, 'static');
+        }
+    }
+    // The files behind symlinked directories the project or home rule reached.
+    if (linkedDirs.length > 0) {
+        after = null;
+        for (;;) {
+            const page = await source.list(after);
+            if (input.spend)
+                await input.spend(page.entries.length * 64);
+            for (const raw of page.entries) {
+                if (raw.kind !== 'file')
+                    continue;
+                const k = key(raw.path);
+                for (const { target, rule } of linkedDirs) {
+                    if (k === target || k.startsWith(target + '/')) {
+                        if (!k.slice(target.length).split('/').some((x) => x === 'node_modules' || x === '.git')) {
+                            take({ path: k, kind: 'file', size: raw.size }, rule);
+                        }
+                        break;
+                    }
+                }
+            }
+            if (page.next === null)
+                break;
+            after = page.next;
+        }
+    }
+    return { paths, bytes, rules };
+}

package/dist/facets/esbuild-transform.d.ts

@@ -1,14 +1,40 @@
-import { type EsbuildTransformOptions, type TransformResult } from '@nimbus-sh/core/runtime/esbuild-service.js';
-import type { DurableObject } from 'cloudflare:workers';
+import { EsbuildService, type EsbuildBuildHost, type EsbuildTransformHost } from '@nimbus-sh/core/runtime/esbuild-service.js';
+import type { EsbuildCliArgs, EsbuildCliOutput } from '@nimbus-sh/core/runtime/esbuild-cli.js';
 import type { WorkerCode } from '@nimbus-sh/fabric/vendor/types.js';
-export declare const ESBUILD_TRANSFORM_WORKER_ID: string;
-export type EsbuildTransformFacetRpc = DurableObject & {
-    transform(code: string, options: EsbuildTransformOptions): Promise<TransformResult>;
-};
+import type { NamespaceFs } from '@nimbus-sh/core/runtime/process-files.js';
+export declare const ESBUILD_FACET_WORKER_ID: string;
 /**
- * Slim Worker Loader module whose DO class owns the esbuild wasm heap.
- * `jsFnBody` is the staged adapter (fetchEsbuildJsFnBody), spliced in so
- * the facet evaluates it at startup, the one moment it may.
+ * Slim Worker Loader module whose DO class owns the esbuild wasm.
+ * `jsFnBody` is the staged adapter (fetchEsbuildJsFnBody), compiled into a
+ * factory at startup, the one moment code may be generated from a string;
+ * each call of the factory is a separate esbuild. `cliRunner` is the staged
+ * runner of the `esbuild` command (fetchEsbuildCliRunner).
  */
-export declare function esbuildTransformWorkerCode(wasmBytes: ArrayBuffer, jsFnBody: string): WorkerCode;
+export declare function esbuildFacetWorkerCode(wasmBytes: ArrayBuffer, jsFnBody: string, cliRunner: string): WorkerCode;
+/**
+ * The transform host a Durable Object's esbuild runs its transforms on: its
+ * esbuild facet, a slice per call. Transforms are pure, so a slice whose call
+ * failed (the facet reset, the connection dropped) is sent once more, to a
+ * freshly minted stub; an overloaded facet is not asked again. A slice that
+ * still fails answers each of its requests with a transient error, which is
+ * no verdict on the source, and the other slices keep their answers.
+ */
+export declare function esbuildTransformHost(ctx: DurableObjectState, env: unknown): EsbuildTransformHost;
+/**
+ * The build host a Durable Object's esbuild runs its builds on: its esbuild
+ * facet. The plugin, and with it every file read, stays with the caller.
+ */
+export declare function esbuildBuildHost(ctx: DurableObjectState, env: unknown): EsbuildBuildHost;
+/**
+ * Runs one `esbuild` command in the Durable Object's esbuild facet, as
+ * process `pid`: its files go through a supervisor capability minted for that
+ * pid, the one IsolatePool mints for a facet, and its stdout and stderr come
+ * back through `output` as esbuild writes them. Resolves to its exit status.
+ */
+export declare function runEsbuildCli(ctx: DurableObjectState, env: unknown, pid: number, args: EsbuildCliArgs, output: EsbuildCliOutput): Promise<number>;
+/**
+ * The esbuild a Durable Object's supervisor shares: its transforms and its
+ * builds run in its esbuild facet, and build() reads `vfs` from here.
+ */
+export declare function supervisorEsbuildService(ctx: DurableObjectState, env: unknown, vfs: NamespaceFs): EsbuildService;
 //# sourceMappingURL=esbuild-transform.d.ts.map

package/dist/facets/esbuild-transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"esbuild-transform.d.ts","sourceRoot":"","sources":["../../src/facets/esbuild-transform.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EACrB,MAAM,4CAA4C,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAGpE,eAAO,MAAM,2BAA2B,QAC+B,CAAC;AAExE,MAAM,MAAM,wBAAwB,GAAG,aAAa,GAAG;IACrD,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CACrF,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,CA8B/F"}
+{"version":3,"file":"esbuild-transform.d.ts","sourceRoot":"","sources":["../../src/facets/esbuild-transform.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EAEd,KAAK,gBAAgB,EAIrB,KAAK,oBAAoB,EAG1B,MAAM,4CAA4C,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAS/F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAIpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAC;AAwD5E,eAAO,MAAM,uBAAuB,QAAqG,CAAC;AAW1I;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,UAAU,CAoB9G;AAqED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,OAAO,GAAG,oBAAoB,CAmChG;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,OAAO,GAAG,gBAAgB,CAIxF;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,kBAAkB,EACvB,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,GAAG,cAAc,CAKhH"}