@vibesdotdev/infra-core 0.0.1 → 1.0.0-rc.11

package/dist/deployment-graph.js

@@ -0,0 +1,705 @@
+/**
+ * The module graph a provider bundles into one Worker script, read from the built output before
+ * the provider's bundler runs.
+ *
+ * The walk starts at the Worker entries and follows what the bundler follows: relative imports,
+ * bare package specifiers resolved through `node_modules` with the provider's export conditions,
+ * dynamic imports and CommonJS `require` calls. Built-in modules (`node:tls`, `cloudflare:workers`)
+ * are leaves the provider supplies or refuses. A bundler's own module markers (`//#region <source>`)
+ * name the source modules a built chunk inlined, so a chunk is attributed to the packages it really
+ * carries. Specifiers are read by a lexer that skips comments, strings and regular expressions, so
+ * prose about `require('fs')` is not an import.
+ *
+ * The measurement is pre-minify and pre-tree-shake: whole modules, as the bundler reads them.
+ */
+import * as z from 'zod/v4';
+import { jsoncCodec } from '@vibesdotdev/shared/jsonc';
+const KEYWORDS_BEFORE_EXPRESSION = new Set([
+    'return', 'typeof', 'instanceof', 'case', 'do', 'else', 'in', 'of', 'new', 'delete', 'void', 'throw', 'yield', 'await'
+]);
+const PUNCTUATION_BEFORE_EXPRESSION = new Set(['(', ',', '=', ':', '[', '!', '&', '|', '?', '{', '}', ';', '+', '-', '*', '%', '<', '>', '~', '^']);
+function isIdentifierStart(char) {
+    return /[A-Za-z_$\u0080-￿]/.test(char);
+}
+function isIdentifierPart(char) {
+    return /[A-Za-z0-9_$\u0080-￿]/.test(char);
+}
+const encoder = new TextEncoder();
+export function utf8Bytes(text) {
+    return encoder.encode(text).length;
+}
+/**
+ * The import, export-from, dynamic-import and `require` specifiers of one JavaScript or TypeScript
+ * module, and the source regions a bundler marked in it. Type-only imports and exports carry no
+ * runtime module and are skipped. Only literal specifiers are read: a computed `import(name)` names
+ * no module a bundler can include either.
+ */
+export function scanModule(text) {
+    const specifiers = [];
+    const regionStarts = [];
+    const regions = [];
+    const length = text.length;
+    let index = 0;
+    /** The last significant token, to tell a regular expression from a division. */
+    let previous = '';
+    let previousWord = '';
+    /** Inside an `import` or `export` statement whose `from` is still to come. */
+    let pendingStatement;
+    /** Open template literal nesting: each entry is the brace depth at which its `${` opened. */
+    const templates = [];
+    let braceDepth = 0;
+    const skipSpace = (from) => {
+        let position = from;
+        while (position < length) {
+            const char = text[position];
+            if (char === ' ' || char === '\t' || char === '\n' || char === '\r')
+                position += 1;
+            else if (char === '/' && text[position + 1] === '/') {
+                while (position < length && text[position] !== '\n')
+                    position += 1;
+            }
+            else if (char === '/' && text[position + 1] === '*') {
+                const end = text.indexOf('*/', position + 2);
+                position = end < 0 ? length : end + 2;
+            }
+            else
+                break;
+        }
+        return position;
+    };
+    /** A string literal at `from`: its value and end, or undefined. Template literals count only without substitutions. */
+    const literalAt = (from) => {
+        const quote = text[from];
+        if (quote !== '"' && quote !== "'" && quote !== '`')
+            return undefined;
+        let position = from + 1;
+        let value = '';
+        while (position < length && text[position] !== quote) {
+            if (text[position] === '\\') {
+                value += text[position + 1] ?? '';
+                position += 2;
+                continue;
+            }
+            if (quote === '`' && text[position] === '$' && text[position + 1] === '{')
+                return undefined;
+            if (quote !== '`' && text[position] === '\n')
+                return undefined;
+            value += text[position];
+            position += 1;
+        }
+        return position < length ? { value, end: position + 1 } : undefined;
+    };
+    const wordAt = (from) => {
+        let end = from;
+        while (end < length && isIdentifierPart(text[end] ?? ''))
+            end += 1;
+        return text.slice(from, end);
+    };
+    const skipString = (from, quote) => {
+        let position = from + 1;
+        while (position < length) {
+            const char = text[position];
+            if (char === '\\')
+                position += 2;
+            else if (char === quote || char === '\n')
+                return position + 1;
+            else
+                position += 1;
+        }
+        return length;
+    };
+    /** Skip template text from `from` (just after a backtick or a closing `}`); stops after the closing backtick or at a `${`. */
+    const skipTemplateText = (from) => {
+        let position = from;
+        while (position < length) {
+            const char = text[position];
+            if (char === '\\')
+                position += 2;
+            else if (char === '`')
+                return position + 1;
+            else if (char === '$' && text[position + 1] === '{') {
+                templates.push(braceDepth);
+                braceDepth += 1;
+                return position + 2;
+            }
+            else
+                position += 1;
+        }
+        return length;
+    };
+    const skipRegex = (from) => {
+        let position = from + 1;
+        let inClass = false;
+        while (position < length) {
+            const char = text[position];
+            if (char === '\\')
+                position += 2;
+            else if (char === '\n')
+                return position;
+            else if (inClass) {
+                if (char === ']')
+                    inClass = false;
+                position += 1;
+            }
+            else if (char === '[') {
+                inClass = true;
+                position += 1;
+            }
+            else if (char === '/') {
+                position += 1;
+                while (position < length && isIdentifierPart(text[position] ?? ''))
+                    position += 1;
+                return position;
+            }
+            else
+                position += 1;
+        }
+        return length;
+    };
+    while (index < length) {
+        const char = text[index] ?? '';
+        const next = text[index + 1];
+        if (char === '/' && next === '/') {
+            const end = text.indexOf('\n', index);
+            const lineEnd = end < 0 ? length : end;
+            const comment = text.slice(index + 2, lineEnd);
+            if (comment.startsWith('#region '))
+                regionStarts.push({ source: comment.slice('#region '.length).trim(), offset: index });
+            else if (comment.startsWith('#endregion')) {
+                const open = regionStarts.pop();
+                if (open)
+                    regions.push({ source: open.source, bytes: utf8Bytes(text.slice(open.offset, lineEnd)) });
+            }
+            index = lineEnd;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            const end = text.indexOf('*/', index + 2);
+            index = end < 0 ? length : end + 2;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            index = skipString(index, char);
+            previous = '"';
+            previousWord = '';
+            continue;
+        }
+        if (char === '`') {
+            index = skipTemplateText(index + 1);
+            previous = '`';
+            previousWord = '';
+            continue;
+        }
+        if (char === '/') {
+            const expression = previous === '' || PUNCTUATION_BEFORE_EXPRESSION.has(previous) || KEYWORDS_BEFORE_EXPRESSION.has(previousWord);
+            if (expression) {
+                index = skipRegex(index);
+                previous = 'regex';
+                previousWord = '';
+                continue;
+            }
+            index += 1;
+            previous = '/';
+            previousWord = '';
+            continue;
+        }
+        if (char === '{') {
+            braceDepth += 1;
+        }
+        else if (char === '}') {
+            braceDepth -= 1;
+            if (templates.length > 0 && templates[templates.length - 1] === braceDepth) {
+                templates.pop();
+                index = skipTemplateText(index + 1);
+                previous = '`';
+                previousWord = '';
+                continue;
+            }
+        }
+        if (char === ';')
+            pendingStatement = undefined;
+        if (isIdentifierStart(char) && !isIdentifierPart(text[index - 1] ?? '')) {
+            const word = wordAt(index);
+            const afterWord = index + word.length;
+            const memberAccess = previous === '.' || previous === '?.';
+            if (!memberAccess && (word === 'import' || word === 'export' || word === 'require' || word === 'from')) {
+                const at = skipSpace(afterWord);
+                const following = text[at] ?? '';
+                if (word === 'require' || (word === 'import' && following === '(')) {
+                    if (following === '(') {
+                        const argument = skipSpace(at + 1);
+                        const literal = literalAt(argument);
+                        if (literal && text[skipSpace(literal.end)] === ')' && literal.value.length > 0) {
+                            specifiers.push({ specifier: literal.value, kind: word === 'require' ? 'require' : 'dynamic' });
+                        }
+                    }
+                }
+                else if (word === 'import' && following !== '.') {
+                    const literal = literalAt(at);
+                    if (literal) {
+                        specifiers.push({ specifier: literal.value, kind: 'static' });
+                        index = literal.end;
+                        previous = '"';
+                        previousWord = '';
+                        continue;
+                    }
+                    const nextWord = wordAt(at);
+                    const typeOnly = nextWord === 'type' && /^[\s]*[{*A-Za-z_$]/.test(text.slice(at + 4, at + 6)) && wordAt(skipSpace(at + 4)) !== 'from';
+                    pendingStatement = typeOnly ? 'type' : 'value';
+                }
+                else if (word === 'export') {
+                    const nextWord = wordAt(at);
+                    if (following === '{' || following === '*')
+                        pendingStatement = 'value';
+                    else if (nextWord === 'type' && /^\s*[{*]/.test(text.slice(at + 4, at + 7)))
+                        pendingStatement = 'type';
+                }
+                else if (word === 'from' && pendingStatement !== undefined) {
+                    const literal = literalAt(at);
+                    if (literal) {
+                        if (pendingStatement === 'value')
+                            specifiers.push({ specifier: literal.value, kind: 'static' });
+                        pendingStatement = undefined;
+                        index = literal.end;
+                        previous = '"';
+                        previousWord = '';
+                        continue;
+                    }
+                }
+            }
+            index = afterWord;
+            previous = 'word';
+            previousWord = word;
+            continue;
+        }
+        if (char !== ' ' && char !== '\t' && char !== '\n' && char !== '\r') {
+            previous = char === '?' && next === '.' ? '?.' : char;
+            if (previous === '?.')
+                index += 1;
+            previousWord = '';
+        }
+        index += 1;
+    }
+    return { specifiers, regions };
+}
+export const SubpathTargetSchema = z.lazy(() => z.union([
+    z.string().transform((path) => ({ kind: 'path', path })),
+    z.null().transform(() => ({ kind: 'excluded' })),
+    z.array(SubpathTargetSchema).transform((items) => ({ kind: 'list', items })),
+    z.record(z.string(), SubpathTargetSchema).transform((record) => ({ kind: 'keyed', entries: Object.entries(record) }))
+]));
+/** The manifest fields resolution reads. A field another tool shapes differently is no resolution evidence, not a failure. */
+const PackageManifestSchema = z.object({
+    name: z.string().optional(),
+    main: z.string().optional().catch(undefined),
+    module: z.string().optional().catch(undefined),
+    /** Only the string form names an entry; the object form remaps files, which this walk does not follow. */
+    browser: z.string().optional().catch(undefined),
+    exports: SubpathTargetSchema.optional().catch(undefined),
+    imports: SubpathTargetSchema.optional().catch(undefined),
+    vibes: z.object({ host: z.boolean().optional() }).loose().optional()
+});
+export function joinPath(directory, name) {
+    return `${directory.replace(/\/+$/, '')}/${name}`;
+}
+export function parentPath(path) {
+    const trimmed = path.replace(/\/+$/, '');
+    const index = trimmed.lastIndexOf('/');
+    return index <= 0 ? '/' : trimmed.slice(0, index);
+}
+/** Resolve `.` and `..` segments of an absolute `/`-separated path. */
+export function normalizePath(path) {
+    const out = [];
+    for (const segment of path.split('/')) {
+        if (segment === '' || segment === '.')
+            continue;
+        if (segment === '..')
+            out.pop();
+        else
+            out.push(segment);
+    }
+    return `/${out.join('/')}`;
+}
+export function relativeTo(root, path) {
+    const prefix = `${root.replace(/\/+$/, '')}/`;
+    if (path.startsWith(prefix))
+        return path.slice(prefix.length);
+    const rootSegments = root.split('/').filter(Boolean);
+    const pathSegments = path.split('/').filter(Boolean);
+    let shared = 0;
+    while (shared < rootSegments.length && rootSegments[shared] === pathSegments[shared])
+        shared += 1;
+    return [...rootSegments.slice(shared).map(() => '..'), ...pathSegments.slice(shared)].join('/');
+}
+/**
+ * Node's own built-in module namespace (what `node:module`'s `builtinModules` lists, without
+ * internal `_` modules a bundler never sees as bare names). A bundler targeting a Node-compatible
+ * runtime treats these bare names as built-ins before any `node_modules` lookup. Which of them a
+ * provider actually supplies is the provider's declaration, never this list.
+ */
+export const NODE_BUILTIN_MODULES = new Set([
+    'assert', 'async_hooks', 'buffer', 'child_process', 'cluster', 'console', 'constants', 'crypto', 'dgram',
+    'diagnostics_channel', 'dns', 'domain', 'events', 'fs', 'http', 'http2', 'https', 'inspector', 'module', 'net',
+    'os', 'path', 'perf_hooks', 'process', 'punycode', 'querystring', 'readline', 'repl', 'stream', 'string_decoder',
+    'sys', 'timers', 'tls', 'trace_events', 'tty', 'url', 'util', 'v8', 'vm', 'wasi', 'worker_threads', 'zlib'
+]);
+const RESOLVABLE_EXTENSIONS = ['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts', '.json', '.svelte.js', '.svelte.ts'];
+const SCANNED = /\.(m|c)?[jt]s$/;
+/** One `exports`/`imports` target, resolved against the active conditions. `null` excludes the subpath. */
+function conditionalTarget(target, conditions, star) {
+    switch (target.kind) {
+        case 'path':
+            return star === undefined ? target.path : target.path.split('*').join(star);
+        case 'excluded':
+            return null;
+        case 'list':
+            for (const candidate of target.items) {
+                const resolved = conditionalTarget(candidate, conditions, star);
+                if (resolved !== undefined)
+                    return resolved;
+            }
+            return undefined;
+        case 'keyed':
+            for (const [condition, value] of target.entries) {
+                if (condition !== 'default' && !conditions.has(condition))
+                    continue;
+                const resolved = conditionalTarget(value, conditions, star);
+                if (resolved !== undefined)
+                    return resolved;
+            }
+            return undefined;
+    }
+}
+function isSubpathKey(key) {
+    return key.startsWith('.') || key.startsWith('#');
+}
+/** The Node subpath-map lookup shared by `exports` and `imports`: exact keys first, then the longest `*` pattern. */
+export function resolveSubpathMap(map, subpath, conditions) {
+    if (!map)
+        return undefined;
+    if (map.kind !== 'keyed' || !map.entries.some(([key]) => isSubpathKey(key))) {
+        return subpath === '.' ? conditionalTarget(map, conditions, undefined) : undefined;
+    }
+    const exact = map.entries.find(([key]) => key === subpath);
+    if (exact)
+        return conditionalTarget(exact[1], conditions, undefined);
+    let best;
+    for (const [key, target] of map.entries) {
+        const starAt = key.indexOf('*');
+        if (starAt < 0)
+            continue;
+        const prefix = key.slice(0, starAt);
+        const suffix = key.slice(starAt + 1);
+        if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix) || subpath.length < key.length - 1)
+            continue;
+        if (!best || prefix.length > best.prefixLength)
+            best = { prefixLength: prefix.length, target, star: subpath.slice(prefix.length, subpath.length - suffix.length) };
+    }
+    return best ? conditionalTarget(best.target, conditions, best.star) : undefined;
+}
+/** Every path a target names under any condition. */
+function targetPaths(target) {
+    switch (target.kind) {
+        case 'path':
+            return [target.path];
+        case 'excluded':
+            return [];
+        case 'list':
+            return target.items.flatMap(targetPaths);
+        case 'keyed':
+            return target.entries.flatMap(([, value]) => targetPaths(value));
+    }
+}
+/** The export subpaths (`./consumer/plugin`) whose targets, under any condition, name `file` inside its package. */
+export function exportSubpathsOf(info, file) {
+    const exports = info.exports;
+    if (!exports || exports.kind !== 'keyed')
+        return [];
+    const relative = `./${relativeTo(info.dir, file)}`;
+    const found = [];
+    for (const [key, value] of exports.entries) {
+        if (!key.startsWith('.'))
+            continue;
+        for (const target of targetPaths(value)) {
+            const starAt = target.indexOf('*');
+            const matches = starAt < 0
+                ? target === relative
+                : relative.startsWith(target.slice(0, starAt)) && relative.endsWith(target.slice(starAt + 1));
+            if (matches) {
+                found.push(key);
+                break;
+            }
+        }
+    }
+    return found;
+}
+/** Caches over the file view: every probe the resolver makes is read once. */
+export class ModuleResolver {
+    #files;
+    #resolution;
+    #conditions;
+    #isFile = new Map();
+    #packages = new Map();
+    #owners = new Map();
+    #real = new Map();
+    constructor(files, resolution) {
+        this.#files = files;
+        this.#resolution = resolution;
+        this.#conditions = new Set(resolution.conditions);
+    }
+    isFile(path) {
+        let cached = this.#isFile.get(path);
+        if (!cached) {
+            cached = (async () => {
+                if ((await this.#files.list(path)) !== undefined)
+                    return false;
+                return (await this.#files.readText(path)) !== undefined;
+            })();
+            this.#isFile.set(path, cached);
+        }
+        return cached;
+    }
+    real(path) {
+        let cached = this.#real.get(path);
+        if (!cached) {
+            cached = (async () => (this.#files.realpath ? ((await this.#files.realpath(path)) ?? path) : path))();
+            this.#real.set(path, cached);
+        }
+        return cached;
+    }
+    /** The package whose manifest sits in `dir`, if any. */
+    packageAt(dir) {
+        let cached = this.#packages.get(dir);
+        if (!cached) {
+            cached = (async () => {
+                const manifestPath = joinPath(dir, 'package.json');
+                if (!(await this.isFile(manifestPath)))
+                    return undefined;
+                const text = await this.#files.readText(manifestPath);
+                if (text === undefined)
+                    return undefined;
+                const decoded = jsoncCodec.parse(text);
+                if (decoded.errorOffsets.length > 0)
+                    return undefined;
+                const parsed = PackageManifestSchema.safeParse(decoded.value);
+                if (!parsed.success)
+                    return undefined;
+                const manifest = parsed.data;
+                let info = {
+                    dir,
+                    name: manifest.name ?? dir.split('/').at(-1) ?? dir,
+                    named: manifest.name !== undefined,
+                    host: manifest.vibes?.host === true,
+                    vibes: manifest.vibes !== undefined
+                };
+                if (manifest.exports)
+                    info = { ...info, exports: manifest.exports };
+                if (manifest.imports)
+                    info = { ...info, imports: manifest.imports };
+                if (manifest.main)
+                    info = { ...info, main: manifest.main };
+                if (manifest.module)
+                    info = { ...info, module: manifest.module };
+                if (manifest.browser)
+                    info = { ...info, browser: manifest.browser };
+                return info;
+            })();
+            this.#packages.set(dir, cached);
+        }
+        return cached;
+    }
+    /**
+     * The nearest named package that owns `path`. A nameless `package.json` (a nested
+     * `{ "type": "module" }` marker inside a published package) is not a package boundary.
+     */
+    ownerOf(path) {
+        const dir = parentPath(path);
+        let cached = this.#owners.get(dir);
+        if (!cached) {
+            cached = (async () => {
+                const own = await this.packageAt(dir);
+                if (own?.named)
+                    return own;
+                return dir === '/' ? undefined : this.ownerOf(dir);
+            })();
+            this.#owners.set(dir, cached);
+        }
+        return cached;
+    }
+    async #fileOrIndex(base) {
+        if (await this.isFile(base))
+            return this.real(base);
+        for (const extension of RESOLVABLE_EXTENSIONS) {
+            if (await this.isFile(`${base}${extension}`))
+                return this.real(`${base}${extension}`);
+        }
+        const own = await this.packageAt(base);
+        if (own) {
+            for (const field of this.#resolution.mainFields) {
+                const entry = field === 'main' ? own.main : field === 'module' ? own.module : field === 'browser' ? own.browser : undefined;
+                if (!entry)
+                    continue;
+                const resolved = await this.#fileOrIndex(normalizePath(joinPath(base, entry)));
+                if (resolved)
+                    return resolved;
+            }
+        }
+        for (const extension of RESOLVABLE_EXTENSIONS) {
+            const index = joinPath(base, `index${extension}`);
+            if (await this.isFile(index))
+                return this.real(index);
+        }
+        return undefined;
+    }
+    async #inPackage(info, subpath) {
+        if (info.exports !== undefined) {
+            const target = resolveSubpathMap(info.exports, subpath, this.#conditions);
+            if (target === null || target === undefined)
+                return undefined;
+            const path = normalizePath(joinPath(info.dir, target));
+            return (await this.isFile(path)) ? this.real(path) : undefined;
+        }
+        return this.#fileOrIndex(subpath === '.' ? info.dir : normalizePath(joinPath(info.dir, subpath)));
+    }
+    isBuiltin(specifier) {
+        if (specifier.startsWith('node:'))
+            return specifier.slice('node:'.length);
+        const base = specifier.split('/')[0] ?? specifier;
+        const named = (name) => NODE_BUILTIN_MODULES.has(name) || this.#resolution.builtinNames.has(name);
+        return named(specifier) || named(base) ? specifier : undefined;
+    }
+    async resolve(from, raw) {
+        const specifier = raw.split(/[?#]/)[0] ?? raw;
+        if (specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('/')) {
+            const base = specifier.startsWith('/') ? normalizePath(specifier) : normalizePath(joinPath(parentPath(from), specifier));
+            const path = await this.#fileOrIndex(base);
+            if (!path)
+                return { kind: 'unresolved', specifier: raw };
+            const owner = await this.ownerOf(path);
+            return owner ? { kind: 'file', path, package: owner } : { kind: 'file', path };
+        }
+        const builtin = this.isBuiltin(specifier);
+        if (builtin !== undefined)
+            return { kind: 'builtin', name: builtin, specifier: raw };
+        if (/^[a-z][a-z0-9+.-]*:/i.test(specifier))
+            return { kind: 'builtin', name: specifier, specifier: raw };
+        if (specifier.startsWith('#')) {
+            const owner = await this.ownerOf(from);
+            const target = owner ? resolveSubpathMap(owner.imports, specifier, this.#conditions) : undefined;
+            if (!owner || target === null || target === undefined)
+                return { kind: 'unresolved', specifier: raw };
+            if (!target.startsWith('.'))
+                return this.resolve(from, target);
+            const path = normalizePath(joinPath(owner.dir, target));
+            return (await this.isFile(path)) ? { kind: 'file', path: await this.real(path), package: owner } : { kind: 'unresolved', specifier: raw };
+        }
+        const parts = specifier.split('/');
+        const name = specifier.startsWith('@') ? parts.slice(0, 2).join('/') : (parts[0] ?? specifier);
+        const rest = parts.slice(specifier.startsWith('@') ? 2 : 1).join('/');
+        const subpath = rest ? `./${rest}` : '.';
+        let directory = parentPath(from);
+        for (;;) {
+            const candidate = joinPath(joinPath(directory, 'node_modules'), name);
+            const found = await this.packageAt(candidate);
+            if (found) {
+                const dir = await this.real(candidate);
+                const info = dir === candidate ? found : ((await this.packageAt(dir)) ?? found);
+                const path = await this.#inPackage(info, subpath);
+                return path ? { kind: 'file', path, package: info } : { kind: 'unresolved', specifier: raw };
+            }
+            if (directory === '/')
+                return { kind: 'unresolved', specifier: raw };
+            directory = parentPath(directory);
+        }
+    }
+}
+/**
+ * Walk breadth-first from `entries`, so each file's recorded importer is on a shortest chain from
+ * an entry.
+ */
+export async function walkModuleGraph(resolver, files, entries) {
+    const reached = new Map();
+    const builtins = [];
+    const unresolved = [];
+    const edges = [];
+    const seenLeaves = new Set();
+    let frontier = [];
+    for (const entry of entries) {
+        const path = await resolver.real(normalizePath(entry));
+        const owner = await resolver.ownerOf(path);
+        frontier.push(owner ? { path, package: owner } : { path });
+    }
+    while (frontier.length > 0) {
+        const next = [];
+        for (const item of frontier) {
+            if (reached.has(item.path))
+                continue;
+            const text = await files.readText(item.path);
+            if (text === undefined)
+                continue;
+            const scanned = SCANNED.test(item.path) ? scanModule(text) : { specifiers: [], regions: [] };
+            let file = { path: item.path, bytes: utf8Bytes(text), regions: scanned.regions };
+            if (item.package)
+                file = { ...file, package: item.package };
+            if (item.importer)
+                file = { ...file, importer: item.importer };
+            if (item.specifier)
+                file = { ...file, specifier: item.specifier };
+            reached.set(item.path, file);
+            for (const { specifier, kind } of scanned.specifiers) {
+                const resolved = await resolver.resolve(item.path, specifier);
+                if (resolved.kind === 'file') {
+                    edges.push({ importer: item.path, specifier, path: resolved.path, kind });
+                    if (!reached.has(resolved.path)) {
+                        next.push(resolved.package ? { path: resolved.path, importer: item.path, specifier, package: resolved.package } : { path: resolved.path, importer: item.path, specifier });
+                    }
+                    continue;
+                }
+                const key = `${resolved.kind}:${specifier}:${item.path}`;
+                if (seenLeaves.has(key))
+                    continue;
+                seenLeaves.add(key);
+                const leaf = { specifier, name: resolved.kind === 'builtin' ? resolved.name : specifier, importer: item.path };
+                if (resolved.kind === 'builtin')
+                    builtins.push(leaf);
+                else
+                    unresolved.push(leaf);
+            }
+        }
+        frontier = next;
+    }
+    // Only a static edge makes a module part of the bundle the Worker instantiates;
+    // a loader thunk's implementation stays enumerable but is refused at resolution.
+    const staticByImporter = new Map();
+    for (const edge of edges) {
+        if (edge.kind !== 'static')
+            continue;
+        const list = staticByImporter.get(edge.importer) ?? [];
+        list.push(edge.path);
+        staticByImporter.set(edge.importer, list);
+    }
+    const staticReachable = new Set();
+    const staticFrontier = await Promise.all(entries.map((entry) => resolver.real(normalizePath(entry))));
+    while (staticFrontier.length > 0) {
+        const path = staticFrontier.pop();
+        if (path === undefined || staticReachable.has(path))
+            continue;
+        staticReachable.add(path);
+        for (const next of staticByImporter.get(path) ?? [])
+            staticFrontier.push(next);
+    }
+    return { files: reached, builtins, unresolved, edges, staticReachable };
+}
+/** The importing chain of `path`, entry first and `path` last. */
+export function chainOf(graph, path) {
+    const chain = [path];
+    const seen = new Set(chain);
+    let current = graph.files.get(path)?.importer;
+    while (current !== undefined && !seen.has(current)) {
+        chain.push(current);
+        seen.add(current);
+        current = graph.files.get(current)?.importer;
+    }
+    return chain.reverse();
+}
+//# sourceMappingURL=deployment-graph.js.map