browser-metro 1.0.5

package/dist/bundler.d.ts

@@ -0,0 +1,34 @@
+import { VirtualFS } from "./fs.js";
+import { BundlerConfig } from "./types.js";
+export declare class Bundler {
+    private fs;
+    private resolver;
+    private config;
+    private plugins;
+    constructor(fs: VirtualFS, config: BundlerConfig);
+    /** Read tsconfig.json "compilerOptions.paths" from the VirtualFS */
+    private static readTsconfigPaths;
+    /** Run the full pre-transform -> Sucrase -> post-transform pipeline */
+    private runTransform;
+    /** Build a resolve callback that consults plugins then falls back to default resolution */
+    private makeResolveTarget;
+    /** Collect module aliases from all plugins */
+    private getModuleAliases;
+    /** Collect module shims from all plugins */
+    private getShimModules;
+    /** Transform a single file using the configured transformer */
+    transformFile(filename: string, src: string): string;
+    /** Bundle starting from the entry file, returning executable code */
+    bundle(entryFile: string): Promise<string>;
+    /** Read dependency versions from the project's package.json */
+    private getPackageVersions;
+    /** Resolve an npm specifier to a versioned form using package.json versions.
+     *  Priority: user's package.json > transitive dep versions from manifests > bare name */
+    private resolveNpmSpecifier;
+    /** Fetch a pre-bundled npm package from the package server */
+    private fetchPackage;
+    /** Build the module map by walking the dependency graph */
+    private buildModuleMap;
+    /** Emit the final bundle string */
+    private emitBundle;
+}

package/dist/bundler.js

@@ -0,0 +1,320 @@
+import { Resolver } from "./resolver.js";
+import { buildCombinedSourceMap, countNewlines, inlineSourceMap, shiftSourceMapOrigLines, } from "./source-map.js";
+import { findRequires, rewriteRequires, buildBundlePreamble } from "./utils.js";
+export class Bundler {
+    constructor(fs, config) {
+        this.fs = fs;
+        this.config = config;
+        const paths = Bundler.readTsconfigPaths(fs);
+        this.resolver = new Resolver(fs, { ...config.resolver, ...(paths && { paths }) });
+        this.plugins = config.plugins ?? [];
+    }
+    /** Read tsconfig.json "compilerOptions.paths" from the VirtualFS */
+    static readTsconfigPaths(fs) {
+        const raw = fs.read("/tsconfig.json");
+        if (!raw)
+            return null;
+        try {
+            const tsconfig = JSON.parse(raw);
+            const paths = tsconfig?.compilerOptions?.paths;
+            return paths && typeof paths === "object" ? paths : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Run the full pre-transform -> Sucrase -> post-transform pipeline */
+    runTransform(filename, src) {
+        const originalLines = countNewlines(src);
+        // Pre-transform hooks
+        for (const plugin of this.plugins) {
+            if (plugin.transformSource) {
+                const result = plugin.transformSource({ src, filename });
+                if (result)
+                    src = result.src;
+            }
+        }
+        const preTransformAddedLines = countNewlines(src) - originalLines;
+        // Core transform (Sucrase)
+        const transformResult = this.config.transformer.transform({ src, filename });
+        let code = transformResult.code;
+        let sourceMap = transformResult.sourceMap;
+        // Post-transform hooks -- track line additions for source map offset
+        const linesBeforePost = countNewlines(code);
+        for (const plugin of this.plugins) {
+            if (plugin.transformOutput) {
+                const result = plugin.transformOutput({ code, filename });
+                if (result)
+                    code = result.code;
+            }
+        }
+        // Adjust source map for plugin modifications
+        if (sourceMap) {
+            // Post-transform: shift generated lines for prepended output lines
+            const postAddedLines = countNewlines(code) - linesBeforePost;
+            if (postAddedLines > 0) {
+                sourceMap = {
+                    ...sourceMap,
+                    mappings: ";".repeat(postAddedLines) + sourceMap.mappings,
+                };
+            }
+            // Pre-transform: shift origLine back so mappings point to original source
+            if (preTransformAddedLines > 0) {
+                sourceMap = shiftSourceMapOrigLines(sourceMap, -preTransformAddedLines);
+            }
+        }
+        return { code, sourceMap };
+    }
+    /** Build a resolve callback that consults plugins then falls back to default resolution */
+    makeResolveTarget(fromFile) {
+        return (target) => {
+            // Let plugins resolve first
+            for (const plugin of this.plugins) {
+                if (plugin.resolveRequest) {
+                    const result = plugin.resolveRequest({ fromFile }, target);
+                    if (result !== null)
+                        return result;
+                }
+            }
+            // Default resolution: skip npm packages, resolve local paths
+            if (this.resolver.isNpmPackage(target))
+                return null;
+            const resolved = this.resolver.resolvePath(fromFile, target);
+            const actual = this.resolver.resolveFile(resolved);
+            return actual ?? null;
+        };
+    }
+    /** Collect module aliases from all plugins */
+    getModuleAliases() {
+        const aliases = {};
+        for (const plugin of this.plugins) {
+            if (plugin.moduleAliases) {
+                Object.assign(aliases, plugin.moduleAliases());
+            }
+        }
+        return aliases;
+    }
+    /** Collect module shims from all plugins */
+    getShimModules() {
+        const shims = {};
+        for (const plugin of this.plugins) {
+            if (plugin.shimModules) {
+                Object.assign(shims, plugin.shimModules());
+            }
+        }
+        return shims;
+    }
+    /** Transform a single file using the configured transformer */
+    transformFile(filename, src) {
+        return this.runTransform(filename, src).code;
+    }
+    /** Bundle starting from the entry file, returning executable code */
+    async bundle(entryFile) {
+        const { moduleMap, sourceMapMap } = await this.buildModuleMap(entryFile);
+        return this.emitBundle(moduleMap, sourceMapMap, entryFile);
+    }
+    /** Read dependency versions from the project's package.json */
+    getPackageVersions() {
+        const raw = this.fs.read("/package.json");
+        if (!raw)
+            return {};
+        try {
+            const pkg = JSON.parse(raw);
+            return pkg.dependencies || {};
+        }
+        catch {
+            return {};
+        }
+    }
+    /** Resolve an npm specifier to a versioned form using package.json versions.
+     *  Priority: user's package.json > transitive dep versions from manifests > bare name */
+    resolveNpmSpecifier(specifier, versions, transitiveDepsVersions) {
+        // Extract base package name: "@scope/pkg/sub" -> "@scope/pkg", "lodash/fp" -> "lodash"
+        let baseName;
+        if (specifier.startsWith("@")) {
+            const parts = specifier.split("/");
+            baseName = parts[0] + "/" + parts[1];
+        }
+        else {
+            baseName = specifier.split("/")[0];
+        }
+        const version = versions[baseName] || (transitiveDepsVersions && transitiveDepsVersions[baseName]);
+        if (!version)
+            return specifier;
+        const subpath = specifier.slice(baseName.length); // e.g. "/client" or ""
+        return baseName + "@" + version + subpath;
+    }
+    /** Fetch a pre-bundled npm package from the package server */
+    async fetchPackage(specifier) {
+        const url = this.config.server.packageServerUrl + "/pkg/" + specifier;
+        const res = await fetch(url);
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            throw new Error("Failed to fetch package '" + specifier + "' (HTTP " + res.status + ")" + (body ? ": " + body.slice(0, 200) : ""));
+        }
+        const code = await res.text();
+        let externals = {};
+        const externalsHeader = res.headers.get("X-Externals");
+        if (externalsHeader) {
+            try {
+                externals = JSON.parse(externalsHeader);
+            }
+            catch { }
+        }
+        return { code, externals };
+    }
+    /** Build the module map by walking the dependency graph */
+    async buildModuleMap(entryFile) {
+        const moduleMap = {};
+        const sourceMapMap = {};
+        const visited = {};
+        const npmPackages = {};
+        const versions = this.getPackageVersions();
+        const transitiveDepsVersions = {};
+        const walk = async (filePath) => {
+            if (visited[filePath])
+                return;
+            visited[filePath] = true;
+            // Asset files get a stub module that exports the filename (or a real URL for external assets)
+            if (this.resolver.isAssetFile(filePath)) {
+                if (this.fs.isExternalAsset(filePath) && this.config.assetPublicPath) {
+                    const assetUrl = this.config.assetPublicPath + filePath;
+                    moduleMap[filePath] = "module.exports = { uri: " + JSON.stringify(assetUrl) + " };";
+                }
+                else {
+                    moduleMap[filePath] = "module.exports = " + JSON.stringify(filePath) + ";";
+                }
+                return;
+            }
+            const source = this.fs.read(filePath);
+            if (!source) {
+                throw new Error("File not found: " + filePath);
+            }
+            // Transform the file (TS -> JS, JSX -> JS, etc.)
+            const { code: transformed, sourceMap } = this.runTransform(filePath, source);
+            if (sourceMap)
+                sourceMapMap[filePath] = sourceMap;
+            const rewritten = rewriteRequires(transformed, filePath, this.makeResolveTarget(filePath));
+            moduleMap[filePath] = rewritten;
+            const deps = findRequires(rewritten);
+            for (let i = 0; i < deps.length; i++) {
+                const dep = deps[i];
+                if (this.resolver.isNpmPackage(dep)) {
+                    if (!npmPackages[dep]) {
+                        npmPackages[dep] = true;
+                    }
+                }
+                else {
+                    const resolved = this.resolver.resolveFile(dep);
+                    if (resolved) {
+                        await walk(resolved);
+                    }
+                }
+            }
+        };
+        await walk(entryFile);
+        // Process module aliases: swap sources for targets in the fetch list
+        const aliases = this.getModuleAliases();
+        for (const [from, to] of Object.entries(aliases)) {
+            delete npmPackages[from];
+            npmPackages[to] = true;
+        }
+        // Collect shims: these replace npm packages with inline code
+        const shims = this.getShimModules();
+        for (const name of Object.keys(shims)) {
+            delete npmPackages[name];
+        }
+        // Fetch npm packages in parallel, then resolve any transitive deps (subpath requires etc.)
+        const skipNames = new Set([...Object.keys(aliases), ...Object.keys(shims)]);
+        const knownNpm = new Set(Object.keys(npmPackages));
+        let toFetch = [...knownNpm];
+        while (toFetch.length > 0) {
+            const fetches = toFetch.map((name) => {
+                const versionedSpecifier = this.resolveNpmSpecifier(name, versions, transitiveDepsVersions);
+                return this.fetchPackage(versionedSpecifier).then(({ code, externals }) => {
+                    moduleMap[name] = code;
+                    // Merge externals into transitive versions (don't overwrite existing entries)
+                    for (const [dep, ver] of Object.entries(externals)) {
+                        if (!transitiveDepsVersions[dep]) {
+                            transitiveDepsVersions[dep] = ver;
+                        }
+                    }
+                });
+            });
+            await Promise.all(fetches);
+            // Discover any npm deps from fetched packages not yet known
+            toFetch = [];
+            for (const name of knownNpm) {
+                for (const dep of findRequires(moduleMap[name])) {
+                    if (this.resolver.isNpmPackage(dep) && !knownNpm.has(dep) && !skipNames.has(dep)) {
+                        knownNpm.add(dep);
+                        toFetch.push(dep);
+                    }
+                }
+            }
+        }
+        // Inject alias shim modules: require("react-native") → re-exports react-native-web
+        for (const [from, to] of Object.entries(aliases)) {
+            moduleMap[from] = 'module.exports = require("' + to + '");';
+        }
+        // Inject inline shim modules
+        for (const [name, code] of Object.entries(shims)) {
+            moduleMap[name] = code;
+        }
+        return { moduleMap, sourceMapMap };
+    }
+    /** Emit the final bundle string */
+    emitBundle(moduleMap, sourceMapMap, entryFile) {
+        const preamble = buildBundlePreamble(this.config.env, this.config.routerShim);
+        const runtimeStr = "(function(modules) {\n" +
+            "  var cache = {};\n" +
+            "  function require(id) {\n" +
+            "    if (cache[id]) return cache[id].exports;\n" +
+            "    if (!modules[id]) throw new Error('Module not found: ' + id);\n" +
+            "    var module = cache[id] = { exports: {} };\n" +
+            "    modules[id].call(module.exports, module, module.exports, require);\n" +
+            "    return module.exports;\n" +
+            "  }\n" +
+            "  require(" +
+            JSON.stringify(entryFile) +
+            ");\n" +
+            "})({\n";
+        const headerStr = preamble + runtimeStr;
+        const ids = Object.keys(moduleMap);
+        const moduleEntries = ids
+            .map((id) => {
+            return (JSON.stringify(id) +
+                ": function(module, exports, require) {\n" +
+                moduleMap[id] +
+                "\n}");
+        })
+            .join(",\n\n");
+        let bundle = headerStr + moduleEntries + "\n});\n";
+        // Build combined source map
+        let lineOffset = countNewlines(headerStr);
+        const inputs = [];
+        for (let i = 0; i < ids.length; i++) {
+            const id = ids[i];
+            if (i > 0)
+                lineOffset += 2; // ",\n\n"
+            lineOffset += 1; // wrapper function line
+            if (sourceMapMap[id]) {
+                const sourceContent = this.fs.read(id);
+                if (sourceContent) {
+                    inputs.push({
+                        sourceFile: id,
+                        sourceContent,
+                        map: sourceMapMap[id],
+                        generatedLineOffset: lineOffset,
+                    });
+                }
+            }
+            lineOffset += countNewlines(moduleMap[id]);
+            lineOffset += 1; // "\n}"
+        }
+        if (inputs.length > 0) {
+            bundle += inlineSourceMap(buildCombinedSourceMap(inputs)) + "\n";
+        }
+        return bundle;
+    }
+}

package/dist/dependency-graph.d.ts

@@ -0,0 +1,22 @@
+export declare class DependencyGraph {
+    /** Forward edges: module -> its dependencies */
+    private nodes;
+    /** Reverse edges: module -> modules that depend on it */
+    private reverseDeps;
+    /** Add or update a module's dependencies. Diffs against old deps to keep reverse edges in sync. */
+    setModule(id: string, localDeps: string[], npmDeps: string[]): void;
+    removeModule(id: string): void;
+    hasModule(id: string): boolean;
+    /** Get direct reverse dependencies (modules that import this one) */
+    getDependents(id: string): Set<string>;
+    /** Get all modules transitively affected by changes to the given set (BFS upward) */
+    getAffectedModules(ids: Set<string>): Set<string>;
+    /** Find modules unreachable from the entry file (BFS downward) */
+    findOrphans(entryFile: string): Set<string>;
+    /** Get the local deps of a module */
+    getLocalDeps(id: string): Set<string>;
+    /** Get the npm deps of a module */
+    getNpmDeps(id: string): Set<string>;
+    /** Get a serializable map of module -> its reverse deps (for embedding in HMR runtime) */
+    getReverseDepsMap(): Record<string, string[]>;
+}

package/dist/dependency-graph.js

@@ -0,0 +1,128 @@
+export class DependencyGraph {
+    constructor() {
+        /** Forward edges: module -> its dependencies */
+        this.nodes = new Map();
+        /** Reverse edges: module -> modules that depend on it */
+        this.reverseDeps = new Map();
+    }
+    /** Add or update a module's dependencies. Diffs against old deps to keep reverse edges in sync. */
+    setModule(id, localDeps, npmDeps) {
+        const newLocalSet = new Set(localDeps);
+        const newNpmSet = new Set(npmDeps);
+        const existing = this.nodes.get(id);
+        if (existing) {
+            // Remove stale reverse edges for local deps that are no longer referenced
+            for (const oldDep of existing.localDeps) {
+                if (!newLocalSet.has(oldDep)) {
+                    this.reverseDeps.get(oldDep)?.delete(id);
+                }
+            }
+            // Remove stale reverse edges for npm deps
+            for (const oldDep of existing.npmDeps) {
+                if (!newNpmSet.has(oldDep)) {
+                    this.reverseDeps.get(oldDep)?.delete(id);
+                }
+            }
+        }
+        // Add new reverse edges
+        for (const dep of newLocalSet) {
+            if (!this.reverseDeps.has(dep)) {
+                this.reverseDeps.set(dep, new Set());
+            }
+            this.reverseDeps.get(dep).add(id);
+        }
+        for (const dep of newNpmSet) {
+            if (!this.reverseDeps.has(dep)) {
+                this.reverseDeps.set(dep, new Set());
+            }
+            this.reverseDeps.get(dep).add(id);
+        }
+        this.nodes.set(id, { localDeps: newLocalSet, npmDeps: newNpmSet });
+    }
+    removeModule(id) {
+        const node = this.nodes.get(id);
+        if (!node)
+            return;
+        // Remove forward edges from reverse map
+        for (const dep of node.localDeps) {
+            this.reverseDeps.get(dep)?.delete(id);
+        }
+        for (const dep of node.npmDeps) {
+            this.reverseDeps.get(dep)?.delete(id);
+        }
+        // Remove reverse edges pointing to this module
+        this.reverseDeps.delete(id);
+        this.nodes.delete(id);
+    }
+    hasModule(id) {
+        return this.nodes.has(id);
+    }
+    /** Get direct reverse dependencies (modules that import this one) */
+    getDependents(id) {
+        return this.reverseDeps.get(id) ?? new Set();
+    }
+    /** Get all modules transitively affected by changes to the given set (BFS upward) */
+    getAffectedModules(ids) {
+        const affected = new Set();
+        const queue = [...ids];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (affected.has(current))
+                continue;
+            affected.add(current);
+            const dependents = this.reverseDeps.get(current);
+            if (dependents) {
+                for (const dep of dependents) {
+                    if (!affected.has(dep)) {
+                        queue.push(dep);
+                    }
+                }
+            }
+        }
+        return affected;
+    }
+    /** Find modules unreachable from the entry file (BFS downward) */
+    findOrphans(entryFile) {
+        const reachable = new Set();
+        const queue = [entryFile];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (reachable.has(current))
+                continue;
+            reachable.add(current);
+            const node = this.nodes.get(current);
+            if (node) {
+                for (const dep of node.localDeps) {
+                    if (!reachable.has(dep)) {
+                        queue.push(dep);
+                    }
+                }
+            }
+        }
+        const orphans = new Set();
+        for (const id of this.nodes.keys()) {
+            if (!reachable.has(id)) {
+                orphans.add(id);
+            }
+        }
+        return orphans;
+    }
+    /** Get the local deps of a module */
+    getLocalDeps(id) {
+        return this.nodes.get(id)?.localDeps ?? new Set();
+    }
+    /** Get the npm deps of a module */
+    getNpmDeps(id) {
+        return this.nodes.get(id)?.npmDeps ?? new Set();
+    }
+    /** Get a serializable map of module -> its reverse deps (for embedding in HMR runtime) */
+    getReverseDepsMap() {
+        const result = {};
+        for (const [id, deps] of this.reverseDeps) {
+            if (deps.size > 0) {
+                result[id] = [...deps];
+            }
+        }
+        return result;
+    }
+}

package/dist/fs.d.ts

@@ -0,0 +1,20 @@
+import { FileMap, FileChange } from "./types.js";
+export declare class VirtualFS {
+    private files;
+    constructor(files: FileMap);
+    read(path: string): string | undefined;
+    write(path: string, content: string): void;
+    delete(path: string): boolean;
+    exists(path: string): boolean;
+    /** Check if a file is an external asset (binary file served from public/) */
+    isExternalAsset(path: string): boolean;
+    list(): string[];
+    getEntryFile(): string | null;
+    /** Read the "main" field from package.json, if present */
+    getPackageMain(): string | null;
+    toFileMap(): FileMap;
+    /** Compare current state against an incoming FileMap, return list of changes */
+    diff(newFiles: FileMap): FileChange[];
+    /** Replace all files at once */
+    replaceAll(files: FileMap): void;
+}

package/dist/fs.js

@@ -0,0 +1,107 @@
+export class VirtualFS {
+    constructor(files) {
+        this.files = { ...files };
+    }
+    read(path) {
+        const entry = this.files[path];
+        if (entry === undefined)
+            return undefined;
+        return entry.content;
+    }
+    write(path, content) {
+        this.files[path] = { content, isExternal: false };
+    }
+    delete(path) {
+        if (path in this.files) {
+            delete this.files[path];
+            return true;
+        }
+        return false;
+    }
+    exists(path) {
+        return path in this.files;
+    }
+    /** Check if a file is an external asset (binary file served from public/) */
+    isExternalAsset(path) {
+        const entry = this.files[path];
+        return entry !== undefined && entry.isExternal === true;
+    }
+    list() {
+        return Object.keys(this.files);
+    }
+    getEntryFile() {
+        // Try common entry points
+        const candidates = [
+            "/index.js",
+            "/index.ts",
+            "/index.tsx",
+            "/index.jsx",
+            "/App.js",
+            "/App.ts",
+            "/App.tsx",
+            "/App.jsx",
+        ];
+        for (const c of candidates) {
+            if (this.exists(c))
+                return c;
+        }
+        // Check package.json "main" field for local entry
+        const pkgJson = this.read("/package.json");
+        if (pkgJson) {
+            try {
+                const pkg = JSON.parse(pkgJson);
+                if (typeof pkg.main === "string" && (pkg.main.startsWith(".") || pkg.main.startsWith("/"))) {
+                    const base = pkg.main.replace(/^\.\//, "/").replace(/^([^/])/, "/$1");
+                    if (this.exists(base))
+                        return base;
+                    for (const ext of [".js", ".ts", ".tsx", ".jsx"]) {
+                        if (this.exists(base + ext))
+                            return base + ext;
+                    }
+                }
+            }
+            catch { }
+        }
+        return null;
+    }
+    /** Read the "main" field from package.json, if present */
+    getPackageMain() {
+        const pkgJson = this.read("/package.json");
+        if (!pkgJson)
+            return null;
+        try {
+            const pkg = JSON.parse(pkgJson);
+            return typeof pkg.main === "string" ? pkg.main : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    toFileMap() {
+        return { ...this.files };
+    }
+    /** Compare current state against an incoming FileMap, return list of changes */
+    diff(newFiles) {
+        const changes = [];
+        // Check for creates and updates
+        for (const path in newFiles) {
+            if (!(path in this.files)) {
+                changes.push({ path, type: "create" });
+            }
+            else if (this.files[path].content !== newFiles[path].content) {
+                changes.push({ path, type: "update" });
+            }
+        }
+        // Check for deletes
+        for (const path in this.files) {
+            if (!(path in newFiles)) {
+                changes.push({ path, type: "delete" });
+            }
+        }
+        return changes;
+    }
+    /** Replace all files at once */
+    replaceAll(files) {
+        this.files = { ...files };
+    }
+}

package/dist/hmr-runtime.d.ts

@@ -0,0 +1,14 @@
+/**
+ * HMR-capable bundle runtime template.
+ *
+ * Called at emit time as an IIFE with:
+ *   modules       - the module map object
+ *   reverseDeps   - JSON reverse dependency map
+ *   entryId       - entry file path string
+ *   reactRefreshEnabled - boolean
+ */
+export declare const HMR_RUNTIME_TEMPLATE = "(function(modules, reverseDeps, entryId, reactRefreshEnabled) {\n  var cache = {};\n  var hotState = {};\n\n  function initHot(id) {\n    if (hotState[id]) return hotState[id];\n    var state = {\n      acceptCallbacks: [],\n      disposeCallbacks: [],\n      data: {},\n      declined: false,\n      accepted: false\n    };\n    hotState[id] = state;\n    return state;\n  }\n\n  function createHotAPI(id) {\n    var state = initHot(id);\n    return {\n      accept: function(cb) {\n        state.accepted = true;\n        if (cb) state.acceptCallbacks.push(cb);\n      },\n      dispose: function(cb) {\n        if (cb) state.disposeCallbacks.push(cb);\n      },\n      decline: function() {\n        state.declined = true;\n      },\n      get data() {\n        return state.data;\n      }\n    };\n  }\n\n  function require(id) {\n    if (cache[id]) return cache[id].exports;\n    if (!modules[id]) throw new Error('Module not found: ' + id);\n    var module = cache[id] = { exports: {}, hot: createHotAPI(id) };\n    modules[id].call(module.exports, module, module.exports, require);\n    return module.exports;\n  }\n\n  // Walk reverse deps to find nearest module.hot.accept() boundary\n  function findAcceptBoundary(changedId) {\n    var visited = {};\n    var queue = [changedId];\n    var boundaries = [];\n\n    while (queue.length > 0) {\n      var current = queue.shift();\n      if (visited[current]) continue;\n      visited[current] = true;\n\n      var state = hotState[current];\n      if (state && state.declined) {\n        return null;\n      }\n      if (state && state.accepted) {\n        boundaries.push(current);\n        continue;\n      }\n      // Walk upward through reverse deps\n      var parents = reverseDeps[current];\n      if (!parents || parents.length === 0) {\n        return null;\n      }\n      for (var i = 0; i < parents.length; i++) {\n        queue.push(parents[i]);\n      }\n    }\n\n    return boundaries.length > 0 ? boundaries : null;\n  }\n\n  function applyUpdate(updatedModules, removedModules, newReverseDeps) {\n    // Merge updated reverse deps so boundary walk sees new modules\n    if (newReverseDeps) {\n      for (var key in newReverseDeps) {\n        reverseDeps[key] = newReverseDeps[key];\n      }\n    }\n\n    // Phase 1: Check boundaries FIRST, before any state mutation.\n    // The dispose phase used to reset accepted=false here, which wiped\n    // out the accept registrations before the boundary walk could see them.\n    var needsReload = false;\n    var modulesToReExecute = new Set();\n\n    for (var uid in updatedModules) {\n      var boundaries = findAcceptBoundary(uid);\n      if (!boundaries) {\n        needsReload = true;\n        break;\n      }\n      for (var b = 0; b < boundaries.length; b++) {\n        modulesToReExecute.add(boundaries[b]);\n      }\n      modulesToReExecute.add(uid);\n    }\n\n    if (needsReload) {\n      console.warn('[HMR] No accept boundary found, requesting full reload');\n      window.parent.postMessage({ type: 'hmr-full-reload' }, '*');\n      return;\n    }\n\n    // Phase 2: Run dispose callbacks and reset state for modules about to be re-executed\n    modulesToReExecute.forEach(function(id) {\n      var state = hotState[id];\n      if (state) {\n        var newData = {};\n        for (var i = 0; i < state.disposeCallbacks.length; i++) {\n          state.disposeCallbacks[i](newData);\n        }\n        state.data = newData;\n        state.disposeCallbacks = [];\n        state.acceptCallbacks = [];\n        state.accepted = false;\n      }\n    });\n\n    // Phase 3: Update module factories\n    for (var mid in updatedModules) {\n      modules[mid] = new Function('module', 'exports', 'require', updatedModules[mid]);\n    }\n\n    // Phase 4: Remove deleted modules\n    for (var r = 0; r < removedModules.length; r++) {\n      var rmId = removedModules[r];\n      delete modules[rmId];\n      delete cache[rmId];\n      delete hotState[rmId];\n    }\n\n    // Phase 5: Re-execute modules. Clear ALL caches first so that nested\n    // require() calls during re-execution pick up the new factories rather\n    // than stale cached exports (e.g. entry requiring a dependency that\n    // hasn't been re-executed yet in this loop).\n    modulesToReExecute.forEach(function(execId) {\n      delete cache[execId];\n    });\n    modulesToReExecute.forEach(function(execId) {\n      try {\n        require(execId);\n      } catch(err) {\n        console.error('[HMR] Error re-executing module ' + execId + ':', err);\n        window.parent.postMessage({ type: 'hmr-full-reload' }, '*');\n      }\n    });\n\n    // Phase 6: React Refresh -- tell React to re-render with new component definitions\n    if (reactRefreshEnabled && window.__REACT_REFRESH_RUNTIME__) {\n      try {\n        window.__REACT_REFRESH_RUNTIME__.performReactRefresh();\n      } catch(err) {\n        console.error('[HMR] React Refresh error:', err);\n      }\n    }\n\n    console.log('[HMR] Updated ' + Object.keys(updatedModules).length + ' module(s)');\n  }\n\n  // Expose HMR API globally\n  window.__BUNDLER_HMR__ = {\n    applyUpdate: applyUpdate,\n    modules: modules,\n    cache: cache,\n    hotState: hotState\n  };\n\n  // Listen for HMR updates from parent window\n  window.addEventListener('message', function(e) {\n    var data = e.data;\n    if (data && data.type === 'hmr-update') {\n      applyUpdate(data.updatedModules || {}, data.removedModules || [], data.reverseDepsMap);\n    }\n  });\n\n  // Initialize React Refresh runtime BEFORE executing the entry module,\n  // so $RefreshReg$ and $RefreshSig$ are available when component modules load.\n  if (reactRefreshEnabled) {\n    try {\n      var RefreshRuntime = require('react-refresh/runtime');\n      RefreshRuntime.injectIntoGlobalHook(window);\n      window.__REACT_REFRESH_RUNTIME__ = RefreshRuntime;\n      window.$RefreshReg$ = function() {};\n      window.$RefreshSig$ = function() { return function(type) { return type; }; };\n    } catch(e) {\n      console.warn('[HMR] React Refresh runtime not available:', e.message || e);\n    }\n  }\n\n  // Execute entry module\n  require(entryId);\n})";
+/**
+ * Emit an HMR-capable bundle string.
+ */
+export declare function emitHmrBundle(moduleMap: Record<string, string>, entryFile: string, reverseDepsMap: Record<string, string[]>, reactRefresh: boolean, env?: Record<string, string>, routerShim?: boolean): string;