@nativescript/vite 8.0.0-alpha.30 → 8.0.0-alpha.31

package/hmr/server/websocket-hot-update.js

@@ -1,33 +1,33 @@
 import * as path from 'path';
-import { createHash } from 'crypto';
-import * as PAT from './constants.js';
 import { isRuntimeGraphExcludedPath } from './runtime-graph-filter.js';
 import { isWithinHmrScope } from '../../helpers/hmr-scope.js';
-import { canonicalizeTransformRequestCacheKey, collectAngularEvictionUrls, collectAngularHotUpdateRoots, collectAngularTransformCacheInvalidationUrls, collectAngularTransitiveImportersForInvalidation, collectGraphUpdateModulesForHotUpdate, shouldInvalidateAngularTransitiveImporters, shouldSuppressDefaultViteHotUpdate } from './websocket-angular-hot-update.js';
+import { collectGraphUpdateModulesForHotUpdate } from '../frameworks/angular/server/websocket-angular-hot-update.js';
 import { getAppCssState } from '../../helpers/app-css-state.js';
 import { collectCssHotUpdatePaths } from './websocket-css-hot-update.js';
 import { classifyHmrUpdateKind, formatHmrUpdateSummary } from './perf-instrumentation.js';
 import { createHmrPendingMessage } from './websocket-hmr-pending.js';
-import { isCoreGlobalsReference, isNativeScriptCoreModule, isNativeScriptPluginModule, resolveVendorFromCandidate } from './websocket-module-specifiers.js';
-import { cleanCode, collectImportDependencies, processSfcCode, rewriteImports } from './websocket-device-transform.js';
-import { isSameAngularModuleRel } from './angular-root-component.js';
+import { getServerOrigin } from './server-origin.js';
 /**
- * The NativeScript `handleHotUpdate` hook, extracted verbatim from
- * `createHmrWebSocketPlugin`. Receives the live Vite {@link HmrContext} plus an
- * injected {@link NsHotUpdateContext}. The early `const` block re-binds every
- * injected dependency to the original closure-local names so the (large) body
- * below is a faithful, behaviour-preserving move.
+ * Shared, framework-agnostic prologue for every strategy's `handleHotUpdate`:
+ * scope gating, update-metrics setup, the `ns:hmr-pending` broadcast, awaiting the
+ * initial graph population, the common module-graph upsert, CSS hot-update +
+ * Tailwind content-CSS broadcast, and the project-scope filter. Returns `null`
+ * when one of those steps fully handles the change (every such path resolves to
+ * Vite's `undefined` result, so the caller just returns), otherwise the
+ * per-invocation {@link HotUpdatePrologueState} (`root`, `updateRel`, the live
+ * `metrics` object, the idempotent `emitSummary`) the per-flavor tail consumes.
+ * Exported so per-flavor strategies can own `prologue + their tail`.
  */
-export async function handleNsHotUpdate(ctx, deps) {
-    const { wss, moduleGraph, strategy, verbose, sfcFileMap, depFileMap, sharedTransformRequest, getServerOrigin, getHmrSourceRootsCached, getBootstrapEntryRelPath, isSocketClientOpen, getHmrSocketRole, shouldRemapImport, rememberAngularReloadSuppression, getRootComponentIdentity } = deps;
+export async function runHotUpdatePrologue(ctx, deps) {
+    const { wss, moduleGraph, strategy, verbose, getHmrSourceRootsCached, isSocketClientOpen } = deps;
     const APP_ROOT_DIR = deps.appRootDir;
     const graphInitialPopulationPromise = deps.getGraphInitialPopulationPromise();
     const { file, server } = ctx;
     if (!wss) {
-        return;
+        return null;
     }
     if (isRuntimeGraphExcludedPath(file)) {
-        return;
+        return null;
     }
     // Authoritative "what triggers HMR" gate, applied before the pending
     // overlay broadcast below: react only to files inside the app source
@@ -36,7 +36,7 @@ export async function handleNsHotUpdate(ctx, deps) {
         if (verbose) {
             console.log(`[ns-hmr][server] ignored change (outside HMR source scope): ${file}`);
         }
-        return;
+        return null;
     }
     // Always-on update timing. Captures the four phases (await,
     // framework, broadcast, total) plus invalidated module count
@@ -135,8 +135,10 @@ export async function handleNsHotUpdate(ctx, deps) {
     updateMetrics.tAfterAwait = Date.now();
     // Graph update for this file change (wrapped to avoid aborting rest of handler)
     try {
-        const skipAngularHtmlGraphUpdate = strategy.flavor === 'angular' && /\.(html|htm)$/i.test(file);
-        if (!skipAngularHtmlGraphUpdate) {
+        // Angular HTML templates opt out via `skipDefaultGraphUpdate` — their tail
+        // re-queries the graph and drives the in-place swap / reboot itself.
+        const skipDefaultGraphUpdate = strategy.skipDefaultGraphUpdate?.(file) ?? false;
+        if (!skipDefaultGraphUpdate) {
             const graphTargets = collectGraphUpdateModulesForHotUpdate({
                 file,
                 flavor: strategy.flavor,
@@ -169,7 +171,7 @@ export async function handleNsHotUpdate(ctx, deps) {
                         // needs the same contract because Solid HMR depends
                         // on the client re-fetching the just-changed module
                         // to drive `solid-refresh.patchRegistry`.
-                        broadcastDelta: strategy.flavor !== 'angular' && strategy.flavor !== 'solid',
+                        broadcastDelta: !strategy.deferDeltaBroadcast,
                     });
                 }
                 catch (error) {
@@ -224,7 +226,7 @@ export async function handleNsHotUpdate(ctx, deps) {
             if (verbose)
                 console.log(`[hmr-ws] Hot update for: ${file} → broadcast CSS paths: ${cssPaths.join(', ')}`);
             emitHmrUpdateSummary();
-            return;
+            return null;
         }
         // CSS without a broadcast target (no appEntryCss
         // configured) — fall through to the scope filter.
@@ -237,7 +239,7 @@ export async function handleNsHotUpdate(ctx, deps) {
     const inApp = normalizedFile.includes(appDir);
     const shouldIgnore = !(inSrcOrCore || inApp);
     if (shouldIgnore)
-        return;
+        return null;
     if (verbose)
         console.log(`[hmr-ws] Hot update for: ${file}`);
     // Tailwind / content-scanning CSS broadcast for non-CSS edits.
@@ -323,838 +325,6 @@ export async function handleNsHotUpdate(ctx, deps) {
             console.warn('[hmr-ws] CSS content-source broadcast failed:', error);
         }
     }
-    // Framework-specific hot update handling
-    if (strategy.flavor === 'angular') {
-        // For Angular, react to component TS or external template HTML changes under /src
-        const isHtml = file.endsWith('.html');
-        const isTs = file.endsWith('.ts');
-        // Web-style template HMR opt-in: when the user enables Angular's
-        // `liveReload` (Analog's flag, mirrored from `--hmr` in
-        // `configuration/angular.ts`), `.html` edits are owned by
-        // Analog's `handleHotUpdate` which sends
-        // `server.ws.send('angular:component-update', { id, timestamp })`.
-        // The runtime listener registered in each compiled component
-        // `.mjs` then dynamic-imports `/@ng/component?c=<id>&t=<ts>` and
-        // calls `ɵɵreplaceMetadata` on the live class — swapping the
-        // template definition AND walking live `LView`s to recreate
-        // matching views in-place. NO Angular reboot, NO route navigation.
-        //
-        // The NS reboot path (`ns:angular-update` → `__reboot_ng_modules__`)
-        // must be SKIPPED for HTML edits when this is on; otherwise both
-        // fire, the reboot wins, and we lose the in-place swap. The
-        // reboot path stays intact for `.ts` edits — those genuinely
-        // change module-level code (services, route configs, NgModule
-        // providers) that Angular's `ɵɵreplaceMetadata` can't reach.
-        //
-        // We detect "live reload mode is on" by checking that the
-        // `analogjs-live-reload-plugin` registered itself with the
-        // dev server. That plugin only exists when `liveReload: true`
-        // was passed to `angular()` in `configuration/angular.ts`,
-        // which gates on `hmrActive`. So this check is a clean
-        // boolean: true iff the in-place pipeline is wired up.
-        const angularLiveReloadActive = (server.config?.plugins ?? []).some((plugin) => plugin?.name === 'analogjs-live-reload-plugin');
-        // Root-component edits must NOT take Analog's in-place
-        // `ɵɵreplaceMetadata` path: the root component hosts the
-        // navigation `Frame` via `<page-router-outlet>`, and replacing
-        // its metadata recreates the root view without re-navigating,
-        // leaving a permanent white screen. We route the edit to the
-        // reboot broadcast below instead (which re-bootstraps and
-        // replays route state). The companion guard in the websocket
-        // bridge drops the in-place `angular:component-update` event for
-        // the root so the two paths don't race. `.ts` root edits already
-        // fall through to the reboot path; this only re-routes `.html`.
-        const rootComponent = getRootComponentIdentity();
-        // `isSameAngularModuleRel` normalizes separators + leading slash internally,
-        // so the raw project-relative path can be passed straight through.
-        const isRootComponentEdit = !!rootComponent && isSameAngularModuleRel(rootComponent.moduleRel, path.relative(root, file));
-        if (isHtml && angularLiveReloadActive && !isRootComponentEdit) {
-            updateMetrics.tAfterFramework = Date.now();
-            if (verbose) {
-                const rel = '/' + path.relative(root, file).split(path.sep).join('/');
-                console.info(`[ns-hmr][server] HTML edit handed off to Analog component-update path; skipping ns:angular-update broadcast (file=${rel})`);
-            }
-            // Re-query the moduleGraph for this file AFTER awaiting
-            // `graphInitialPopulationPromise` (done at the top of
-            // `handleHotUpdate`) and return the freshly-discovered
-            // modules so they propagate to Analog's `handleHotUpdate`
-            // in the same chain.
-            //
-            // Vite v8 builds the initial `mixedHmrContext.modules`
-            // from `mixedModuleGraph.getModulesByFile(file)` BEFORE
-            // any plugin runs. On the very first save after a cold
-            // dev-server start, the moduleGraph for the changed
-            // `.html` template has not yet been populated — that
-            // population happens lazily via `populateInitialGraph`
-            // → `transformRequest` → Analog's `transform` hook →
-            // `addWatchFile(htmlFile)` → `vite:import-analysis`
-            // consumes `_addedImports` and finally calls
-            // `moduleGraph.updateModuleInfo` which registers the
-            // `html → component.ts` importer relationship in
-            // `fileToModulesMap`. All of that work races against the
-            // file-watcher event for the `.html` edit, and the
-            // watcher event almost always wins — so `ctx.modules`
-            // arrives as `[]` even though the component is fully
-            // compiled and ready to receive an in-place template
-            // swap.
-            //
-            // Returning `undefined` here would propagate that empty
-            // `ctx.modules` to the next plugin (Analog's handler),
-            // which iterates with `ctx.modules.forEach(mod => mod
-            // .importers.forEach(imp => …))` — a no-op when
-            // `ctx.modules` is empty. Analog never broadcasts
-            // `angular:component-update`, never marks anything
-            // self-accepting, and Vite falls back to a `full-reload`
-            // payload that the device runtime cannot honor (NS apps
-            // don't have a browser-style page reload). The
-            // user-visible symptom is exactly the "first save logs
-            // `(client) page reload` and the simulator gets stuck
-            // on the HMR-applying overlay forever" failure we hit
-            // before this re-query was added.
-            //
-            // Since we already `await graphInitialPopulationPromise`
-            // at the top of this function, by this point the
-            // moduleGraph IS populated (every component file in
-            // `src/` has been transformed and `addWatchFile` has
-            // been consumed by `import-analysis`). A fresh
-            // `getModulesByFile(file)` call now returns the template
-            // module with the importing component's module in
-            // `.importers`. Returning that array overwrites
-            // `mixedHmrContext.modules` so Analog's handler — which
-            // runs RIGHT AFTER us in the same chain — sees the
-            // populated importer graph, identifies the component
-            // class via `classNames.get(imp.id)`, and broadcasts
-            // `angular:component-update` for `ɵɵreplaceMetadata`.
-            //
-            // We still skip the reboot path (`ns:angular-update`)
-            // for HTML edits — control never reaches the
-            // reboot-broadcast block below because of the `return`
-            // here. The default-Vite-full-reload suppression is now
-            // Analog's responsibility: it marks the changed module
-            // self-accepting, which tells Vite the update is
-            // handled and prevents the fallback.
-            let resolvedModules = ctx.modules;
-            try {
-                const fresh = server.moduleGraph?.getModulesByFile?.(file);
-                if (fresh && fresh.size > 0) {
-                    resolvedModules = [...fresh];
-                    if (verbose) {
-                        console.info(`[ns-hmr][server] re-queried modules after graph population: count=${resolvedModules.length} (was ${ctx.modules?.length ?? 0})`);
-                    }
-                }
-            }
-            catch (refetchErr) {
-                if (verbose) {
-                    console.warn('[ns-hmr][server] failed to re-query moduleGraph for html update', refetchErr);
-                }
-            }
-            emitHmrUpdateSummary();
-            return resolvedModules;
-        }
-        const angularHotUpdateRoots = collectAngularHotUpdateRoots({
-            file,
-            modules: ctx.modules,
-            getModuleById: (id) => server.moduleGraph.getModuleById(id),
-            getModulesByFile: (targetFile) => server.moduleGraph.getModulesByFile?.(targetFile),
-        });
-        if (verbose) {
-            console.info(`[ns-hmr][server] hot-update file=${file} isHtml=${isHtml} isTs=${isTs} ctxModules=${Array.from(ctx.modules || []).length} hotUpdateRoots=${angularHotUpdateRoots.length} (${angularHotUpdateRoots
-                .map((m) => m?.id ?? '(none)')
-                .slice(0, 8)
-                .join(', ')}${angularHotUpdateRoots.length > 8 ? ', …' : ''})`);
-        }
-        if (!(isHtml || isTs))
-            return;
-        updateMetrics.invalidated += angularHotUpdateRoots.length;
-        if (angularHotUpdateRoots.length) {
-            for (const mod of angularHotUpdateRoots) {
-                try {
-                    server.moduleGraph.invalidateModule(mod);
-                }
-                catch (invalidationError) {
-                    if (verbose) {
-                        console.warn('[hmr-ws][angular] hot-update root invalidation failed', mod?.id, invalidationError);
-                    }
-                }
-            }
-            if (verbose) {
-                console.log('[hmr-ws][angular] invalidated hot-update root modules:', angularHotUpdateRoots.length);
-            }
-        }
-        const angularTransitiveInvalidationRoots = (angularHotUpdateRoots.length ? angularHotUpdateRoots : ctx.modules);
-        // Read the source for `.ts/.tsx/.js/.jsx` edits so
-        // `shouldInvalidateAngularTransitiveImporters` can
-        // distinguish leaf modules (constants/utils) from real
-        // Angular files. If `ctx.read()` throws (file deleted, race
-        // against the watcher), `angularChangedSource` stays
-        // undefined and we fall back to the conservative "always
-        // invalidate transitively" behavior.
-        let angularChangedSource;
-        if (isTs) {
-            try {
-                angularChangedSource = await ctx.read();
-            }
-            catch {
-                angularChangedSource = undefined;
-            }
-        }
-        const angularNeedsTransitive = shouldInvalidateAngularTransitiveImporters({
-            flavor: strategy.flavor,
-            file,
-            source: angularChangedSource,
-        });
-        // Surface the narrowing decision on every `.ts` Angular hot
-        // update (HTML routes always invalidate transitively and
-        // aren't subject to narrowing, so we leave them as
-        // `undefined` — the field is omitted from the summary line).
-        // The boolean is the inverse of `angularNeedsTransitive`
-        // because "needs transitive" is the broad (un-narrowed)
-        // behavior.
-        if (isTs) {
-            updateMetrics.narrowed = !angularNeedsTransitive;
-        }
-        // Stable URL + Explicit Invalidation:
-        //
-        // Compute the transitive importer closure ONCE here and reuse
-        // it for (a) `server.moduleGraph.invalidateModule` (so Vite's
-        // transform pipeline re-runs on next request), (b) the shared
-        // transform-request cache, and (c) the runtime eviction set
-        // we broadcast in `ns:angular-update`. Consolidating this
-        // removes a redundant graph walk and guarantees the three
-        // consumers see the exact same set of importers (otherwise a
-        // late module-graph mutation between calls could leave an
-        // asymmetric narrowed/broad mix).
-        //
-        // We separate Vite-transform narrowing from runtime eviction:
-        // `angularNeedsTransitive` answers the question "does the
-        // changed file's symbol shape change such that importers
-        // must be re-transformed by Vite?". The runtime, however,
-        // has a stricter requirement: ESM live bindings only refresh
-        // if the importing module re-evaluates inside V8. A
-        // constants file with no Angular decorator does NOT need a
-        // Vite re-transform of its importers (their compiled JS is
-        // identical), but its importers still hold stale bindings to
-        // the OLD constants Module record. After eviction + re-import
-        // of `main.ts`, V8 sees the cached importers, returns them
-        // unchanged, and they continue to read the OLD values. The
-        // user-visible symptom: HMR completes successfully, logs are
-        // clean, but the simulator does not reflect the change.
-        //
-        // The fix: ALWAYS compute the transitive importer closure
-        // for runtime eviction. Only skip Vite's
-        // `moduleGraph.invalidate` + transform-cache purge when
-        // `angularNeedsTransitive` is false — those are the genuine
-        // narrowing wins (saves re-transform work on the server).
-        // The eviction set always includes importers so V8 re-fetches
-        // and re-binds them.
-        if (verbose) {
-            console.info(`[ns-hmr][server] angularNeedsTransitive=${angularNeedsTransitive} (file=${path.basename(file)})`);
-        }
-        let transitiveImporters = [];
-        try {
-            transitiveImporters = collectAngularTransitiveImportersForInvalidation({
-                modules: angularTransitiveInvalidationRoots,
-                isExcluded: (id) => id.includes('/node_modules/'),
-                maxDepth: 16,
-            });
-            if (verbose) {
-                console.info(`[ns-hmr][server] transitiveImporters count=${transitiveImporters.length} firstN=`, transitiveImporters.slice(0, 16).map((m) => m?.id ?? '(none)'));
-            }
-            if (angularNeedsTransitive) {
-                updateMetrics.invalidated += transitiveImporters.length;
-                for (const mod of transitiveImporters) {
-                    try {
-                        server.moduleGraph.invalidateModule(mod);
-                    }
-                    catch (invalidationError) {
-                        if (verbose) {
-                            console.warn('[hmr-ws][angular] transitive importer invalidation failed', mod?.id, invalidationError);
-                        }
-                    }
-                }
-                if (verbose && transitiveImporters.length) {
-                    console.log('[hmr-ws][angular] invalidated transitive importers:', transitiveImporters.length);
-                }
-            }
-            else if (isTs && typeof angularChangedSource === 'string') {
-                // Surfacing this log unconditionally lets the user
-                // immediately confirm whether narrowing fired for a
-                // given `.ts` edit (the summary line below still
-                // emits `narrowed=yes`/`no`, but having both makes
-                // the decision easier to spot in noisy logs and lets
-                // the user diff scenarios without flipping
-                // `NS_HMR_VERBOSE=true`).
-                //
-                // Narrowing means "skip Vite re-transform" (the
-                // importers still get evicted from the V8 module
-                // registry so live bindings refresh). The importer
-                // count is appended so the distinction is visible.
-                if (verbose && transitiveImporters.length) {
-                    console.log(`[hmr-ws][angular] narrowed transitive invalidation (no @Component/@Directive/@Pipe/@Injectable/@NgModule): ${updateRel} — Vite transform skipped, runtime eviction includes ${transitiveImporters.length} importer(s)`);
-                }
-            }
-        }
-        catch (error) {
-            if (verbose)
-                console.warn('[hmr-ws][angular] transitive importer collection failed', error);
-        }
-        try {
-            // Purge shared transform cache for the changed file +
-            // hot-update roots unconditionally (their transform
-            // output IS different now). Transitive importers are
-            // only purged when narrowing decides their output may
-            // have changed; otherwise their cached transforms are
-            // still valid (compiled JS is identical even though the
-            // runtime must re-evaluate them to refresh ESM bindings).
-            const transformCacheInvalidationUrls = new Set(collectAngularTransformCacheInvalidationUrls({
-                file,
-                isTs,
-                hotUpdateRoots: angularHotUpdateRoots,
-                transitiveImporters: angularNeedsTransitive ? transitiveImporters : [],
-                projectRoot: server.config.root || process.cwd(),
-            }));
-            if (transformCacheInvalidationUrls.size) {
-                sharedTransformRequest.invalidateMany(transformCacheInvalidationUrls);
-                if (verbose) {
-                    console.log('[hmr-ws][angular] purged shared transform cache entries:', transformCacheInvalidationUrls.size);
-                }
-            }
-        }
-        catch (error) {
-            if (verbose)
-                console.warn('[hmr-ws][angular] shared transform cache purge failed', error);
-        }
-        updateMetrics.tAfterFramework = Date.now();
-        try {
-            const root = server.config.root || process.cwd();
-            const rel = '/' + path.posix.normalize(path.relative(root, file)).split(path.sep).join('/');
-            rememberAngularReloadSuppression(root, file);
-            const origin = getServerOrigin(server);
-            const bootstrapEntryRel = getBootstrapEntryRelPath();
-            // Stable URL + Explicit Invalidation:
-            //
-            // `evictPaths` is the canonical list of `/ns/m/<rel>` URLs
-            // the runtime must drop from `g_moduleRegistry` before
-            // re-importing `importerEntry`. Older versions of the
-            // server signaled invalidation by bumping a global
-            // `graphVersion` counter and embedding it in every URL —
-            // but V8 keys the module registry by full URL, so a v1 →
-            // v2 bump effectively flushed the entire dependency
-            // graph from the cache and forced the runtime to
-            // re-fetch + re-eval every transitively-imported module
-            // on each save (~3s HMR cycles, dominated by Vite's
-            // single-threaded transform pipeline). The new model:
-            //
-            //   1. URLs are stable: `/ns/m/<rel>` everywhere, no `vN`.
-            //   2. The server walks the inverse-dependency closure and
-            //      sends only the modules that actually need to be
-            //      re-evaluated (typically O(1) for component edits,
-            //      or the changed file + entry for narrowed edits).
-            //   3. The client calls `__nsInvalidateModules(evictPaths)`
-            //      and re-imports `importerEntry`, which causes V8 to
-            //      refetch ONLY those modules. Everything else stays
-            //      hot in the registry.
-            //
-            // Invariants enforced by `collectAngularEvictionUrls`:
-            //   - Always includes the changed file (so the new source
-            //     is fetched).
-            //   - Always includes `importerEntry` (so re-import
-            //     re-evaluates).
-            //   - Excludes node_modules (vendor packages are stable).
-            //   - Excludes virtual / runtime-graph-excluded ids.
-            //   - Origin-prefixed: `http://host:port/ns/m/<rel>`.
-            let evictPaths = [];
-            try {
-                evictPaths = collectAngularEvictionUrls({
-                    file,
-                    hotUpdateRoots: angularHotUpdateRoots,
-                    transitiveImporters,
-                    projectRoot: root,
-                    origin,
-                    bootstrapEntry: bootstrapEntryRel,
-                });
-            }
-            catch (error) {
-                if (verbose) {
-                    console.warn('[ns-hmr][server] eviction set computation failed', error);
-                }
-            }
-            if (verbose) {
-                try {
-                    const tsRel = rel.replace(/\.(html|htm)$/i, '.ts');
-                    const jsRel = rel.replace(/\.(html|htm)$/i, '.js');
-                    const containsRelatedTs = evictPaths.some((u) => u.endsWith(tsRel));
-                    const containsRelatedJs = evictPaths.some((u) => u.endsWith(jsRel));
-                    const sample = evictPaths.slice(0, 32);
-                    console.info(`[ns-hmr][server] evict-set count=${evictPaths.length} importerEntry=${bootstrapEntryRel ?? '(none)'} containsRelatedTs=${containsRelatedTs} containsRelatedJs=${containsRelatedJs} firstN=`, sample);
-                    if (evictPaths.length > sample.length) {
-                        console.info(`[ns-hmr][server] evict-set hidden=${evictPaths.length - sample.length} (showed first ${sample.length})`);
-                    }
-                }
-                catch { }
-            }
-            const msg = {
-                type: 'ns:angular-update',
-                origin,
-                path: rel,
-                version: moduleGraph.version,
-                timestamp: Date.now(),
-                evictPaths,
-                importerEntry: bootstrapEntryRel,
-            };
-            if (verbose) {
-                console.log('[hmr-ws][angular] broadcasting update', Array.from(wss.clients || []).map((client) => ({
-                    role: getHmrSocketRole(client),
-                    readyState: client.readyState,
-                    openState: client.OPEN,
-                })));
-            }
-            wss.clients.forEach((client) => {
-                if (isSocketClientOpen(client)) {
-                    client.send(JSON.stringify(msg));
-                    updateMetrics.recipients += 1;
-                }
-            });
-        }
-        catch (error) {
-            console.warn('[hmr-ws][angular] update failed:', error);
-        }
-        emitHmrUpdateSummary();
-        if (shouldSuppressDefaultViteHotUpdate({ flavor: strategy.flavor, file })) {
-            return [];
-        }
-        return;
-    }
-    // TypeScript flavor: emit generic graph delta for app XML/TS/style changes
-    if (strategy.flavor === 'typescript') {
-        updateMetrics.tAfterFramework = Date.now();
-        try {
-            const rel = '/' + path.posix.normalize(path.relative(root, file)).split(path.sep).join('/');
-            if (verbose)
-                console.log('[hmr-ws][ts] app file hot update', { file, rel });
-            // Treat the changed file itself as a graph module with no deps. We only
-            // care that its hash/identity changes so the client sees a delta and can
-            // perform a TS root reset. Code is not used for execution here.
-            moduleGraph.upsert(rel, '', [], { emitDeltaOnInsert: true });
-        }
-        catch (e) {
-            if (verbose)
-                console.warn('[hmr-ws][ts] failed to emit delta for', file, e);
-        }
-        emitHmrUpdateSummary();
-        return;
-    }
-    // Solid flavor: emit graph delta for app TSX/TS/JSX file changes.
-    // The common graph-update block above (moduleGraph lookup) may have
-    // already emitted a delta if the file was in Vite's module graph.
-    // This handler ensures a delta is emitted even if the module wasn't
-    // found (e.g. new file, or moduleGraph mismatch), and provides
-    // Solid-specific logging. The client-side processQueue handles
-    // propagation from non-component .ts files to .tsx component boundaries.
-    if (strategy.flavor === 'solid') {
-        const isSolidFile = /\.(tsx?|jsx?)$/i.test(file);
-        if (!isSolidFile)
-            return;
-        updateMetrics.tAfterFramework = Date.now();
-        try {
-            const rel = '/' + path.posix.normalize(path.relative(root, file)).split(path.sep).join('/');
-            if (verbose)
-                console.log('[hmr-ws][solid] app file hot update', { file, rel });
-            // If the common block already upserted (hash changed), this will
-            // detect unchanged hash and no-op. If the common block missed it
-            // (module not in Vite's graph), this forces the delta emission.
-            const normalizedId = moduleGraph.normalizeGraphId(rel);
-            const existing = moduleGraph.get(normalizedId);
-            if (!existing) {
-                // Module not in graph yet — force upsert with timestamp-based
-                // hash so the client sees a change.
-                moduleGraph.upsert(rel, `/* solid-hmr ${Date.now()} */`, [], { emitDeltaOnInsert: true });
-            }
-            // Log what we're sending so devs can trace the flow on the server side.
-            if (verbose) {
-                const gm = moduleGraph.get(normalizedId);
-                console.log('[hmr-ws][solid] delta module', { id: gm?.id, hash: gm?.hash });
-            }
-            // Purge the shared transform-request cache AND Vite's own
-            // moduleGraph transformResult cache for the changed file
-            // AND every transitive importer.
-            //
-            // Why this matters for Solid HMR specifically:
-            //  - The HMR client evicts V8's module cache for the
-            //    canonical /ns/m/<path> URL and re-imports the module.
-            //  - The dev server resolves /ns/m/* by calling
-            //    `sharedTransformRequest(...)`, which has a 60s TTL on
-            //    transform results to amortize cost across HMR
-            //    cycles. The shared cache wraps `server.transformRequest`,
-            //    which itself caches the compiled output on each
-            //    `ModuleNode.transformResult`. Both layers must be
-            //    invalidated, or the re-import resolves to whatever
-            //    the previous save populated.
-            //  - Without invalidation at *both* layers, the second
-            //    save of a file within the cache window returns the
-            //    FIRST save's transform — V8 evaluates stale code,
-            //    `solid-refresh.patchRegistry` runs against an
-            //    unchanged source body, and the visible page picks
-            //    up the previous save's edit instead of the current
-            //    one (the "one-save-behind" symptom users reported).
-            //
-            // Critically, transitive importers must also be invalidated
-            // because TanStack file-based routing (and similar frameworks)
-            // use route files that statically import their components.
-            // When `home.tsx` changes, `routes/index.tsx`'s transform
-            // output references the imported home module identity. Even
-            // though the route file's source bytes did not change, its
-            // *resolved* import target has — and its cached transform
-            // might still encode the previous resolution. Forcing a
-            // fresh transform of the importer guarantees the route
-            // file's `import Home from ...` re-resolves against the
-            // freshly evaluated home module on V8 side.
-            //
-            // The Angular path performs the equivalent purge via
-            // `collectAngularTransformCacheInvalidationUrls` /
-            // `sharedTransformRequest.invalidateMany`. We replicate
-            // that contract for Solid here. The transitive walk is
-            // bounded the same way (max depth 16, node_modules /
-            // virtual ids excluded) so vendor packages stay hot.
-            try {
-                const projectRoot = server.config.root || process.cwd();
-                const cacheInvalidationUrls = new Set();
-                const addCacheKey = (rawId) => {
-                    const id = String(rawId || '');
-                    if (!id)
-                        return;
-                    const cacheKey = canonicalizeTransformRequestCacheKey(id, projectRoot);
-                    cacheInvalidationUrls.add(cacheKey);
-                    const noQuery = cacheKey.replace(/\?.*$/, '');
-                    const stripped = noQuery.replace(/\.(?:[mc]?[jt]sx?)$/i, '');
-                    if (stripped !== noQuery) {
-                        cacheInvalidationUrls.add(stripped);
-                    }
-                };
-                addCacheKey(file);
-                const rootModules = server.moduleGraph.getModulesByFile?.(file);
-                const transitiveImporters = collectAngularTransitiveImportersForInvalidation({
-                    modules: rootModules ? Array.from(rootModules) : [],
-                    isExcluded: (id) => id.includes('/node_modules/') || isRuntimeGraphExcludedPath(id),
-                    maxDepth: 16,
-                });
-                // Invalidate Vite's moduleGraph for the changed file +
-                // every transitive importer so `server.transformRequest`
-                // re-runs the transform pipeline instead of returning
-                // the cached `ModuleNode.transformResult`. We call
-                // `onFileChange` (Vite's authoritative file-changed
-                // signal — walks all module variants including `?v=`,
-                // `?import`, `?t=`) AND per-module `invalidateModule`
-                // for transitive importers (which onFileChange
-                // doesn't reach).
-                try {
-                    server.moduleGraph.onFileChange(file);
-                }
-                catch { }
-                if (rootModules) {
-                    for (const mod of rootModules) {
-                        try {
-                            server.moduleGraph.invalidateModule(mod);
-                        }
-                        catch { }
-                    }
-                }
-                for (const mod of transitiveImporters) {
-                    addCacheKey(mod?.id);
-                    try {
-                        server.moduleGraph.invalidateModule(mod);
-                    }
-                    catch { }
-                }
-                if (cacheInvalidationUrls.size && sharedTransformRequest) {
-                    sharedTransformRequest.invalidateMany(cacheInvalidationUrls);
-                    if (verbose) {
-                        console.log('[hmr-ws][solid] purged shared transform cache entries:', cacheInvalidationUrls.size, 'transitiveImporters=', transitiveImporters.length);
-                    }
-                }
-                // Sledgehammer: nuke EVERY entry in sharedTransformRequest's
-                // result cache. The targeted `invalidateMany` above only
-                // clears keys we know about. The `/ns/m/` handler iterates
-                // a long list of candidate extensions (`.ts`, `.js`, `.tsx`,
-                // `.jsx`, `.mjs`, `.mts`, `.cts`, `.vue`, `index.*`) and
-                // EACH candidate is a separate cache key. If a previous
-                // serve populated cache for `/src/components/home.js` (via
-                // extension fallback that resolves to `home.tsx`), our
-                // targeted invalidate misses it and iOS HITs the stale
-                // entry — serving the previous save's transformed code.
-                try {
-                    sharedTransformRequest.clear();
-                }
-                catch { }
-            }
-            catch (e) {
-                if (verbose)
-                    console.warn('[hmr-ws][solid] transform cache invalidation failed', e);
-            }
-            // Re-run the transform AFTER all caches are invalidated, then
-            // re-upsert the graph so the broadcast hash matches the freshly-
-            // transformed content. The common upsert block above ran
-            // `server.transformRequest` BEFORE invalidation — at that
-            // moment Vite's auto-invalidate hadn't fired yet (it runs after
-            // `plugin.handleHotUpdate`), so the result it cached was the
-            // previous save's. Without this re-transform, the broadcast
-            // carries a stale hash and iOS evaluates the previous save's
-            // bytes ("one save behind").
-            //
-            // We pre-populate the cache for every extension variant Vite's
-            // /ns/m/ handler might try, so the first request from iOS hits
-            // fresh data regardless of which candidate it resolves first.
-            try {
-                const ext = file.match(/\.(?:[mc]?[jt]sx?)$/i)?.[0] || '';
-                const baseSpec = '/' + path.posix.normalize(path.relative(root, file)).split(path.sep).join('/');
-                const baseNoExt = ext ? baseSpec.replace(/\.(?:[mc]?[jt]sx?)$/i, '') : baseSpec;
-                const candidates = Array.from(new Set([baseSpec, baseNoExt, baseNoExt + '.ts', baseNoExt + '.tsx', baseNoExt + '.js', baseNoExt + '.jsx', baseNoExt + '.mjs', baseNoExt + '.mts', baseNoExt + '.cts', file]));
-                let freshCode = '';
-                for (const cand of candidates) {
-                    try {
-                        const fresh = await sharedTransformRequest(cand, 30000);
-                        if (fresh?.code && !freshCode)
-                            freshCode = fresh.code;
-                    }
-                    catch { }
-                }
-                if (freshCode) {
-                    const existingGm = moduleGraph.get(normalizedId);
-                    const existingDeps = existingGm?.deps || [];
-                    moduleGraph.upsert(normalizedId, freshCode, existingDeps, {
-                        broadcastDelta: false,
-                    });
-                }
-            }
-            catch (e) {
-                if (verbose)
-                    console.warn('[hmr-ws][solid] post-invalidation re-transform failed', e);
-            }
-            // Broadcast the (now-fresh) delta. Suppressing this in the
-            // common upsert block (`broadcastDelta: strategy.flavor
-            // !== 'solid'`) and emitting it here ensures the client's
-            // eviction + re-import doesn't race the server's cache
-            // invalidation.
-            try {
-                const gm = moduleGraph.get(normalizedId);
-                if (gm) {
-                    moduleGraph.emitDelta([gm], []);
-                    if (verbose) {
-                        console.log('[hmr-ws][solid] broadcast delta after cache invalidation', { id: gm.id, hash: gm.hash });
-                    }
-                }
-            }
-            catch (e) {
-                if (verbose)
-                    console.warn('[hmr-ws][solid] post-invalidation broadcast failed', e);
-            }
-        }
-        catch (e) {
-            if (verbose)
-                console.warn('[hmr-ws][solid] failed to handle hot update for', file, e);
-        }
-        emitHmrUpdateSummary();
-        return;
-    }
-    // Handle .vue file updates
-    if (!file.endsWith('.vue')) {
-        if (verbose)
-            console.log('[hmr-ws] Not a .vue file, skipping');
-        return;
-    }
-    if (verbose)
-        console.log('[hmr-ws] Processing .vue file update...');
-    try {
-        const root = server.config.root || process.cwd();
-        let rel = '/' + path.posix.normalize(path.relative(root, file)).split(path.sep).join('/');
-        // Transform the .vue file
-        const transformed = await server.transformRequest(rel);
-        if (!transformed?.code)
-            return;
-        let code = transformed.code;
-        // Clean and process
-        code = cleanCode(code, strategy);
-        // Process dependencies
-        const visitedPaths = new Set();
-        const importerDir = path.posix.dirname(rel);
-        // Collect dependencies from this file
-        const deps = new Set();
-        const collectDeps = (pattern) => {
-            let match;
-            while ((match = pattern.exec(code)) !== null) {
-                const spec = match[2];
-                if (!spec || PAT.VUE_FILE_PATTERN.test(spec) || !shouldRemapImport(spec)) {
-                    continue;
-                }
-                let key;
-                if (spec.startsWith('/')) {
-                    key = spec;
-                }
-                else if (spec.startsWith('./') || spec.startsWith('../')) {
-                    key = path.posix.normalize(path.posix.join(importerDir, spec));
-                    if (!key.startsWith('/'))
-                        key = '/' + key;
-                }
-                else {
-                    continue;
-                }
-                key = key.replace(PAT.QUERY_PATTERN, '');
-                deps.add(key);
-            }
-        };
-        collectDeps(PAT.IMPORT_PATTERN_1);
-        collectDeps(PAT.IMPORT_PATTERN_2);
-        collectDeps(PAT.EXPORT_PATTERN);
-        collectDeps(PAT.IMPORT_PATTERN_3);
-        // CRITICAL: Collect .vue file imports separately
-        // Use matchAll() to avoid regex state issues
-        const vueDeps = new Set();
-        const vueImportMatches = [...code.matchAll(PAT.IMPORT_PATTERN_1), ...code.matchAll(PAT.VUE_FILE_IMPORT)];
-        for (const match of vueImportMatches) {
-            const spec = match[2];
-            if (!spec || !PAT.VUE_FILE_PATTERN.test(spec)) {
-                continue;
-            }
-            let key;
-            if (spec.startsWith('/')) {
-                key = spec.replace(PAT.QUERY_PATTERN, '');
-            }
-            else if (spec.startsWith('./') || spec.startsWith('../')) {
-                key = path.posix.normalize(path.posix.join(importerDir, spec.replace(PAT.QUERY_PATTERN, '')));
-                if (!key.startsWith('/'))
-                    key = '/' + key;
-            }
-            else {
-                continue;
-            }
-            // Ensure this .vue file is registered in sfcFileMap
-            if (!sfcFileMap.has(key)) {
-                const hash = createHash('md5').update(key).digest('hex').slice(0, 8);
-                sfcFileMap.set(key, `sfc-${hash}.mjs`);
-                if (verbose) {
-                    console.log(`[hmr-ws] Registered .vue import: ${key} → sfc-${hash}.mjs`);
-                }
-            }
-            // Add to vueDeps for separate processing
-            vueDeps.add(key);
-        }
-        // Process .vue dependencies (they stay as sfc-*.mjs imports)
-        for (const vueDep of vueDeps) {
-            await strategy.processFile({
-                filePath: vueDep,
-                server,
-                sfcFileMap,
-                depFileMap,
-                visitedPaths,
-                wss,
-                verbose,
-                helpers: {
-                    cleanCode: (code) => cleanCode(code, strategy),
-                    collectImportDependencies,
-                    isCoreGlobalsReference,
-                    isNativeScriptCoreModule,
-                    isNativeScriptPluginModule,
-                    resolveVendorFromCandidate,
-                    createHash: (value) => createHash('md5').update(value).digest('hex'),
-                },
-            });
-        }
-        // Process with consistent SFC processor (removes non-.vue imports)
-        code = processSfcCode(code);
-        // Rewrite ONLY .vue imports (everything else is now inlined)
-        const projectRoot = server.config.root || process.cwd();
-        code = rewriteImports(code, rel, sfcFileMap, depFileMap, projectRoot, verbose, undefined);
-        moduleGraph.upsert(rel, code, [...deps, ...vueDeps]);
-        // Add HMR runtime prelude (CRITICAL for runtime)
-        const hmrPrelude = `
-// Embedded HMR Runtime for NativeScript runtime
-const createHotContext = (id) => ({
-  on: (event, handler) => {
-    if (!globalThis.__NS_HMR_HANDLERS__) globalThis.__NS_HMR_HANDLERS__ = new Map();
-    if (!globalThis.__NS_HMR_HANDLERS__.has(id)) globalThis.__NS_HMR_HANDLERS__.set(id, []);
-    globalThis.__NS_HMR_HANDLERS__.get(id).push({ event, handler });
-  },
-  accept: (handler) => {
-    if (!globalThis.__NS_HMR_ACCEPTS__) globalThis.__NS_HMR_ACCEPTS__ = new Map();
-    globalThis.__NS_HMR_ACCEPTS__.set(id, handler);
-  }
-});
-
-if (typeof import.meta === 'undefined') {
-  globalThis.importMeta = { hot: null };
-} else if (!import.meta.hot) {
-  import.meta.hot = null;
-}
-
-const __vite__createHotContext = createHotContext;
-
-if (typeof __VUE_HMR_RUNTIME__ === 'undefined') {
-  globalThis.__VUE_HMR_RUNTIME__ = {
-    createRecord: () => true,
-    reload: () => {},
-    rerender: () => {},
-  };
-}
-
-// Install a lightweight guard to capture require('http(s)://...') attempts with stack traces
-(() => {
-  try {
-    const g = globalThis;
-    if (g.__NS_REQUIRE_GUARD_INSTALLED__) return;
-	const makeGuard = (orig, label) => function () {
-      try {
-        const spec = arguments[0];
-        if (typeof spec === 'string' && /^(?:https?:)\/\//.test(spec)) {
-          const err = new Error('[ns-hmr][require-guard] require of URL: ' + spec + ' via ' + label);
-          const stack = err.stack || '';
-          console.error(err.message + '\n' + stack);
-          try { g.__NS_REQUIRE_GUARD_LAST__ = { spec, stack, label, ts: Date.now() }; } catch {}
-        }
-      } catch {}
-      return orig.apply(this, arguments);
-    };
-    if (typeof g.require === 'function' && !g.require.__NS_REQ_GUARDED__) {
-      const orig = g.require; g.require = makeGuard(orig, 'require'); g.require.__NS_REQ_GUARDED__ = true;
-    }
-    if (typeof g.__nsRequire === 'function' && !g.__nsRequire.__NS_REQ_GUARDED__) {
-      const orig = g.__nsRequire; g.__nsRequire = makeGuard(orig, '__nsRequire'); g.__nsRequire.__NS_REQ_GUARDED__ = true;
-    }
-    g.__NS_REQUIRE_GUARD_INSTALLED__ = true;
-  } catch {}
-})();
-`;
-        code = hmrPrelude + '\n' + code;
-        // Update SFC registry
-        const hash = createHash('md5').update(rel).digest('hex').slice(0, 8);
-        const fileName = sfcFileMap.get(rel) || `sfc-${hash}.mjs`;
-        sfcFileMap.set(rel, fileName);
-        const ts = Date.now();
-        // FIRST: Send mapping-only registry update (no code)
-        const registryUpdateMsg = {
-            type: 'ns:vue-sfc-registry-update',
-            path: rel,
-            fileName,
-            ts,
-            version: moduleGraph.version,
-        };
-        wss.clients.forEach((client) => {
-            if (isSocketClientOpen(client)) {
-                client.send(JSON.stringify(registryUpdateMsg));
-            }
-        });
-        // HTTP-only mode: the device loads SFC artifacts and their dependencies via
-        // HTTP endpoints on demand, so the WS channel stays metadata-only (just the
-        // registry update above). No code-push, dependency harvest, or legacy dynamic
-        // module message is emitted here.
-    }
-    catch (error) {
-        console.warn('[hmr-ws] HMR update failed:', error);
-        console.error(error);
-    }
-    // Vue path emits update summary at the end of the function so
-    // every framework branch gets exactly one log line. Idempotent
-    // — if any branch already emitted, this is a no-op.
-    emitHmrUpdateSummary();
-    // CRITICAL: Return empty array to prevent Vite's default HMR
-    return [];
+    return { root, updateRel, metrics: updateMetrics, emitSummary: emitHmrUpdateSummary };
 }
 //# sourceMappingURL=websocket-hot-update.js.map