@atlaspack/runtime-browser-hmr 2.14.5-canary.49 → 2.14.5-canary.490

package/dist/loaders/hmr-runtime.js

@@ -0,0 +1,616 @@
+"use strict";
+/* global HMR_HOST, HMR_PORT, HMR_ENV_HASH, HMR_SECURE, HMR_USE_SSE, chrome, browser, __parcel__import__, __parcel__importScripts__, ServiceWorkerGlobalScope, HMR_ENABLE_BUNDLE_VERSION */
+Object.defineProperty(exports, "__esModule", { value: true });
+// /flow-to-ts helpers
+var OVERLAY_ID = '__parcel__error__overlay__';
+var HMR_BUNDLE_VERSION = '__parcel__hmrBundleVersion';
+// @ts-expect-error TS2339
+var OldModule = module.bundle.Module;
+function Module(moduleName) {
+    // @ts-expect-error TS2683
+    OldModule.call(this, moduleName);
+    // @ts-expect-error TS2683
+    this.hot = {
+        // @ts-expect-error TS2339
+        data: module.bundle.hotData[moduleName],
+        _acceptCallbacks: [],
+        _disposeCallbacks: [],
+        // @ts-expect-error TS7006
+        accept: function (fn) {
+            this._acceptCallbacks.push(fn || function () { });
+        },
+        // @ts-expect-error TS7006
+        dispose: function (fn) {
+            this._disposeCallbacks.push(fn);
+        },
+    };
+    // @ts-expect-error TS2339
+    module.bundle.hotData[moduleName] = undefined;
+}
+// @ts-expect-error TS2339
+module.bundle.Module = Module;
+// @ts-expect-error TS2339
+module.bundle.hotData = {};
+// @ts-expect-error TS7034
+var checkedAssets /*: {|[string]: boolean|} */, 
+// @ts-expect-error TS7034
+disposedAssets /*: {|[string]: boolean|} */, 
+// @ts-expect-error TS7034
+assetsToDispose /*: Array<[ParcelRequire, string]> */, 
+// @ts-expect-error TS7034
+assetsToAccept /*: Array<[ParcelRequire, string]> */;
+function getBundleVersion() {
+    // @ts-expect-error TS7017
+    return globalThis[HMR_BUNDLE_VERSION];
+}
+function bumpBundleVersion() {
+    // @ts-expect-error TS2304
+    if (!HMR_ENABLE_BUNDLE_VERSION) {
+        return;
+    }
+    let version = getBundleVersion();
+    let nextVersion = typeof version === 'number' && Number.isFinite(version) ? version + 1 : 1;
+    // @ts-expect-error TS7017
+    globalThis[HMR_BUNDLE_VERSION] = nextVersion;
+    return nextVersion;
+}
+function appendBundleVersion(url) {
+    // @ts-expect-error TS2304
+    if (!HMR_ENABLE_BUNDLE_VERSION) {
+        return url + (url.includes('?') ? '&' : '?') + 't=' + Date.now();
+    }
+    let version = getBundleVersion();
+    if (version == null) {
+        return url;
+    }
+    return url + (url.includes('?') ? '&' : '?') + 't=' + version;
+}
+function getHostname() {
+    return (
+    // @ts-expect-error TS2304
+    HMR_HOST ||
+        (location.protocol.indexOf('http') === 0 ? location.hostname : 'localhost'));
+}
+function getPort() {
+    // @ts-expect-error TS2304
+    return HMR_PORT || location.port;
+}
+// eslint-disable-next-line no-redeclare
+// @ts-expect-error TS2339
+var parent = module.bundle.parent;
+if ((!parent || !parent.isParcelRequire) && typeof WebSocket !== 'undefined') {
+    var hostname = getHostname();
+    var port = getPort();
+    var protocol = 
+    // @ts-expect-error TS2304
+    HMR_SECURE ||
+        (location.protocol == 'https:' &&
+            !['localhost', '127.0.0.1', '0.0.0.0'].includes(hostname))
+        ? 'wss'
+        : 'ws';
+    var ws;
+    // @ts-expect-error TS2304
+    if (HMR_USE_SSE) {
+        ws = new EventSource('/__parcel_hmr');
+    }
+    else {
+        try {
+            ws = new WebSocket(protocol + '://' + hostname + (port ? ':' + port : '') + '/');
+        }
+        catch (err) {
+            if (err.message) {
+                console.error(err.message);
+            }
+            ws = {};
+        }
+    }
+    // Web extension context
+    var extCtx = 
+    // @ts-expect-error TS2304
+    typeof browser === 'undefined'
+        ? // @ts-expect-error TS2304
+            typeof chrome === 'undefined'
+                ? null
+                : // @ts-expect-error TS2304
+                    chrome
+        : // @ts-expect-error TS2304
+            browser;
+    // Safari doesn't support sourceURL in error stacks.
+    // eval may also be disabled via CSP, so do a quick check.
+    var supportsSourceURL = false;
+    try {
+        (0, eval)('throw new Error("test"); //# sourceURL=test.js');
+    }
+    catch (err) {
+        supportsSourceURL = err.stack.includes('test.js');
+    }
+    // @ts-expect-error TS2339
+    ws.onmessage = async function (event /*: {data: string, ...} */) {
+        checkedAssets = {} /*: {|[string]: boolean|} */;
+        disposedAssets = {} /*: {|[string]: boolean|} */;
+        assetsToAccept = [];
+        assetsToDispose = [];
+        var data /*: HMRMessage */ = JSON.parse(event.data);
+        if (data.type === 'reload') {
+            fullReload();
+        }
+        else if (data.type === 'update') {
+            // Remove error overlay if there is one
+            if (typeof document !== 'undefined') {
+                removeErrorOverlay();
+            }
+            let assets = data.assets.filter(
+            // @ts-expect-error TS7006
+            (asset) => asset.envHash === HMR_ENV_HASH);
+            // Handle HMR Update
+            // @ts-expect-error TS7006
+            let handled = assets.every((asset) => {
+                return (asset.type === 'css' ||
+                    (asset.type === 'js' &&
+                        // @ts-expect-error TS2339
+                        hmrAcceptCheck(module.bundle.root, asset.id, asset.depsByBundle)));
+            });
+            if (handled) {
+                bumpBundleVersion();
+                console.clear();
+                // Dispatch custom event so other runtimes (e.g React Refresh) are aware.
+                if (typeof window !== 'undefined' &&
+                    typeof CustomEvent !== 'undefined') {
+                    window.dispatchEvent(new CustomEvent('parcelhmraccept'));
+                }
+                await hmrApplyUpdates(assets);
+                hmrDisposeQueue();
+                // Run accept callbacks. This will also re-execute other disposed assets in topological order.
+                let processedAssets = {};
+                for (let i = 0; i < assetsToAccept.length; i++) {
+                    // @ts-expect-error TS7005
+                    let id = assetsToAccept[i][1];
+                    if (!processedAssets[id]) {
+                        // @ts-expect-error TS7005
+                        hmrAccept(assetsToAccept[i][0], id);
+                        processedAssets[id] = true;
+                    }
+                }
+            }
+            else
+                fullReload();
+        }
+        if (data.type === 'error') {
+            // Log parcel errors to console
+            for (let ansiDiagnostic of data.diagnostics.ansi) {
+                let stack = ansiDiagnostic.codeframe
+                    ? ansiDiagnostic.codeframe
+                    : ansiDiagnostic.stack;
+                console.error('🚨 [parcel]: ' +
+                    ansiDiagnostic.message +
+                    '\n' +
+                    stack +
+                    '\n\n' +
+                    ansiDiagnostic.hints.join('\n'));
+            }
+            if (typeof document !== 'undefined') {
+                // Render the fancy html overlay
+                removeErrorOverlay();
+                var overlay = createErrorOverlay(data.diagnostics.html);
+                document.body.appendChild(overlay);
+            }
+        }
+    };
+    if (ws instanceof WebSocket) {
+        ws.onerror = function (e) {
+            if (e.message) {
+                console.error(e.message);
+            }
+        };
+        ws.onclose = function (e) {
+            if (process.env.ATLASPACK_BUILD_ENV !== 'test') {
+                console.warn('[parcel] 🚨 Connection to the HMR server was lost');
+            }
+        };
+    }
+}
+function removeErrorOverlay() {
+    var overlay = document.getElementById(OVERLAY_ID);
+    if (overlay) {
+        overlay.remove();
+        console.log('[parcel] ✨ Error resolved');
+    }
+}
+function createErrorOverlay(diagnostics) {
+    var overlay = document.createElement('div');
+    overlay.id = OVERLAY_ID;
+    let errorHTML = '<div style="background: black; opacity: 0.85; font-size: 16px; color: white; position: fixed; height: 100%; width: 100%; top: 0px; left: 0px; padding: 30px; font-family: Menlo, Consolas, monospace; z-index: 9999;">';
+    for (let diagnostic of diagnostics) {
+        let stack = diagnostic.frames.length
+            ? // @ts-expect-error TS7006
+                diagnostic.frames.reduce((p, frame) => {
+                    return `${p}
+<a href="/__parcel_launch_editor?file=${encodeURIComponent(frame.location)}" style="text-decoration: underline; color: #888" onclick="fetch(this.href); return false">${frame.location}</a>
+${frame.code}`;
+                }, '')
+            : diagnostic.stack;
+        errorHTML += `
+      <div>
+        <div style="font-size: 18px; font-weight: bold; margin-top: 20px;">
+          🚨 ${diagnostic.message}
+        </div>
+        <pre>${stack}</pre>
+        <div>
+          ${diagnostic.hints
+            // @ts-expect-error TS7006
+            .map((hint) => '<div>💡 ' + hint + '</div>')
+            .join('')}
+        </div>
+        ${diagnostic.documentation
+            ? `<div>📝 <a style="color: violet" href="${diagnostic.documentation}" target="_blank">Learn more</a></div>`
+            : ''}
+      </div>
+    `;
+    }
+    errorHTML += '</div>';
+    overlay.innerHTML = errorHTML;
+    return overlay;
+}
+function fullReload() {
+    if ('reload' in location) {
+        location.reload();
+    }
+    else if (extCtx && extCtx.runtime && extCtx.runtime.reload) {
+        extCtx.runtime.reload();
+    }
+}
+function getParents(
+// @ts-expect-error TS2304
+bundle, id) {
+    var modules = bundle.modules;
+    if (!modules) {
+        return [];
+    }
+    // @ts-expect-error TS2304
+    var parents = [];
+    var k, d, dep;
+    for (k in modules) {
+        for (d in modules[k][1]) {
+            dep = modules[k][1][d];
+            if (dep === id || (Array.isArray(dep) && dep[dep.length - 1] === id)) {
+                parents.push([bundle, k]);
+            }
+        }
+    }
+    if (bundle.parent) {
+        parents = parents.concat(getParents(bundle.parent, id));
+    }
+    return parents;
+}
+function updateLink(link) {
+    var href = link.getAttribute('href');
+    if (!href) {
+        return;
+    }
+    var newLink = link.cloneNode();
+    // @ts-expect-error TS2345
+    newLink.onload = function () {
+        if (link.parentNode !== null) {
+            link.parentNode.removeChild(link);
+        }
+    };
+    // @ts-expect-error TS2339
+    newLink.setAttribute('href', appendBundleVersion(href));
+    // @ts-expect-error TS18047
+    link.parentNode.insertBefore(newLink, link.nextSibling);
+}
+// @ts-expect-error TS7034
+var cssTimeout = null;
+function reloadCSS() {
+    // @ts-expect-error TS7005
+    if (cssTimeout) {
+        return;
+    }
+    cssTimeout = setTimeout(function () {
+        var document = window.document;
+        var links = document.querySelectorAll('link[rel="stylesheet"]');
+        for (var i = 0; i < links.length; i++) {
+            var href /*: string */ = links[i].getAttribute('href');
+            var hostname = getHostname();
+            var servedFromHMRServer = hostname === 'localhost'
+                ? new RegExp('^(https?:\\/\\/(0.0.0.0|127.0.0.1)|localhost):' + getPort()).test(href)
+                : // @ts-expect-error TS2345
+                    href.indexOf(hostname + ':' + getPort());
+            var absolute = 
+            // @ts-expect-error TS2345
+            /^https?:\/\//i.test(href) &&
+                // @ts-expect-error TS18047
+                href.indexOf(location.origin) !== 0 &&
+                !servedFromHMRServer;
+            if (!absolute) {
+                // @ts-expect-error TS2345
+                updateLink(links[i]);
+            }
+        }
+        cssTimeout = null;
+    }, 50);
+}
+// @ts-expect-error TS2304
+function hmrDownload(asset) {
+    if (asset.type === 'js') {
+        if (typeof document !== 'undefined') {
+            let script = document.createElement('script');
+            script.src = appendBundleVersion(asset.url);
+            if (asset.outputFormat === 'esmodule') {
+                script.type = 'module';
+            }
+            return new Promise((resolve, reject) => {
+                script.onload = () => resolve(script);
+                script.onerror = reject;
+                document.head?.appendChild(script);
+            });
+            // @ts-expect-error TS2304
+        }
+        else if (typeof importScripts === 'function') {
+            // Worker scripts
+            if (asset.outputFormat === 'esmodule') {
+                // @ts-expect-error TS2304
+                return __parcel__import__(appendBundleVersion(asset.url));
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    try {
+                        // @ts-expect-error TS2304
+                        __parcel__importScripts__(appendBundleVersion(asset.url));
+                        // @ts-expect-error TS2794
+                        resolve();
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                });
+            }
+        }
+    }
+}
+// @ts-expect-error TS2304
+async function hmrApplyUpdates(assets) {
+    // @ts-expect-error TS7017
+    global.parcelHotUpdate = Object.create(null);
+    let scriptsToRemove;
+    try {
+        // If sourceURL comments aren't supported in eval, we need to load
+        // the update from the dev server over HTTP so that stack traces
+        // are correct in errors/logs. This is much slower than eval, so
+        // we only do it if needed (currently just Safari).
+        // https://bugs.webkit.org/show_bug.cgi?id=137297
+        // This path is also taken if a CSP disallows eval.
+        if (!supportsSourceURL) {
+            let promises = assets.map((asset) => hmrDownload(asset)?.catch((err) => {
+                // Web extension fix
+                if (extCtx &&
+                    extCtx.runtime &&
+                    extCtx.runtime.getManifest().manifest_version == 3 &&
+                    // @ts-expect-error TS2304
+                    typeof ServiceWorkerGlobalScope != 'undefined' &&
+                    // @ts-expect-error TS2304
+                    global instanceof ServiceWorkerGlobalScope) {
+                    extCtx.runtime.reload();
+                    return;
+                }
+                throw err;
+            }));
+            scriptsToRemove = await Promise.all(promises);
+        }
+        assets.forEach(function (asset) {
+            // @ts-expect-error TS2339
+            hmrApply(module.bundle.root, asset);
+        });
+    }
+    finally {
+        // @ts-expect-error TS7017
+        delete global.parcelHotUpdate;
+        if (scriptsToRemove) {
+            // @ts-expect-error TS7006
+            scriptsToRemove.forEach((script) => {
+                if (script) {
+                    document.head?.removeChild(script);
+                }
+            });
+        }
+    }
+}
+function hmrApply(
+// @ts-expect-error TS2304
+bundle /*: ParcelRequire */, 
+// @ts-expect-error TS2304
+asset /*:  HMRAsset */) {
+    var modules = bundle.modules;
+    if (!modules) {
+        return;
+    }
+    if (asset.type === 'css') {
+        reloadCSS();
+    }
+    else if (asset.type === 'js') {
+        let deps = asset.depsByBundle[bundle.HMR_BUNDLE_ID];
+        if (deps) {
+            if (modules[asset.id]) {
+                // Remove dependencies that are removed and will become orphaned.
+                // This is necessary so that if the asset is added back again, the cache is gone, and we prevent a full page reload.
+                let oldDeps = modules[asset.id][1];
+                for (let dep in oldDeps) {
+                    if (!deps[dep] || deps[dep] !== oldDeps[dep]) {
+                        let id = oldDeps[dep];
+                        // @ts-expect-error TS2339
+                        let parents = getParents(module.bundle.root, id);
+                        if (parents.length === 1) {
+                            // @ts-expect-error TS2339
+                            hmrDelete(module.bundle.root, id);
+                        }
+                    }
+                }
+            }
+            if (supportsSourceURL) {
+                // Global eval. We would use `new Function` here but browser
+                // support for source maps is better with eval.
+                (0, eval)(asset.output);
+            }
+            // @ts-expect-error TS7017
+            let fn = global.parcelHotUpdate[asset.id];
+            modules[asset.id] = [fn, deps];
+        }
+        // Always traverse to the parent bundle, even if we already replaced the asset in this bundle.
+        // This is required in case modules are duplicated. We need to ensure all instances have the updated code.
+        if (bundle.parent) {
+            hmrApply(bundle.parent, asset);
+        }
+    }
+}
+// @ts-expect-error TS2304
+function hmrDelete(bundle, id) {
+    let modules = bundle.modules;
+    if (!modules) {
+        return;
+    }
+    if (modules[id]) {
+        // Collect dependencies that will become orphaned when this module is deleted.
+        let deps = modules[id][1];
+        let orphans = [];
+        for (let dep in deps) {
+            // @ts-expect-error TS2339
+            let parents = getParents(module.bundle.root, deps[dep]);
+            if (parents.length === 1) {
+                orphans.push(deps[dep]);
+            }
+        }
+        // Delete the module. This must be done before deleting dependencies in case of circular dependencies.
+        delete modules[id];
+        delete bundle.cache[id];
+        // Now delete the orphans.
+        orphans.forEach((id) => {
+            // @ts-expect-error TS2339
+            hmrDelete(module.bundle.root, id);
+        });
+    }
+    else if (bundle.parent) {
+        hmrDelete(bundle.parent, id);
+    }
+}
+function hmrAcceptCheck(
+// @ts-expect-error TS2304
+bundle /*: ParcelRequire */, id /*: string */, depsByBundle /*: ?{ [string]: { [string]: string } }*/) {
+    if (hmrAcceptCheckOne(bundle, id, depsByBundle)) {
+        return true;
+    }
+    // Traverse parents breadth first. All possible ancestries must accept the HMR update, or we'll reload.
+    // @ts-expect-error TS2339
+    let parents = getParents(module.bundle.root, id);
+    let accepted = false;
+    while (parents.length > 0) {
+        let v = parents.shift();
+        // @ts-expect-error TS18048
+        let a = hmrAcceptCheckOne(v[0], v[1], null);
+        if (a) {
+            // If this parent accepts, stop traversing upward, but still consider siblings.
+            accepted = true;
+        }
+        else {
+            // Otherwise, queue the parents in the next level upward.
+            // @ts-expect-error TS2339
+            let p = getParents(module.bundle.root, v[1]);
+            if (p.length === 0) {
+                // If there are no parents, then we've reached an entry without accepting. Reload.
+                accepted = false;
+                break;
+            }
+            parents.push(...p);
+        }
+    }
+    return accepted;
+}
+function hmrAcceptCheckOne(
+// @ts-expect-error TS2304
+bundle /*: ParcelRequire */, id /*: string */, depsByBundle /*: ?{ [string]: { [string]: string } }*/) {
+    var modules = bundle.modules;
+    if (!modules) {
+        return;
+    }
+    if (depsByBundle && !depsByBundle[bundle.HMR_BUNDLE_ID]) {
+        // If we reached the root bundle without finding where the asset should go,
+        // there's nothing to do. Mark as "accepted" so we don't reload the page.
+        if (!bundle.parent) {
+            return true;
+        }
+        return hmrAcceptCheck(bundle.parent, id, depsByBundle);
+    }
+    // @ts-expect-error TS7005
+    if (checkedAssets[id]) {
+        return true;
+    }
+    // @ts-expect-error TS7005
+    checkedAssets[id] = true;
+    var cached = bundle.cache[id];
+    assetsToDispose.push([bundle, id]);
+    if (!cached || (cached.hot && cached.hot._acceptCallbacks.length)) {
+        assetsToAccept.push([bundle, id]);
+        return true;
+    }
+}
+function hmrDisposeQueue() {
+    // Dispose all old assets.
+    for (let i = 0; i < assetsToDispose.length; i++) {
+        // @ts-expect-error TS7005
+        let id = assetsToDispose[i][1];
+        // @ts-expect-error TS7005
+        if (!disposedAssets[id]) {
+            // @ts-expect-error TS7005
+            hmrDispose(assetsToDispose[i][0], id);
+            disposedAssets[id] = true;
+        }
+    }
+    assetsToDispose = [];
+}
+function hmrDispose(
+// @ts-expect-error TS2304
+bundle /*: ParcelRequire */, id /*: string */) {
+    var cached = bundle.cache[id];
+    bundle.hotData[id] = {};
+    if (cached && cached.hot) {
+        cached.hot.data = bundle.hotData[id];
+    }
+    if (cached && cached.hot && cached.hot._disposeCallbacks.length) {
+        // @ts-expect-error TS7006
+        cached.hot._disposeCallbacks.forEach(function (cb) {
+            cb(bundle.hotData[id]);
+        });
+    }
+    delete bundle.cache[id];
+}
+function hmrAccept(
+// @ts-expect-error TS2304
+bundle /*: ParcelRequire */, id /*: string */) {
+    // Execute the module.
+    bundle(id);
+    // Run the accept callbacks in the new version of the module.
+    var cached = bundle.cache[id];
+    if (cached && cached.hot && cached.hot._acceptCallbacks.length) {
+        let assetsToAlsoAccept = [];
+        // @ts-expect-error TS7006
+        cached.hot._acceptCallbacks.forEach(function (cb) {
+            let additionalAssets = cb(function () {
+                // @ts-expect-error TS2339
+                return getParents(module.bundle.root, id);
+            });
+            if (Array.isArray(additionalAssets) && additionalAssets.length) {
+                // @ts-expect-error TS2345
+                assetsToAlsoAccept.push(...additionalAssets);
+            }
+        });
+        if (assetsToAlsoAccept.length > 0) {
+            let handled = assetsToAlsoAccept.every(function (a) {
+                // @ts-expect-error TS2554
+                return hmrAcceptCheck(a[0], a[1]);
+            });
+            if (!handled) {
+                return fullReload();
+            }
+            hmrDisposeQueue();
+        }
+    }
+}

package/lib/HMRRuntime.js

@@ -11,6 +11,13 @@ function _plugin() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _fs() {
   const data = _interopRequireDefault(require("fs"));
   _fs = function () {
@@ -25,14 +32,16 @@ function _path() {
   };
   return data;
 }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // Without this, the hmr-runtime.js is transpiled with the React Refresh swc transform because it
 // lives in `/app/packages/runtimes/...` and thus the `config` in the JSTransformer is actually the
 // user's package.json, and hmr-runtime.js is transpiled as a JSX asset.
 const FILENAME =
-// $FlowFixMe
+// @ts-expect-error TS2339
 process.env.ATLASPACK_BUILD_REPL && process.browser ? '/' + __filename : __filename;
-const HMR_RUNTIME = _fs().default.readFileSync(_path().default.join(__dirname, './loaders/hmr-runtime.js'), 'utf8');
+const HMR_RUNTIME = process.env.ATLASPACK_REGISTER_USE_SRC === 'true' ?
+// This is templated code so it has to be compiled before inlining
+_fs().default.readFileSync(_path().default.join(__dirname, '../lib/loaders/hmr-runtime.js'), 'utf8') : _fs().default.readFileSync(_path().default.join(__dirname, './loaders/hmr-runtime.js'), 'utf8');
 var _default = exports.default = new (_plugin().Runtime)({
   apply({
     bundle,
@@ -51,11 +60,17 @@ var _default = exports.default = new (_plugin().Runtime)({
       // Default to the HTTP port in the browser, only override
       // in watch mode or if hmr port != serve port
       !options.serveOptions || options.serveOptions.port !== port) ? port : null)};` + `var HMR_SECURE = ${JSON.stringify(!!(options.serveOptions && options.serveOptions.https))};` + `var HMR_ENV_HASH = "${bundle.env.id}";` + `var HMR_USE_SSE = ${JSON.stringify(
-      // $FlowFixMe
-      !!(process.env.ATLASPACK_BUILD_REPL && process.browser))};` + `module.bundle.HMR_BUNDLE_ID = ${JSON.stringify(bundle.id)};` + HMR_RUNTIME,
+      // @ts-expect-error TS2339
+      !!(process.env.ATLASPACK_BUILD_REPL && process.browser))};` + `var HMR_ENABLE_BUNDLE_VERSION = ${JSON.stringify((0, _featureFlags().getFeatureFlag)('hmrBundleVersioning'))};` + `module.bundle.HMR_BUNDLE_ID = ${JSON.stringify(bundle.id)};` + HMR_RUNTIME,
       isEntry: true,
       env: {
         sourceType: 'module'
+      },
+      // Pre-computed symbols: HMR runtime sets globals and executes, no explicit exports/imports
+      symbolData: {
+        symbols: new Map(),
+        // No exports, just side effects
+        dependencies: [] // No explicit dependencies, uses runtime globals
       }
     };
   }