@nativescript/vite 8.0.0-alpha.1 → 8.0.0-alpha.11

package/hmr/helpers/cjs-named-exports.js

@@ -0,0 +1,152 @@
+// Runtime-enumerated CommonJS named exports for the HMR `/ns/m` pipeline.
+//
+// Why this exists:
+// V8's HTTP-imported ES module loader (the device's `http-esm` mode) requires
+// named exports to be declared statically at parse time. Many real-world npm
+// packages do not declare their public surface statically — the canonical
+// example is lodash:
+//
+//   (freeModule.exports = _)._ = _;
+//
+// At parse time there are zero `exports.foo = ...` or
+// `Object.defineProperty(exports, 'foo', ...)` patterns. Lodash builds its
+// public surface dynamically inside an IIFE and attaches every method to a
+// function object that is then assigned to `module.exports`. Neither a
+// regex nor an AST can statically determine that lodash exposes
+// `capitalize`, `chunk`, `debounce`, etc.
+//
+// The only correct way to enumerate this kind of CJS module's public
+// surface is to actually load it in the dev server's Node context and ask
+// `Object.keys(...)`. This is exactly what esbuild and Vite do at build
+// time when they pre-bundle CJS deps for an ESM consumer; this helper
+// brings the same strategy to the HMR served-module pipeline so that
+// `import { capitalize } from 'lodash'` succeeds even when lodash is not
+// pre-bundled by Vite.
+//
+// Safety:
+// - Only call this for modules under `node_modules` (we never execute user
+//   source code via this path).
+// - Wrap in try/catch — some npm packages throw at load time (missing peer
+//   deps, browser-only globals, side effects). On any failure we return an
+//   empty list and the caller falls back to whatever it could detect
+//   statically.
+// - Cache by absolute path so a second HMR request for the same module is
+//   free.
+import { createRequire } from 'node:module';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+const cache = new Map();
+const RESERVED = new Set(['default', '__esModule']);
+// `Object.getOwnPropertyNames` on a function exposes these implementation
+// details — they are not real exports.
+const FUNCTION_INTERNAL = new Set(['length', 'name', 'prototype', 'arguments', 'caller']);
+const VALID_IDENT = /^[A-Za-z_$][\w$]*$/;
+export function clearCjsNamedExportsCache(filePath) {
+    if (!filePath) {
+        cache.clear();
+    }
+    else {
+        cache.delete(filePath);
+    }
+}
+export function getCjsNamedExportsCacheSize() {
+    return cache.size;
+}
+/**
+ * Normalize a path that may have come from a Vite-resolved id (e.g.
+ * `/@fs/Users/.../node_modules/foo/index.js?import`) into a plain
+ * absolute filesystem path that `createRequire` can load.
+ *
+ * Returns null if the path does not look like an absolute filesystem
+ * path that exists on disk.
+ */
+export function normalizeAbsolutePathForRequire(input) {
+    if (!input)
+        return null;
+    let s = String(input).replace(/[?#].*$/, '');
+    // Vite serves absolute paths as `/@fs/<absolute>`; strip the prefix.
+    if (s.startsWith('/@fs/')) {
+        s = s.slice('/@fs'.length);
+    }
+    if (!path.isAbsolute(s))
+        return null;
+    try {
+        if (!fs.statSync(s).isFile())
+            return null;
+    }
+    catch {
+        return null;
+    }
+    return s;
+}
+/**
+ * Enumerate the named exports of a CommonJS module by loading it in the
+ * dev server's Node context.
+ *
+ * Returns an empty array if the module can't be loaded, isn't in
+ * node_modules, or doesn't expose any enumerable string-keyed properties
+ * that look like JS identifiers.
+ *
+ * Results are cached by absolute path. Pass `clearCjsNamedExportsCache()`
+ * if you need to invalidate (e.g. between tests).
+ */
+export function getCjsNamedExports(absolutePath) {
+    const normalized = normalizeAbsolutePathForRequire(absolutePath);
+    if (!normalized)
+        return [];
+    // Only enumerate node_modules paths — never execute user source via this code path.
+    if (!/(?:^|\/)node_modules\//.test(normalized))
+        return [];
+    const cached = cache.get(normalized);
+    if (cached !== undefined)
+        return cached || [];
+    let names = null;
+    try {
+        // `createRequire` needs a path that itself exists; the file we are
+        // enumerating is a fine anchor. The cwd of the require base is its
+        // parent directory, which matters for nested workspace resolution.
+        const req = createRequire(normalized);
+        const mod = req(normalized);
+        const collected = new Set();
+        const isFn = typeof mod === 'function';
+        if (mod && (typeof mod === 'object' || isFn)) {
+            // `Object.keys` returns enumerable own props — covers most CJS modules
+            // where named exports are real properties on the exports object.
+            try {
+                for (const k of Object.keys(mod)) {
+                    if (!RESERVED.has(k) && VALID_IDENT.test(k))
+                        collected.add(k);
+                }
+            }
+            catch {
+                /* exotic proxy etc. */
+            }
+            // `Object.getOwnPropertyNames` covers non-enumerable own props too.
+            // Lodash attaches a few methods that aren't enumerable; more importantly
+            // some packages mark exports non-enumerable on purpose.
+            try {
+                for (const k of Object.getOwnPropertyNames(mod)) {
+                    if (RESERVED.has(k) || !VALID_IDENT.test(k))
+                        continue;
+                    if (isFn && FUNCTION_INTERNAL.has(k))
+                        continue;
+                    collected.add(k);
+                }
+            }
+            catch {
+                /* exotic */
+            }
+            names = Array.from(collected);
+        }
+        else {
+            // Primitive default export (e.g. `module.exports = 'hello'`). No named exports possible.
+            names = [];
+        }
+    }
+    catch {
+        names = null;
+    }
+    cache.set(normalized, names);
+    return names || [];
+}
+//# sourceMappingURL=cjs-named-exports.js.map

package/hmr/helpers/cjs-named-exports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cjs-named-exports.js","sourceRoot":"","sources":["../../../../../packages/vite/hmr/helpers/cjs-named-exports.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,EAAE;AACF,mBAAmB;AACnB,8EAA8E;AAC9E,6EAA6E;AAC7E,0EAA0E;AAC1E,qBAAqB;AACrB,EAAE;AACF,oCAAoC;AACpC,EAAE;AACF,sDAAsD;AACtD,2EAA2E;AAC3E,2EAA2E;AAC3E,uEAAuE;AACvE,gEAAgE;AAChE,0CAA0C;AAC1C,EAAE;AACF,qEAAqE;AACrE,0EAA0E;AAC1E,wEAAwE;AACxE,sEAAsE;AACtE,qEAAqE;AACrE,yEAAyE;AACzE,uBAAuB;AACvB,EAAE;AACF,UAAU;AACV,2EAA2E;AAC3E,gCAAgC;AAChC,2EAA2E;AAC3E,2EAA2E;AAC3E,qEAAqE;AACrE,gBAAgB;AAChB,0EAA0E;AAC1E,UAAU;AAEV,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAE9B,MAAM,KAAK,GAAG,IAAI,GAAG,EAA2B,CAAC;AAEjD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;AAEpD,0EAA0E;AAC1E,uCAAuC;AACvC,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;AAE1F,MAAM,WAAW,GAAG,oBAAoB,CAAC;AAEzC,MAAM,UAAU,yBAAyB,CAAC,QAAiB;IAC1D,IAAI,CAAC,QAAQ,EAAE,CAAC;QACf,KAAK,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;SAAM,CAAC;QACP,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACxB,CAAC;AACF,CAAC;AAED,MAAM,UAAU,2BAA2B;IAC1C,OAAO,KAAK,CAAC,IAAI,CAAC;AACnB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,+BAA+B,CAAC,KAAgC;IAC/E,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IAC7C,qEAAqE;IACrE,IAAI,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3B,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5B,CAAC;IACD,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACrC,IAAI,CAAC;QACJ,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE;YAAE,OAAO,IAAI,CAAC;IAC3C,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,IAAI,CAAC;IACb,CAAC;IACD,OAAO,CAAC,CAAC;AACV,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,YAAuC;IACzE,MAAM,UAAU,GAAG,+BAA+B,CAAC,YAAY,CAAC,CAAC;IACjE,IAAI,CAAC,UAAU;QAAE,OAAO,EAAE,CAAC;IAE3B,oFAAoF;IACpF,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,UAAU,CAAC;QAAE,OAAO,EAAE,CAAC;IAE1D,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACrC,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,IAAI,EAAE,CAAC;IAE9C,IAAI,KAAK,GAAoB,IAAI,CAAC;IAClC,IAAI,CAAC;QACJ,mEAAmE;QACnE,mEAAmE;QACnE,mEAAmE;QACnE,MAAM,GAAG,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC;QACtC,MAAM,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC;QAE5B,MAAM,SAAS,GAAG,IAAI,GAAG,EAAU,CAAC;QACpC,MAAM,IAAI,GAAG,OAAO,GAAG,KAAK,UAAU,CAAC;QAEvC,IAAI,GAAG,IAAI,CAAC,OAAO,GAAG,KAAK,QAAQ,IAAI,IAAI,CAAC,EAAE,CAAC;YAC9C,uEAAuE;YACvE,iEAAiE;YACjE,IAAI,CAAC;gBACJ,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;oBAClC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;wBAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAC/D,CAAC;YACF,CAAC;YAAC,MAAM,CAAC;gBACR,uBAAuB;YACxB,CAAC;YACD,oEAAoE;YACpE,yEAAyE;YACzE,wDAAwD;YACxD,IAAI,CAAC;gBACJ,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,mBAAmB,CAAC,GAAG,CAAC,EAAE,CAAC;oBACjD,IAAI,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;wBAAE,SAAS;oBACtD,IAAI,IAAI,IAAI,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC;wBAAE,SAAS;oBAC/C,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAClB,CAAC;YACF,CAAC;YAAC,MAAM,CAAC;gBACR,YAAY;YACb,CAAC;YACD,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC/B,CAAC;aAAM,CAAC;YACP,yFAAyF;YACzF,KAAK,GAAG,EAAE,CAAC;QACZ,CAAC;IACF,CAAC;IAAC,MAAM,CAAC;QACR,KAAK,GAAG,IAAI,CAAC;IACd,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IAC7B,OAAO,KAAK,IAAI,EAAE,CAAC;AACpB,CAAC"}

package/hmr/server/constants.d.ts

@@ -4,6 +4,7 @@ export declare const IMPORT_PATTERN_1: RegExp;
 export declare const IMPORT_PATTERN_2: RegExp;
 export declare const EXPORT_PATTERN: RegExp;
 export declare const IMPORT_PATTERN_3: RegExp;
+export declare const IMPORT_PATTERN_SIDE_EFFECT: RegExp;
 export declare const VUE_FILE_PATTERN: RegExp;
 export declare const VUE_FILE_IMPORT: RegExp;
 export declare const VITE_CLIENT_IMPORT: RegExp;

package/hmr/server/constants.js

@@ -5,13 +5,24 @@ export const QUERY_PATTERN = /\?.*$/;
 // Detect whether Vite's variable dynamic import helper is already inlined
 export const VARIABLE_DYNAMIC_IMPORT_HELPER_PATTERN = /__variableDynamicImportRuntimeHelper\s*=/;
 // Import/export matchers (static and dynamic)
-export const IMPORT_PATTERN_1 = /(?:^|\n)(\s*import\s+[^'";]*?\s+from\s+["'])([^"']+)(["'];?)/g;
-export const IMPORT_PATTERN_2 = /(?:^|\n)(\s*export\s+[^'";]*?\s+from\s+["'])([^"']+)(["'];?)/g;
+//
+// Each pattern's first capture group includes the optional leading anchor
+// (`^|\n`) so the replacement function preserves the line break that would
+// otherwise be silently consumed by the regex engine. Without this, two
+// concatenated patterns like:
+//   `})();\nexport * from "a"\nexport * from "b"`
+// would collapse to:
+//   `})();export * from "a"export * from "b"`
+// because each `(?:^|\n)` ate a newline that no replacement string put back.
+export const IMPORT_PATTERN_1 = /((?:^|\n)\s*import\s+[^'";]*?\s+from\s+["'])([^"']+)(["'];?)/g;
+export const IMPORT_PATTERN_2 = /((?:^|\n)\s*export\s+[^'";]*?\s+from\s+["'])([^"']+)(["'];?)/g;
 export const EXPORT_PATTERN = IMPORT_PATTERN_2;
 export const IMPORT_PATTERN_3 = /(import\(\s*["'])([^"']+)(["']\s*\))/g;
+// Side-effect imports: import "spec" / import 'spec' (no `from`, no bindings)
+export const IMPORT_PATTERN_SIDE_EFFECT = /((?:^|\n)\s*import\s+["'])([^"']+)(["'];?)/g;
 // Vue-specific patterns
 export const VUE_FILE_PATTERN = /\.vue(?:\?[^"']*)?$/;
-export const VUE_FILE_IMPORT = /(?:^|\n)(\s*import\s+[^'";]*?\s+from\s+["'])([^"']+\.vue(?:\?[^"']*)?)(["'];?)/g;
+export const VUE_FILE_IMPORT = /((?:^|\n)\s*import\s+[^'";]*?\s+from\s+["'])([^"']+\.vue(?:\?[^"']*)?)(["'];?)/g;
 // Vite/HMR noise cleanup
 export const VITE_CLIENT_IMPORT = /(?:^|\n)\s*import\s+['"](?:\/@vite\/client|@vite\/client)['"];?/g;
 // Strip Vite's injected `import.meta.hot = __vite__createHotContext(...)` assignment.

package/hmr/server/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../../packages/vite/hmr/server/constants.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,qGAAqG;AAErG,uBAAuB;AACvB,MAAM,CAAC,MAAM,aAAa,GAAG,OAAO,CAAC;AAErC,0EAA0E;AAC1E,MAAM,CAAC,MAAM,sCAAsC,GAAG,0CAA0C,CAAC;AAEjG,8CAA8C;AAC9C,MAAM,CAAC,MAAM,gBAAgB,GAAG,+DAA+D,CAAC;AAChG,MAAM,CAAC,MAAM,gBAAgB,GAAG,+DAA+D,CAAC;AAChG,MAAM,CAAC,MAAM,cAAc,GAAG,gBAAgB,CAAC;AAC/C,MAAM,CAAC,MAAM,gBAAgB,GAAG,uCAAuC,CAAC;AAExE,wBAAwB;AACxB,MAAM,CAAC,MAAM,gBAAgB,GAAG,qBAAqB,CAAC;AACtD,MAAM,CAAC,MAAM,eAAe,GAAG,iFAAiF,CAAC;AAEjH,yBAAyB;AACzB,MAAM,CAAC,MAAM,kBAAkB,GAAG,kEAAkE,CAAC;AACrG,sFAAsF;AACtF,wFAAwF;AACxF,2CAA2C;AAC3C,MAAM,CAAC,MAAM,0BAA0B,GAAG,sCAAsC,CAAC;AACjF,MAAM,CAAC,MAAM,qBAAqB,GAAG,+DAA+D,CAAC;AAErG,uEAAuE;AACvE,MAAM,CAAC,MAAM,iBAAiB,GAAG,kEAAkE,CAAC;AACpG,MAAM,CAAC,MAAM,qBAAqB,GAAG,sEAAsE,CAAC;AAC5G,MAAM,CAAC,MAAM,qBAAqB,GAAG,+CAA+C,CAAC"}
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../../packages/vite/hmr/server/constants.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,qGAAqG;AAErG,uBAAuB;AACvB,MAAM,CAAC,MAAM,aAAa,GAAG,OAAO,CAAC;AAErC,0EAA0E;AAC1E,MAAM,CAAC,MAAM,sCAAsC,GAAG,0CAA0C,CAAC;AAEjG,8CAA8C;AAC9C,EAAE;AACF,0EAA0E;AAC1E,2EAA2E;AAC3E,wEAAwE;AACxE,8BAA8B;AAC9B,kDAAkD;AAClD,qBAAqB;AACrB,8CAA8C;AAC9C,6EAA6E;AAC7E,MAAM,CAAC,MAAM,gBAAgB,GAAG,+DAA+D,CAAC;AAChG,MAAM,CAAC,MAAM,gBAAgB,GAAG,+DAA+D,CAAC;AAChG,MAAM,CAAC,MAAM,cAAc,GAAG,gBAAgB,CAAC;AAC/C,MAAM,CAAC,MAAM,gBAAgB,GAAG,uCAAuC,CAAC;AACxE,8EAA8E;AAC9E,MAAM,CAAC,MAAM,0BAA0B,GAAG,6CAA6C,CAAC;AAExF,wBAAwB;AACxB,MAAM,CAAC,MAAM,gBAAgB,GAAG,qBAAqB,CAAC;AACtD,MAAM,CAAC,MAAM,eAAe,GAAG,iFAAiF,CAAC;AAEjH,yBAAyB;AACzB,MAAM,CAAC,MAAM,kBAAkB,GAAG,kEAAkE,CAAC;AACrG,sFAAsF;AACtF,wFAAwF;AACxF,2CAA2C;AAC3C,MAAM,CAAC,MAAM,0BAA0B,GAAG,sCAAsC,CAAC;AACjF,MAAM,CAAC,MAAM,qBAAqB,GAAG,+DAA+D,CAAC;AAErG,uEAAuE;AACvE,MAAM,CAAC,MAAM,iBAAiB,GAAG,kEAAkE,CAAC;AACpG,MAAM,CAAC,MAAM,qBAAqB,GAAG,sEAAsE,CAAC;AAC5G,MAAM,CAAC,MAAM,qBAAqB,GAAG,+CAA+C,CAAC"}

package/hmr/server/core-sanitize.d.ts

@@ -8,8 +8,8 @@
  *   "@nativescript/core/index.js";
  * This trips the sanitizer's local-core-path detector and breaks HTTP ESM loading.
  *
- * This helper safely maps those literals to:
- *   import "/ns/core?p=index.js";
+ * This helper safely maps those literals to the canonical path form:
+ *   import "/ns/core/<sub>";   // subpath form, no version, no ?p=
  * or, without subpath:
  *   import "/ns/core";
  */
@@ -30,3 +30,50 @@ export declare function fixDanglingCoreFrom(code: string): string;
  * into the unified '/ns/core' bridge before fast-fail assertions.
  */
 export declare function normalizeAnyCoreSpecToBridge(code: string): string;
+/**
+ * Minimal specifier rewriter for deep subpath core modules.
+ *
+ * Takes Vite's correctly-transformed ESM output and ONLY rewrites the
+ * specifier strings inside import/export clauses. Does NOT:
+ *   - Inject global defines
+ *   - Run AST normalization
+ *   - Convert named imports to default + destructure
+ *   - Mangle newlines or code structure
+ *
+ * This replaces the heavy 5-pass pipeline (processCodeForDevice →
+ * rewriteImports → deduplicateLinkerImports → CJS wrapping → etc.)
+ * for deep subpath core modules where Vite already produces correct ESM.
+ */
+export declare function rewriteSpecifiersForDevice(code: string, origin: string, ver: number): string;
+/**
+ * Determine whether a `/ns/core` bridge URL points to a real subpath module.
+ *
+ * Any `/ns/core/<sub>` module now serves real ESM content with real named
+ * exports via Vite's transform pipeline, except for package-main aliases like
+ * `/ns/core/index`, which should be treated like the main `/ns/core`
+ * bridge and destructured from its default export.
+ * The main proxy bridge (`/ns/core`) still only exports a default Proxy and
+ * requires named imports to be destructured from it.
+ *
+ * This check is used in all named-import-to-default destructuring passes to
+ * skip rewriting for real subpath modules — they have named exports that work
+ * natively without conversion.
+ *
+ * Accepts both the canonical path form (`/ns/core/<sub>`) and the legacy
+ * query form (`/ns/core?p=<sub>`) for back-compat; every emitter has been
+ * migrated to the path form but external code may still carry the old URL.
+ */
+export declare function isDeepCoreSubpath(url: string): boolean;
+/**
+ * Synthesize a `default` export for an ESM module that only has named/star
+ * exports. Utility function — not currently called from the core bridge
+ * handler since `ensureDestructureCoreImports` now skips deep subpaths.
+ *
+ * Handles all three @nativescript/core patterns:
+ *   1. Direct declarations: export class X, export function Y, export const Z
+ *   2. Named re-exports:   export { A, B } from '/path'
+ *   3. Star re-exports:    export * from '/path'
+ *
+ * Returns the code unchanged if it already has a default export or CJS exports.
+ */
+export declare function synthesizeDefaultExport(moduleCode: string): string;

package/hmr/server/core-sanitize.js

@@ -1,3 +1,4 @@
+import { buildCoreUrlPath } from '../../helpers/ns-core-url.js';
 /**
  * Rewrites stray string-literal side-effect lines that reference @nativescript/core
  * into proper ESM import statements targeting the unified /ns/core bridge.
@@ -8,8 +9,8 @@
  *   "@nativescript/core/index.js";
  * This trips the sanitizer's local-core-path detector and breaks HTTP ESM loading.
  *
- * This helper safely maps those literals to:
- *   import "/ns/core?p=index.js";
+ * This helper safely maps those literals to the canonical path form:
+ *   import "/ns/core/<sub>";   // subpath form, no version, no ?p=
  * or, without subpath:
  *   import "/ns/core";
  */
@@ -18,26 +19,21 @@ export function normalizeStrayCoreStringLiterals(code) {
         return code;
     try {
         let out = code;
+        const toCoreBridgeUrl = (sub) => buildCoreUrlPath(sub);
         // Normalize any concatenated imports on the same line to start on a new line
         // e.g. `...;import x from` -> `...;\nimport x from`
         out = out.replace(/;\s*import\s+/g, ';\nimport ');
         // Case 1: inline literal followed by another import on SAME line
         // Example: "@nativescript/core/index.js";import { x } from "...";
         out = out.replace(/(["']@nativescript\/core([^"']*)["'];)(\s*import\s+)/g, (_m, _lit, sub, after) => {
-            const qp = String(sub || '')
-                .trim()
-                .replace(/^\//, '');
-            const url = qp ? `/ns/core?p=${qp}` : '/ns/core';
+            const url = toCoreBridgeUrl(sub);
             return `import "${url}";${after}`;
         });
         // Case 2: standalone literal on its own line (not a JSON key) — must be end-of-line
         // Guard with EOL so we don't rewrite JSON keys like "@nativescript/core": "alpha"
         const reLine = /(^|\n)([\t ]*)["']@nativescript\/core([^"']*)["']\s*;?\s*(?=$|\n)/g;
         out = out.replace(reLine, (_full, prefix, indent, sub) => {
-            const qp = String(sub || '')
-                .trim()
-                .replace(/^\//, '');
-            const url = qp ? `/ns/core?p=${qp}` : '/ns/core';
+            const url = toCoreBridgeUrl(sub);
             return `${prefix}${indent}import "${url}";`;
         });
         return out;
@@ -63,7 +59,9 @@ export function fixDanglingCoreFrom(code) {
         code = code.replace(/;\s*import\s+/g, ';\nimport ');
         // Multi-line form: import { ...\n  ...\n} from\nimport "<core-url>";[tail]
         // Merge into: import { ... } from "<core-url>";\n[tail]
-        code = code.replace(/(^|\n|;)\s*import\s*\{([\s\S]*?)\}\s*from\s*\n\s*import\s+["']((?:https?:\/\/[^"']+)?\/ns\/core(?:\/\d+)?(?:\?p=[^"']+)?)["'];?(.*)/g, (_m, pre, named, url, tail) => {
+        // Accepts canonical path form (/ns/core/<sub>), legacy query form
+        // (/ns/core?p=<sub>), and versioned-path form (/ns/core/<ver>/<sub>).
+        code = code.replace(/(^|\n|;)\s*import\s*\{([\s\S]*?)\}\s*from\s*\n\s*import\s+["']((?:https?:\/\/[^"']+)?\/ns\/core(?:\/[^"']*)?(?:\?p=[^"']+)?)["'];?(.*)/g, (_m, pre, named, url, tail) => {
             const prefix = pre ? (String(pre).endsWith(';') ? String(pre) + '\n' : String(pre)) : '';
             const tailNorm = (tail || '').replace(/^\s*;?\s*/, '').trim();
             return prefix + `import {${named}} from "${url}";` + (tailNorm ? `\n${tailNorm}` : '');
@@ -77,7 +75,7 @@ export function fixDanglingCoreFrom(code) {
                 const next = lines[i + 1];
                 // Support when the next line starts with the core import followed by another ';import ...'
                 // Capture the core import URL and any trailing content after it (another import concatenated)
-                const m2 = /^\s*import\s+["']((?:https?:\/\/[^"']+)?\/ns\/core(?:\/\d+)?(?:\?p=[^"']+)?)["'];?(.*)$/.exec(next);
+                const m2 = /^\s*import\s+["']((?:https?:\/\/[^"']+)?\/ns\/core(?:\/[^"']*)?(?:\?p=[^"']+)?)["'];?(.*)$/.exec(next);
                 if (m2) {
                     const url = m2[1];
                     const tail = m2[2] || '';
@@ -109,26 +107,271 @@ export function normalizeAnyCoreSpecToBridge(code) {
         return code;
     try {
         let out = code;
-        const toQp = (sub) => {
-            const s = String(sub || '')
-                .split('?')[0]
-                .trim()
-                .replace(/^\//, '');
-            return s ? `?p=${s}` : '';
-        };
+        const toCoreBridgeUrl = (sub) => buildCoreUrlPath(sub);
         // Static: import ... from "...@nativescript/core[/sub]..."
-        out = out.replace(/from\s+["'][^"']*@nativescript[\/_-]core([^"']*)["']/g, (_m, sub) => `from "/ns/core${toQp(sub)}"`);
+        out = out.replace(/from\s+["'][^"']*@nativescript[\/_-]core([^"']*)["']/g, (_m, sub) => `from "${toCoreBridgeUrl(sub)}"`);
         // Side-effect: import "...@nativescript/core[/sub]..."
-        out = out.replace(/(^|\n)\s*import\s+["'][^"']*@nativescript[\/_-]core([^"']*)["'];?/gm, (full, pfx, sub) => `${pfx}import "/ns/core${toQp(sub)}";`);
+        out = out.replace(/(^|\n)\s*import\s+["'][^"']*@nativescript[\/_-]core([^"']*)["'];?/gm, (full, pfx, sub) => `${pfx}import "${toCoreBridgeUrl(sub)}";`);
         // Dynamic: import("...@nativescript/core[/sub]...")
-        out = out.replace(/import\(\s*["'][^"']*@nativescript[\/_-]core([^"']*)["']\s*\)/g, (_m, sub) => `import("/ns/core${toQp(sub)}")`);
+        out = out.replace(/import\(\s*["'][^"']*@nativescript[\/_-]core([^"']*)["']\s*\)/g, (_m, sub) => `import("${toCoreBridgeUrl(sub)}")`);
         // Repair glitch where a previous pass split/merged lines into: "from import '/ns/core...'"
-        // Normalize to a valid specifier: "from '/ns/core...'"
-        out = out.replace(/from\s+import\s+["']((?:https?:\/\/[^"']+)?\/ns\/core(?:\/[0-9]+)?(?:\?p=[^"']+)?)['"]/g, (_m, url) => `from "${url}"`);
+        // Normalize to a valid specifier: "from '/ns/core...'". Accepts both
+        // canonical path form (/ns/core/<sub>) and legacy ?p= form.
+        out = out.replace(/from\s+import\s+["']((?:https?:\/\/[^"']+)?\/ns\/core(?:\/[^"']*)?(?:\?p=[^"']+)?)['"]/g, (_m, url) => `from "${url}"`);
         return out;
     }
     catch {
         return code;
     }
 }
+/**
+ * Rewrite a single import/export specifier for device consumption.
+ *
+ * Converts Vite-resolved root-relative paths to URLs the device can fetch:
+ *   /node_modules/@nativescript/core/x/y  →  /ns/core/x/y   (canonical)
+ *   /node_modules/other-pkg/x.js          →  {origin}/ns/m/node_modules/other-pkg/x.js
+ *   /src/app/foo.ts                       →  {origin}/ns/m/src/app/foo.ts
+ *   already /ns/... or http://...         →  unchanged
+ */
+function rewriteSpec(spec, origin, ver) {
+    void ver;
+    // Strip Vite cache-busting query params for bridge URLs
+    const cleanSpec = spec.split('?')[0];
+    // @nativescript/core anywhere in the path → core bridge.
+    // Delegated to the ONE canonical URL generator to guarantee that
+    // every emitter — this function, the ns-core-external-urls plugin,
+    // main-entry's coreSpec, and the runtime import map — produces
+    // byte-identical URLs for the same logical module. Mixed forms
+    // (query `?p=`, versioned, `.js` suffix) would otherwise produce
+    // distinct iOS HTTP ESM cache entries for the same file,
+    // re-evaluating register() side effects and crashing on "Cannot
+    // redefine property".
+    const coreIdx = cleanSpec.indexOf('@nativescript/core');
+    if (coreIdx !== -1) {
+        const after = cleanSpec.substring(coreIdx + '@nativescript/core'.length);
+        return buildCoreUrlPath(after);
+    }
+    // Already a bridge, vendor, or HTTP URL → leave unchanged
+    if (spec.startsWith('/ns/') || spec.startsWith('http://') || spec.startsWith('https://') || spec.startsWith('ns-vendor://')) {
+        return spec;
+    }
+    // Leave relative specifiers for Vite/rolldown to resolve (they do not
+    // appear after Vite transform but the guard is free)
+    if (spec.startsWith('./') || spec.startsWith('../')) {
+        return spec;
+    }
+    // Root-relative paths → HTTP URL through /ns/m/ handler
+    if (spec.startsWith('/')) {
+        return `${origin}/ns/m${spec}`;
+    }
+    // Bare package specifier (e.g. `source-map-js/lib/source-map-generator.js`)
+    // → HTTP URL through /ns/m/node_modules/ handler. Under HMR bundle-build,
+    // @nativescript/core subpath modules served by this bridge (e.g.
+    // /ns/core?p=inspector_modules) may reference other npm packages with bare
+    // specifiers in their transformed output — specifically, the CommonJS
+    // compat transformer for source-map-js rewrites `require('./lib/source-
+    // map-generator')` into `import from 'source-map-js/lib/source-map-
+    // generator.js'`, a bare specifier that iOS's ESM loader cannot resolve at
+    // module-instantiation time (the runtime import map isn't installed yet).
+    // Converting to /ns/m/node_modules/<spec> makes iOS fetch the package over
+    // HTTP, which Vite serves through the same pipeline that already handles
+    // every other node_modules subpath import in the app.
+    return `${origin}/ns/m/node_modules/${spec}`;
+}
+/**
+ * Minimal specifier rewriter for deep subpath core modules.
+ *
+ * Takes Vite's correctly-transformed ESM output and ONLY rewrites the
+ * specifier strings inside import/export clauses. Does NOT:
+ *   - Inject global defines
+ *   - Run AST normalization
+ *   - Convert named imports to default + destructure
+ *   - Mangle newlines or code structure
+ *
+ * This replaces the heavy 5-pass pipeline (processCodeForDevice →
+ * rewriteImports → deduplicateLinkerImports → CJS wrapping → etc.)
+ * for deep subpath core modules where Vite already produces correct ESM.
+ */
+export function rewriteSpecifiersForDevice(code, origin, ver) {
+    if (!code)
+        return code;
+    let result = code;
+    // Pattern 1: from "specifier" — covers all static import/export forms
+    //   import { X } from "spec"
+    //   import X from "spec"
+    //   import * as X from "spec"
+    //   export { X } from "spec"
+    //   export * from "spec"
+    //
+    // The lookbehind guard below ensures we only match `from` at the start of
+    // its ESM-keyword context, not `from` appearing INSIDE a string literal
+    // (e.g. `if (time === 'from') { … }` in @nativescript/core's
+    // css-animation-parser). Without this guard the regex spans from the
+    // `from` inside the string to the NEXT quote elsewhere in the file,
+    // corrupting both tokens.
+    result = result.replace(/(?<![a-zA-Z0-9_$'"`])(from\s+)(["'])([^"']+)\2/g, (_m, pre, q, spec) => {
+        return `${pre}${q}${rewriteSpec(spec, origin, ver)}${q}`;
+    });
+    // Pattern 2: import("specifier") — dynamic imports
+    result = result.replace(/(import\s*\(\s*)(["'])([^"']+)\2(\s*\))/g, (_m, pre, q, spec, post) => {
+        return `${pre}${q}${rewriteSpec(spec, origin, ver)}${q}${post}`;
+    });
+    // Pattern 3: import "specifier" — side-effect imports (no from clause)
+    // Anchored after start-of-string, newline, or semicolon to avoid false matches.
+    // The `^` alternative is critical: when a transformed module's body begins
+    // with a side-effect import (no preceding `;` or `\n`), the legacy
+    // `[;\n]`-only anchor missed it and the URL leaked to the device unmodified.
+    // Concrete failure mode: `/ns/core/inspector_modules` whose first body line
+    // `import '/@fs/.../@nativescript/core/globals/index.js';` was served raw,
+    // producing a `__DEV__ is not defined` ReferenceError in `platform-check.js`
+    // because `/@fs/` URLs bypass the `/ns/core` bridge's define-injection.
+    result = result.replace(/(^|[;\n])(\s*import\s+)(["'])([^"']+)\3/g, (_m, lead, pre, q, spec) => {
+        // Skip if it looks like an identifier rather than a path
+        if (!/[/.@]/.test(spec))
+            return _m;
+        return `${lead}${pre}${q}${rewriteSpec(spec, origin, ver)}${q}`;
+    });
+    return result;
+}
+/**
+ * Determine whether a `/ns/core` bridge URL points to a real subpath module.
+ *
+ * Any `/ns/core/<sub>` module now serves real ESM content with real named
+ * exports via Vite's transform pipeline, except for package-main aliases like
+ * `/ns/core/index`, which should be treated like the main `/ns/core`
+ * bridge and destructured from its default export.
+ * The main proxy bridge (`/ns/core`) still only exports a default Proxy and
+ * requires named imports to be destructured from it.
+ *
+ * This check is used in all named-import-to-default destructuring passes to
+ * skip rewriting for real subpath modules — they have named exports that work
+ * natively without conversion.
+ *
+ * Accepts both the canonical path form (`/ns/core/<sub>`) and the legacy
+ * query form (`/ns/core?p=<sub>`) for back-compat; every emitter has been
+ * migrated to the path form but external code may still carry the old URL.
+ */
+export function isDeepCoreSubpath(url) {
+    if (!url || typeof url !== 'string')
+        return false;
+    // Legacy query form
+    const query = url.match(/\?p=([^&'"#]+)/);
+    if (query) {
+        const sub = String(query[1] || '').replace(/^\/+/, '');
+        if (!sub || sub === 'index' || sub === 'index.js')
+            return false;
+        return true;
+    }
+    // Canonical path form — extract the subpath segment following /ns/core/.
+    const path = url.match(/\/ns\/core\/([^?#]+)/);
+    if (!path)
+        return false;
+    const sub = String(path[1] || '').replace(/^\/+|\/+$/g, '');
+    if (!sub || sub === 'index' || sub === 'index.js')
+        return false;
+    return true;
+}
+/**
+ * Synthesize a `default` export for an ESM module that only has named/star
+ * exports. Utility function — not currently called from the core bridge
+ * handler since `ensureDestructureCoreImports` now skips deep subpaths.
+ *
+ * Handles all three @nativescript/core patterns:
+ *   1. Direct declarations: export class X, export function Y, export const Z
+ *   2. Named re-exports:   export { A, B } from '/path'
+ *   3. Star re-exports:    export * from '/path'
+ *
+ * Returns the code unchanged if it already has a default export or CJS exports.
+ */
+export function synthesizeDefaultExport(moduleCode) {
+    if (!moduleCode || typeof moduleCode !== 'string')
+        return moduleCode;
+    const hasExportDefault = /\bexport\s+default\b/.test(moduleCode) || /export\s*\{\s*default\s*(?:as\s*default)?\s*\}/.test(moduleCode);
+    if (hasExportDefault)
+        return moduleCode;
+    const hasCjsExports = /\bmodule\s*\.\s*exports\b/.test(moduleCode) || /\bexports\s*\.\s*\w/.test(moduleCode);
+    if (hasCjsExports)
+        return moduleCode;
+    try {
+        const bindings = []; // [localName, exportedName]
+        const extraImports = [];
+        const starSpreads = [];
+        let sIdx = 0;
+        let m;
+        // export { A, b as B } [from 'src'] — handles both local and re-exports
+        const reBraces = /\bexport\s*\{([^}]+)\}\s*(?:from\s*["']([^"']+)["'])?/g;
+        while ((m = reBraces.exec(moduleCode)) !== null) {
+            const specList = m[1];
+            const fromSrc = m[2]; // undefined for local exports
+            const specs = specList
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean);
+            for (const spec of specs) {
+                const parts = spec.split(/\s+as\s+/);
+                const srcName = parts[0].trim();
+                const expName = parts.length > 1 ? parts[1].trim() : srcName;
+                if (!expName || expName === 'default')
+                    continue;
+                // For re-exports, the local name is the exported name (from the import we add below)
+                // For local exports, the local name is srcName (already in scope)
+                bindings.push(fromSrc ? [expName, expName] : [srcName, expName]);
+            }
+            if (fromSrc) {
+                const importSpecs = specs
+                    .map((spec) => {
+                    const parts = spec.split(/\s+as\s+/);
+                    const srcName = parts[0].trim();
+                    const expName = parts.length > 1 ? parts[1].trim() : srcName;
+                    if (!expName || expName === 'default')
+                        return '';
+                    return parts.length > 1 ? `${srcName} as ${expName}` : expName;
+                })
+                    .filter(Boolean);
+                if (importSpecs.length) {
+                    extraImports.push(`import { ${importSpecs.join(', ')} } from ${JSON.stringify(fromSrc)};`);
+                }
+            }
+        }
+        // export const/let/var X
+        const reDecl = /\bexport\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/g;
+        while ((m = reDecl.exec(moduleCode)) !== null) {
+            bindings.push([m[1], m[1]]);
+        }
+        // export [async] function[*]/class X
+        const reFunc = /\bexport\s+(?:async\s+)?(?:function\s*\*?|class)\s+([A-Za-z_$][\w$]*)/g;
+        while ((m = reFunc.exec(moduleCode)) !== null) {
+            bindings.push([m[1], m[1]]);
+        }
+        // export * as X from 'src' (namespace re-export)
+        const reStarAs = /\bexport\s*\*\s*as\s+([A-Za-z_$][\w$]*)\s+from\s*["']([^"']+)["']/g;
+        while ((m = reStarAs.exec(moduleCode)) !== null) {
+            extraImports.push(`import * as ${m[1]} from ${JSON.stringify(m[2])};`);
+            bindings.push([m[1], m[1]]);
+        }
+        // export * from 'src' (bare star re-export, NOT 'export * as')
+        const reStarBare = /\bexport\s*\*\s*(?!as\s)from\s*["']([^"']+)["']/g;
+        while ((m = reStarBare.exec(moduleCode)) !== null) {
+            const v = `__ns_star_${sIdx++}`;
+            extraImports.push(`import * as ${v} from ${JSON.stringify(m[1])};`);
+            starSpreads.push(`...${v}`);
+        }
+        if (bindings.length > 0 || starSpreads.length > 0) {
+            const entries = [...starSpreads];
+            const seen = new Set();
+            for (const [local, exported] of bindings) {
+                if (seen.has(exported))
+                    continue;
+                seen.add(exported);
+                entries.push(local === exported ? exported : `${JSON.stringify(exported)}: ${local}`);
+            }
+            const prefix = extraImports.length ? extraImports.join('\n') + '\n' : '';
+            return prefix + moduleCode + `\nvar __ns_default_export = { ${entries.join(', ')} };\nexport { __ns_default_export as default };\n`;
+        }
+        return moduleCode;
+    }
+    catch {
+        return moduleCode;
+    }
+}
 //# sourceMappingURL=core-sanitize.js.map