@nativescript/vite 8.0.0-alpha.2 → 8.0.0-alpha.20

package/hmr/shared/vendor/manifest.js

@@ -1,12 +1,13 @@
 import * as esbuild from 'esbuild';
 import { readFile } from 'fs/promises';
 import path from 'path';
-import { readFileSync } from 'fs';
+import fs, { readFileSync } from 'fs';
 import { createHash } from 'crypto';
 import { createRequire } from 'node:module';
 import { registerVendorManifest, clearVendorManifest, getVendorManifest } from './registry.js';
 import { generatePlatformPolyfills } from '../runtime/platform-polyfills.js';
 import { createNativeClassEsbuildPlugin } from '../../../helpers/nativeclass-esbuild-plugin.js';
+import { getGlobalDefines } from '../../../helpers/global-defines.js';
 export const VENDOR_MANIFEST_ID = '@nativescript/vendor-manifest';
 export const VENDOR_MANIFEST_VIRTUAL_ID = '\0' + VENDOR_MANIFEST_ID;
 export const VENDOR_BUNDLE_ID = '@nativescript/vendor';
@@ -162,7 +163,7 @@ export function vendorManifestPlugin(options) {
             const result = await ensureResult('server');
             if (req.url === SERVER_VENDOR_PATH) {
                 res.setHeader('Content-Type', 'application/javascript');
-                res.end(result.code);
+                res.end(createVendorBundleRuntimeModule(result));
                 return true;
             }
             if (req.url === SERVER_MANIFEST_PATH) {
@@ -229,15 +230,8 @@ export function vendorManifestPlugin(options) {
             }
             if (id === VENDOR_BUNDLE_VIRTUAL_ID) {
                 const result = await ensureResult('load-bundle');
-                // Return a single self-contained module that includes both the vendor module map
-                // and the vendor manifest to avoid extra imports that can influence chunking.
-                // - result.code exports `__nsVendorModuleMap`
-                // - we append an inline manifest export
                 return {
-                    code: `${result.code}
-export const vendorManifest = ${JSON.stringify(result.manifest)};
-export default vendorManifest;
-`,
+                    code: createVendorBundleRuntimeModule(result),
                     moduleType: 'js',
                 };
             }
@@ -275,7 +269,62 @@ async function generateVendorBundle(options) {
     const { projectRoot, platform, mode, flavor } = options;
     const collected = collectVendorModules(projectRoot, platform, flavor);
     const entryCode = createVendorEntry(collected.entries);
+    // Externalize @nativescript/core and its subpaths in the vendor bundle so
+    // vendored packages (e.g. @nativescript-community/ui-material-bottomsheet)
+    // do NOT bring their own copy of core with them. The iOS import map maps
+    // `@nativescript/core` → `/ns/core` (the core bridge) at runtime, and the
+    // bridge delegates to the canonical Application/View/etc. already set up
+    // by bundle.mjs via installCoreAliasesEarly + the globalThis.Application
+    // seed. Without this externalization, vendor.mjs bundles a second copy of
+    // iOSApplication/View/LayoutBase — the second iosApp never receives the
+    // iOS launch event (bundle.mjs's iosApp registered first as
+    // UIApplication.delegate), so Application.getRootView() on it returns
+    // undefined, and any vendor-internal code that reads .getRootView() or
+    // checks `instanceof View` against bundle's classes fails under HMR.
+    const nsCoreExternalPlugin = {
+        name: 'ns-core-external',
+        setup(build) {
+            build.onResolve({ filter: /^@nativescript\/core(?:\/.*)?$/ }, (args) => ({
+                path: args.path,
+                external: true,
+            }));
+        },
+    };
+    // Externalize the `solid-js` root specifier for the Solid flavor so
+    // vendor-bundled packages (e.g. `@nativescript-community/solid-js`,
+    // `solid-navigation`, transitively `solid-js/universal` and
+    // `solid-js/store`) don't bake their own copy of solid-js into
+    // vendor.mjs. The dev server's import map (see `import-map.ts`)
+    // redirects bare `solid-js` to the same `/ns/m/node_modules/solid-js/...`
+    // URL that Vite's alias produces for user code and `@solid-refresh`,
+    // so V8 dedupes the three import paths down to a single module
+    // instance — one `Owner` module-local, one reactive graph, one
+    // `$DEVCOMP`/`$PROXY` symbol identity across the whole app.
+    //
+    // Important: scope this to the EXACT bare `solid-js` specifier. Subpaths
+    // like `solid-js/store`, `solid-js/universal`, `solid-js/web` stay
+    // bundleable so vendor packages that import them keep working out of
+    // the box; those subpaths still go through the unified solid-js
+    // runtime via their own `import 'solid-js'` statements (which we just
+    // externalized).
+    const nsSolidJsExternalPlugin = {
+        name: 'ns-solid-js-external',
+        setup(build) {
+            build.onResolve({ filter: /^solid-js$/ }, (args) => ({
+                path: args.path,
+                external: true,
+            }));
+        },
+    };
     const plugins = [
+        // Mark @nativescript/core external BEFORE other plugins so esbuild never
+        // tries to read/transform core's source files. See comment above.
+        nsCoreExternalPlugin,
+        // For the Solid flavor, externalize `solid-js` so vendor.mjs and the
+        // HTTP-served `@solid-refresh` / user code converge on one runtime
+        // realm. See `nsSolidJsExternalPlugin`'s definition for the full
+        // duplicate-instance rationale.
+        ...(flavor === 'solid' ? [nsSolidJsExternalPlugin] : []),
         // Apply NativeClass transformer to convert @NativeClass decorated classes to ES5 IIFE pattern.
         // This MUST run before other plugins to ensure proper transformation.
         createNativeClassEsbuildPlugin(platform),
@@ -336,9 +385,31 @@ async function generateVendorBundle(options) {
             '.css': 'text',
             '.json': 'json',
         },
-        define: {
-            'process.env.NODE_ENV': JSON.stringify(mode),
-        },
+        // Mirror Vite's main-bundle DefinePlugin in the vendor esbuild build.
+        //
+        // esbuild's `define` requires every value to be a JS expression
+        // expressed as a string (the same constraint Vite normalises away).
+        // `getGlobalDefines()` returns a few raw `boolean` values for
+        // historical reasons (e.g. `__COMMONJS__: false`,
+        // `__UI_USE_XML_PARSER__: true`), so coerce any non-string entries
+        // through `JSON.stringify` before handing the table to esbuild.
+        define: (() => {
+            const raw = getGlobalDefines({
+                platform,
+                targetMode: mode,
+                verbose: !!options.verbose,
+                flavor: flavor ?? '',
+                isCI: !!process.env.CI,
+            });
+            const out = {};
+            for (const [key, value] of Object.entries(raw)) {
+                out[key] = typeof value === 'string' ? value : JSON.stringify(value);
+            }
+            // Belt-and-suspenders: keep the original NODE_ENV define explicit so
+            // future changes to `getGlobalDefines()` can't silently drop it.
+            out['process.env.NODE_ENV'] = JSON.stringify(mode);
+            return out;
+        })(),
         plugins,
         // Externalize ALL Node built-in modules. The vendor bundle runs on the
         // NativeScript device runtime, not Node, so any Node API reference must
@@ -464,9 +535,17 @@ function collectVendorModules(projectRoot, platform, flavor) {
     const packageJsonPath = path.resolve(projectRoot, 'package.json');
     const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
     const projectRequire = createRequire(packageJsonPath);
+    const debug = process.env.VITE_DEBUG_LOGS === 'true' || process.env.VITE_DEBUG_LOGS === '1';
     const vendor = new Set();
     const visited = new Set();
     const queue = [];
+    // Local-source deps (file: pointing to a directory, link:, workspace:) are
+    // app code, not pre-packaged libraries. esbuild's vendor pipeline has none
+    // of the user's tsconfig path aliases or other Vite plugin resolvers, so
+    // any aliased import inside their source will fail with "Could not
+    // resolve". We collect their names here so that peer-dep traversal can
+    // also skip them.
+    const localSourceNames = new Set();
     const isPackageRootSpecifier = (name) => {
         if (!name)
             return false;
@@ -479,6 +558,7 @@ function collectVendorModules(projectRoot, platform, flavor) {
         return !name.includes('/');
     };
     const isAngularFlavor = flavor === 'angular';
+    const isSolidFlavor = flavor === 'solid';
     const addCandidate = (name) => {
         if (!name || shouldSkipDependency(name)) {
             return;
@@ -490,6 +570,29 @@ function collectVendorModules(projectRoot, platform, flavor) {
         if (!isAngularFlavor && (name === '@angular/compiler' || name.startsWith('@angular/'))) {
             return;
         }
+        // For the Solid flavor, keep `solid-js` itself OUT of the vendor bundle.
+        //
+        // Both `@solid-refresh` (served via HTTP) and Vite-aliased user code
+        // import `solid-js` through the dev server, while the vendor bundle
+        // pulls it in as a peerDependency of `@nativescript-community/solid-js`.
+        // Two copies → two `Owner` module-locals → the proxy memo created by
+        // `solid-refresh`'s `HMRComp` is registered on the HTTP copy's Owner
+        // (which is always null — hence the
+        // `computations created outside a createRoot or render` warning), while
+        // `render(App, doc)` runs against the vendor copy's Owner. Same chain
+        // breaks HMR propagation: `patchRegistry`'s `setComp` ticks the HTTP
+        // copy's signal but the live page tree subscribes through the vendor
+        // copy's reactive graph, so the new component body never reaches the
+        // screen.
+        //
+        // We pair this skip with the matching esbuild externalization
+        // (`nsSolidJsExternalPlugin`) and an import-map redirect in
+        // `import-map.ts` that points `solid-js` at the HTTP URL. All three
+        // converge on the same dev-server URL, V8 dedupes by URL, and the
+        // app sees a single `solid-js` realm.
+        if (isSolidFlavor && name === 'solid-js') {
+            return;
+        }
         // Skip already-visited packages to avoid redundant queue processing
         if (visited.has(name)) {
             return;
@@ -506,14 +609,35 @@ function collectVendorModules(projectRoot, platform, flavor) {
         if (!deps) {
             return;
         }
-        for (const name of Object.keys(deps)) {
+        for (const [name, spec] of Object.entries(deps)) {
+            if (isUnvendorableLocalSource(name, spec, projectRequire, platform)) {
+                // Defer to the regular Vite/Rolldown pipeline (HTTP-served in
+                // dev, bundled in production) where the
+                // ns-tsconfig-paths-resolver and the rest of the plugin chain
+                // can handle aliased imports. Local .tgz file: refs ARE proper
+                // packaged libraries and DO stay in vendor; so do file:
+                // directory refs that point at packages with compiled JS
+                // entry points (a common NativeScript monorepo pattern that
+                // hoists installs and re-exposes them from the app's
+                // package.json via `file:../../node_modules/<name>`).
+                localSourceNames.add(name);
+                if (debug) {
+                    console.log(`[vendor] skipping local source dependency ${name} (spec: ${String(spec)})`);
+                }
+                continue;
+            }
             addCandidate(name);
         }
     };
     addDeps(pkg.dependencies);
     addDeps(pkg.optionalDependencies);
     for (const name of ALWAYS_INCLUDE) {
-        addCandidate(name);
+        // Some force-included packages are only present transitively in apps that
+        // actually use them. Skip missing packages quietly so unrelated projects do
+        // not fail vendor collection just because the policy list names them.
+        if (canResolveDependencyPackageJson(name, projectRequire)) {
+            addCandidate(name);
+        }
     }
     // Ensure Android Activity proxy is present for SBG scanning in dev/HMR
     // and non-HMR builds alike: explicitly include the side-effect module
@@ -524,16 +648,10 @@ function collectVendorModules(projectRoot, platform, flavor) {
     if (pkg.dependencies?.['nativescript-vue'] && pkg.devDependencies?.vue) {
         addCandidate('vue');
     }
-    if (pkg.dependencies?.['@nativescript/angular']) {
-        if (pkg.dependencies?.['@angular/core']) {
-            addCandidate('@angular/core');
-        }
-        if (pkg.dependencies?.['@angular/common']) {
-            addCandidate('@angular/common');
-        }
-        // RxJS is large and not required inside the vendor bundle for dev HMR.
-        // Avoid bundling to reduce memory pressure; let app import via HTTP loader.
-    }
+    // Angular framework packages are intentionally NOT added to vendor. They are
+    // served via HTTP only so every importer resolves to a single module realm.
+    // See shouldSkipDependency() for the full rationale. RxJS is also left out of
+    // vendor (large, and not required in the vendor bundle for dev HMR).
     if (pkg.dependencies?.['react-nativescript']) {
         if (pkg.dependencies?.react) {
             addCandidate('react');
@@ -571,7 +689,7 @@ function collectVendorModules(projectRoot, platform, flavor) {
         }
         const peerDependencies = Object.keys(dependencyPkg.peerDependencies ?? {});
         for (const peer of peerDependencies) {
-            if (shouldSkipDependency(peer)) {
+            if (shouldSkipDependency(peer) || localSourceNames.has(peer)) {
                 continue;
             }
             if (projectDeps.dependencies.has(peer) || projectDeps.optional.has(peer) || projectDeps.dev.has(peer)) {
@@ -599,6 +717,16 @@ function shouldSkipDependency(name) {
     if (ALWAYS_EXCLUDE.has(name)) {
         return true;
     }
+    // Angular framework packages must only be served via the HTTP path so every
+    // importer resolves to a single module realm. When these packages are present
+    // in the vendor bundle AND imported by app modules via HTTP subpath, every
+    // @Component/@Injectable gets defined twice (once per realm), producing NG0912
+    // selector collisions, cross-realm `instanceof` failures, and dual class
+    // identities throughout Angular's DI container. HTTP-only is the single-realm
+    // invariant for user-level framework code.
+    if (name === '@nativescript/angular' || name === 'nativescript-angular' || name.startsWith('@angular/')) {
+        return true;
+    }
     // All Babel packages are build tools — never bundle into device runtime.
     // They require Node built-ins (fs, path, url) that don't exist on device.
     if (name.startsWith('@babel/') || name.startsWith('babel-')) {
@@ -641,7 +769,160 @@ function shouldSkipDependency(name) {
     }
     return false;
 }
+const COMPILED_JS_ENTRY_EXTENSIONS = ['.js', '.mjs', '.cjs'];
+const COMPILED_JS_ENTRY_REGEX = /\.(?:c|m)?jsx?$/;
+function compiledJsExtensionsForPlatform(platform) {
+    const exts = [...COMPILED_JS_ENTRY_EXTENSIONS];
+    switch (platform) {
+        case 'android':
+            exts.push('.android.js');
+            break;
+        case 'ios':
+            exts.push('.ios.js', '.visionos.js');
+            break;
+        case 'visionos':
+            exts.push('.visionos.js', '.ios.js');
+            break;
+    }
+    return exts;
+}
+/**
+ * Determine whether a `package.json` dependency must be excluded from the
+ * HMR vendor bundle because esbuild's standalone vendor pipeline can't
+ * resolve its source.
+ *
+ * The HMR vendor bundle is generated by a standalone esbuild build that
+ * has none of the Vite plugin chain (most notably
+ * `ns-tsconfig-paths-resolver`), so any aliased import inside the
+ * package's **source** files will fail with "Could not resolve" and abort
+ * the whole bundle.
+ *
+ * Skip:
+ *  - `link:` and `workspace:` refs (always app-side source).
+ *  - `file:` refs to a directory whose installed package only ships
+ *    TypeScript/JSX source (no compiled `.js`/`.mjs`/`.cjs` entry).
+ *
+ * Keep (return false):
+ *  - Regular semver / git / url specs (normal third-party libraries).
+ *  - Local `.tgz` file refs (pre-packaged libraries extracted at install).
+ *  - `file:` directory refs that resolve to a package with a compiled JS
+ *    entry — a common NativeScript monorepo convention where the app's
+ *    `package.json` redirects to `../../node_modules/<name>` to avoid
+ *    duplicate installs while letting the NativeScript CLI discover
+ *    plugins from the app directory.
+ */
+export function isUnvendorableLocalSource(name, spec, projectRequire, platform) {
+    if (typeof spec !== 'string')
+        return false;
+    if (spec.startsWith('link:') || spec.startsWith('workspace:'))
+        return true;
+    if (!spec.startsWith('file:'))
+        return false;
+    // Tarballs are already pre-packaged libraries — install extracts them
+    // into a normal node_modules entry.
+    if (/\.t(?:ar\.)?gz(?:[?#].*)?$/.test(spec))
+        return false;
+    // Directory file: refs need a deeper check: peek at the installed
+    // package.json and ask "does this ship compiled JS?". If yes, vendor
+    // it. If no (TS source only), defer to the regular Vite pipeline.
+    return !packageHasCompiledJsEntry(name, projectRequire, platform);
+}
+function packageHasCompiledJsEntry(name, projectRequire, platform) {
+    let pkgJsonPath;
+    try {
+        pkgJsonPath = projectRequire.resolve(`${name}/package.json`);
+    }
+    catch {
+        return false;
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+    }
+    catch {
+        return false;
+    }
+    const pkgDir = path.dirname(pkgJsonPath);
+    const candidates = [];
+    const pushCandidate = (value) => {
+        if (typeof value === 'string' && value)
+            candidates.push(value);
+    };
+    pushCandidate(pkg.module);
+    pushCandidate(pkg.main);
+    // Recursively flatten conditional `exports` maps to surface concrete
+    // file paths. We only need `string` leaves; anything else (function-
+    // based exports, etc.) doesn't apply to esbuild's resolution.
+    const visitExports = (node) => {
+        if (!node)
+            return;
+        if (typeof node === 'string') {
+            pushCandidate(node);
+            return;
+        }
+        if (Array.isArray(node)) {
+            for (const item of node)
+                visitExports(item);
+            return;
+        }
+        if (typeof node === 'object') {
+            for (const value of Object.values(node))
+                visitExports(value);
+        }
+    };
+    visitExports(pkg.exports);
+    if (candidates.length === 0) {
+        // node's default lookup falls back to `index.js`.
+        candidates.push('index');
+    }
+    const extensionsToTry = compiledJsExtensionsForPlatform(platform);
+    for (const cand of candidates) {
+        const abs = path.resolve(pkgDir, cand);
+        const ext = path.extname(cand);
+        if (COMPILED_JS_ENTRY_REGEX.test(cand)) {
+            // Explicit JS extension. If the file exists, vendor it. If not
+            // (a NativeScript plugin commonly declares `main: "index.js"`
+            // but ships only platform variants like `index.ios.js`), try
+            // the platform-specific variants which esbuild's
+            // `resolveExtensions` will pick up at bundle time.
+            if (fs.existsSync(abs))
+                return true;
+            const baseAbs = abs.slice(0, -ext.length);
+            for (const e of extensionsToTry) {
+                if (fs.existsSync(baseAbs + e))
+                    return true;
+            }
+            continue;
+        }
+        if (!ext) {
+            // Extensionless main — try plain JS variants AND the
+            // platform-specific variants NativeScript plugins commonly use
+            // (`index.ios.js`, `index.android.js`, `index.visionos.js`).
+            for (const e of extensionsToTry) {
+                if (fs.existsSync(abs + e))
+                    return true;
+            }
+            continue;
+        }
+        // A non-JS extension (typically `.ts`/`.tsx`) means the package
+        // only ships TS source — esbuild's vendor pipeline can't resolve
+        // any tsconfig-aliased imports inside it.
+    }
+    return false;
+}
 export const __test_collectVendorModules = collectVendorModules;
+export const __test_createVendorBundleRuntimeModule = createVendorBundleRuntimeModule;
+export const __test_isUnvendorableLocalSource = isUnvendorableLocalSource;
+export const __test_packageHasCompiledJsEntry = packageHasCompiledJsEntry;
+function canResolveDependencyPackageJson(specifier, projectRequire) {
+    try {
+        projectRequire.resolve(`${specifier}/package.json`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function readDependencyPackageJson(specifier, projectRequire) {
     try {
         const packageJsonPath = projectRequire.resolve(`${specifier}/package.json`);
@@ -668,9 +949,31 @@ function createVendorEntry(entries) {
         return `export const __nsVendorModuleMap = {};
 `;
     }
-    const imports = entries.map((specifier, index) => `import * as __nsVendor_${index} from ${JSON.stringify(specifier)};`).join('\n');
+    // Emit a side-effect-only import FIRST for each entry, then the namespace
+    // import we actually expose through `__nsVendorModuleMap`. Per the ESM
+    // spec, `import "pkg";` (no clause) guarantees module body evaluation, and
+    // esbuild treats these as DCE-immune even when the package declares
+    // `"sideEffects": false`. Without this, packages whose top-level
+    // statements install runtime patches (e.g. `@nativescript-community/text`
+    // monkey-patching `TextBase.prototype.setTextDecorationAndTransform` via
+    // `overrideSpanAndFormattedString()` invoked from
+    // `@nativescript-community/ui-label/index-common.js` line 12) can have
+    // their bodies elided by esbuild — exports stay resolvable via the
+    // namespace, but the runtime patches never fire, producing line-height /
+    // letter-spacing / formatted-text rendering divergence between HMR
+    // (vendor.mjs via HTTP) and no-HMR (single Rolldown bundle that inlines
+    // everything anyway). This affects any NS plugin that relies on top-level
+    // side-effects to wire up renderer behavior.
+    const sideEffectImports = entries.map((specifier) => `import ${JSON.stringify(specifier)};`).join('\n');
+    const namespaceImports = entries.map((specifier, index) => `import * as __nsVendor_${index} from ${JSON.stringify(specifier)};`).join('\n');
     const modules = entries.map((specifier, index) => `${JSON.stringify(specifier)}: __nsVendor_${index}`).join(',\n  ');
-    return `${imports}\n\nexport const __nsVendorModuleMap = {\n  ${modules}\n};\n`;
+    return `${sideEffectImports}\n\n${namespaceImports}\n\nexport const __nsVendorModuleMap = {\n  ${modules}\n};\n`;
+}
+function createVendorBundleRuntimeModule(result) {
+    return `${result.code}
+export const vendorManifest = ${JSON.stringify(result.manifest)};
+export default vendorManifest;
+`;
 }
 function resolveExtensionsForPlatform(platform) {
     const base = ['.tsx', '.jsx', '.ts', '.js', '.mjs', '.cjs', '.json'];
@@ -753,10 +1056,7 @@ function createVendorEsbuildPlugin(projectRoot) {
             // @angular/platform-browser/animations -> provide concrete named stubs
             build.onResolve({ filter: /^@angular\/platform-browser\/animations(?:\/.*)?$/ }, (args) => {
                 if (debug) {
-                    try {
-                        console.log('[vendor] map', args.path, '->', PB_ANIMATIONS_ID);
-                    }
-                    catch { }
+                    console.log('[vendor] map', args.path, '->', PB_ANIMATIONS_ID);
                 }
                 return { path: PB_ANIMATIONS_ID, namespace: 'ns-vendor' };
             });
@@ -782,10 +1082,7 @@ function createVendorEsbuildPlugin(projectRoot) {
             // @angular/animations/browser -> provide ɵ* engine/renderer/style normalizer stubs
             build.onResolve({ filter: /^@angular\/animations\/browser(?:\/.*)?$/ }, (args) => {
                 if (debug) {
-                    try {
-                        console.log('[vendor] map', args.path, '->', ANIMATIONS_BROWSER_ID);
-                    }
-                    catch { }
+                    console.log('[vendor] map', args.path, '->', ANIMATIONS_BROWSER_ID);
                 }
                 return { path: ANIMATIONS_BROWSER_ID, namespace: 'ns-vendor' };
             });
@@ -807,10 +1104,7 @@ function createVendorEsbuildPlugin(projectRoot) {
             // Keep generic mapping for @angular/animations base; /browser is handled above
             { filter: /^@angular\/animations(?:$|\/)$/ }, (args) => {
                 if (debug) {
-                    try {
-                        console.log('[vendor] map', args.path, '->', ANIMATIONS_ID);
-                    }
-                    catch { }
+                    console.log('[vendor] map', args.path, '->', ANIMATIONS_ID);
                 }
                 return { path: ANIMATIONS_ID, namespace: 'ns-vendor' };
             });
@@ -990,10 +1284,7 @@ function angularLinkerEsbuildPlugin(projectRoot) {
                         fileSystem: angularFileSystem,
                     });
                     if (debug) {
-                        try {
-                            console.log('[ns-angular-linker][vendor] linking', args.path);
-                        }
-                        catch { }
+                        console.log('[ns-angular-linker][vendor] linking', args.path);
                     }
                     const result = await babel.transformAsync(source, {
                         filename: args.path,
@@ -1099,15 +1390,84 @@ function normalizeSpecifier(spec) {
   return value;
 }
 
+function normalizeCoreSubLocal(s) {
+  if (!s) return "";
+  let t = String(s).split("?")[0].split("#")[0].trim();
+  t = t.replace(/^\\/+/, "").replace(/\\/+$/, "");
+  t = t.replace(/\\.(?:mjs|cjs|js)$/, "");
+  if (t.length >= 6 && t.substring(t.length - 6) === "/index") {
+    t = t.substring(0, t.length - 6);
+  }
+  if (!t || t === "index") return "";
+  return t;
+}
+
+// Invariant D: shape ESM namespaces before returning to CJS callers.
+//
+// The /ns/core handler's registration footer (see websocket.ts) and the
+// main-entry require shim (see helpers/main-entry.ts) both install the
+// shape function on globalThis. In practice, entries stored in
+// __NS_CORE_MODULES__ are ALREADY shaped, so this pass-through is a
+// fast no-op (the shape function's fast path returns obj as-is when it
+// already has Object.prototype). We call it anyway as defense-in-depth
+// against future callers that might populate the registry without
+// shaping.
+function shapeForCjs(value) {
+  if (!value || typeof value !== "object") return value;
+  const shape = g.__NS_CJS_SHAPE__;
+  if (typeof shape === "function") {
+    try { return shape(value); } catch (e) {}
+  }
+  return value;
+}
+
+function resolveCoreFromRegistry(normalizedId) {
+  if (
+    normalizedId !== "@nativescript/core" &&
+    normalizedId.indexOf("@nativescript/core/") !== 0
+  ) {
+    return null;
+  }
+  const table = g.__NS_CORE_MODULES__;
+  if (!table) return null;
+  if (table[normalizedId]) return shapeForCjs(table[normalizedId]);
+  const rawSub =
+    normalizedId === "@nativescript/core"
+      ? ""
+      : normalizedId.slice("@nativescript/core/".length);
+  const normSub = normalizeCoreSubLocal(rawSub);
+  const bareKey = normSub ? "@nativescript/core/" + normSub : "@nativescript/core";
+  if (table[bareKey]) return shapeForCjs(table[bareKey]);
+  if (normSub && table[normSub]) return shapeForCjs(table[normSub]);
+  if (!normSub && table[""]) return shapeForCjs(table[""]);
+  return null;
+}
+
 export function createRequire(_url) {
   const nsRequire = getNativeScriptRequire();
   if (!nsRequire) {
-    return function () {
+    return function (id) {
+      // Even without nsRequire, the @nativescript/core registry populated by
+      // the /ns/core bridge may already have the module — return it so
+      // vendor install() hooks that run against the HMR-served core don't
+      // crash at module-instantiation time.
+      const fromRegistry = resolveCoreFromRegistry(normalizeSpecifier(id));
+      if (fromRegistry) return fromRegistry;
       throw new Error("NativeScript require() is not available in this context");
     };
   }
   const req = function (id) {
     const normalizedId = normalizeSpecifier(id);
+    // Invariant C: @nativescript/core and its subpaths are served ONCE via
+    // the /ns/core HTTP bridge, which self-registers each module's ESM
+    // namespace on globalThis.__NS_CORE_MODULES__. CommonJS require() from
+    // vendor packages (e.g. \`require('@nativescript/core/ui/core/view').View\`
+    // in @nativescript-community/gesturehandler, or \`require('@nativescript/core').View\`
+    // in @nativescript-community/ui-material-core) MUST resolve to that
+    // same namespace; otherwise we re-trigger class identity splits and
+    // applyMixins() crashes with "Cannot read properties of undefined".
+    const fromRegistry = resolveCoreFromRegistry(normalizedId);
+    if (fromRegistry) return fromRegistry;
     if (
       normalizedId.includes("../data/patch.json") ||
       normalizedId.includes("css-tree/lib/data/patch.json")
@@ -1130,7 +1490,12 @@ export function createRequire(_url) {
     if (normalizedId.endsWith(".json")) {
       return {};
     }
-    return nsRequire(normalizedId);
+    // Shape the native require result too. The NativeScript CJS loader
+    // may serve an @nativescript/core subpath over HTTP before the
+    // /ns/core footer has run (e.g., during initial boot). In that
+    // window, the result is a raw ESM namespace with null [[Prototype]]
+    // and zone.js/vendor install() hooks crash on hasOwnProperty.
+    return shapeForCjs(nsRequire(normalizedId));
   };
   req.resolve = nsRequire.resolve
     ? function (id) {