create-octane-xplat 0.1.0 → 0.3.0

package/template/App_Resources/iOS/LaunchScreen.storyboard

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13771" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <device id="retina5_9" orientation="portrait">
+        <adaptation id="fullscreen"/>
+    </device>
+    <dependencies>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13772"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <layoutGuides>
+                        <viewControllerLayoutGuide type="top" id="Llm-lL-Icb"/>
+                        <viewControllerLayoutGuide type="bottom" id="xb3-aO-Qok"/>
+                    </layoutGuides>
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <rect key="frame" x="0.0" y="0.0" width="375" height="812"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>
+                            <imageView userInteractionEnabled="NO" contentMode="scaleAspectFill" horizontalHuggingPriority="251" verticalHuggingPriority="251" image="LaunchScreen.AspectFill" translatesAutoresizingMaskIntoConstraints="NO" id="wtH-rr-YfP">
+                                <rect key="frame" x="0.0" y="0.0" width="375" height="812"/>
+                            </imageView>
+                            <imageView userInteractionEnabled="NO" contentMode="center" horizontalHuggingPriority="251" verticalHuggingPriority="251" image="LaunchScreen.Center" translatesAutoresizingMaskIntoConstraints="NO" id="s1z-aa-wYv">
+                                <rect key="frame" x="0.0" y="150" width="375" height="512"/>
+                            </imageView>
+                        </subviews>
+                        <color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                        <constraints>
+                            <constraint firstAttribute="trailing" secondItem="s1z-aa-wYv" secondAttribute="trailing" id="4Rf-kf-vql"/>
+                            <constraint firstAttribute="bottom" secondItem="wtH-rr-YfP" secondAttribute="bottom" id="5CS-At-4ka"/>
+                            <constraint firstItem="wtH-rr-YfP" firstAttribute="top" secondItem="Ze5-6b-2t3" secondAttribute="top" id="Awn-b8-xf1"/>
+                            <constraint firstItem="s1z-aa-wYv" firstAttribute="leading" secondItem="Ze5-6b-2t3" secondAttribute="leading" id="BpJ-vb-eKA"/>
+                            <constraint firstItem="s1z-aa-wYv" firstAttribute="trailing" secondItem="wtH-rr-YfP" secondAttribute="trailing" id="QIM-7J-OZz"/>
+                            <constraint firstAttribute="trailing" secondItem="wtH-rr-YfP" secondAttribute="trailing" id="RXg-rW-UK8"/>
+                            <constraint firstItem="s1z-aa-wYv" firstAttribute="centerY" secondItem="Ze5-6b-2t3" secondAttribute="centerY" id="Rcp-LG-48z"/>
+                            <constraint firstItem="wtH-rr-YfP" firstAttribute="leading" secondItem="Ze5-6b-2t3" secondAttribute="leading" id="cch-8E-tYu"/>
+                        </constraints>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="509.60000000000002" y="237.93103448275863"/>
+        </scene>
+    </scenes>
+    <resources>
+        <image name="LaunchScreen.AspectFill" width="768" height="1024"/>
+        <image name="LaunchScreen.Center" width="384" height="512"/>
+    </resources>
+</document>

package/template/App_Resources/iOS/build.xcconfig

@@ -0,0 +1,7 @@
+// You can add custom settings here
+// for example you can uncomment the following line to force distribution code signing
+// CODE_SIGN_IDENTITY = iPhone Distribution 
+// To build for device with XCode you need to specify your development team.
+// DEVELOPMENT_TEAM = YOUR_TEAM_ID;
+ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+IPHONEOS_DEPLOYMENT_TARGET = 17.0;

package/template/App_Resources/iOS/src/OctaneShaders.metal

@@ -0,0 +1,128 @@
+#include <metal_stdlib>
+#include <SwiftUI/SwiftUI_Metal.h>
+using namespace metal;
+
+// Stitchable shaders for SwiftUI's `.distortionEffect` / `.colorEffect` (iOS 17+).
+// SwiftUI supplies the leading parameters — `position` for a distortion, plus
+// `color` for a colour effect — and appends the arguments passed at the call
+// site in `OctaneLogo.swift`.
+
+/// Rising heat haze.
+///
+/// A distortion shader maps a destination pixel back to the source pixel it
+/// should sample, so the returned offset reads as the image bending. Amplitude
+/// is weighted by `base^2` (1 at the bottom, 0 at the top) so the mark shimmers
+/// like air over hot metal instead of wobbling as a rigid block, and the two
+/// waves use incommensurate frequencies so the pattern never visibly repeats.
+[[ stitchable ]] float2 octaneHeatHaze(float2 position, float time, float2 size, float intensity) {
+	float2 uv = position / size;
+	float base = 1.0 - uv.y;
+	float wave = sin(uv.y * 26.0 - time * 3.1) * 0.6
+	           + sin(uv.y * 11.0 - time * 1.9 + uv.x * 4.0) * 0.4;
+	float amp = 2.4 * base * base * intensity;
+	return position + float2(wave * amp, 0.0);
+}
+
+/// Ember sheen sweeping diagonally across the ink.
+///
+/// SwiftUI hands colour effects premultiplied alpha, so the colour has to be
+/// un-premultiplied before mixing and re-premultiplied on the way out —
+/// blending straight into premultiplied RGB would bleed the highlight into the
+/// transparent surround and halo the glyph edges.
+[[ stitchable ]] half4 octaneSheen(float2 position, half4 color, float time, float2 size, float intensity) {
+	if (color.a < 0.004h) {
+		return color;
+	}
+	half3 rgb = color.rgb / color.a;
+
+	float2 uv = position / size;
+	float sweep = fract(time * 0.22);
+	float d = (uv.x * 0.85 + (1.0 - uv.y) * 0.35) - (sweep * 1.8 - 0.4);
+	float band = exp(-(d * d) * 42.0);
+
+	half3 ember = half3(1.0h, 0.255h, 0.353h); // the logo's #FF415A accent
+	half3 gold = half3(1.0h, 0.72h, 0.36h);
+	half3 hot = mix(ember, gold, half(band));
+
+	half glow = half(band) * half(intensity);
+	rgb = mix(rgb, hot, glow * 0.9h);
+	rgb += half3(glow * 0.25h);
+
+	return half4(saturate(rgb) * color.a, color.a);
+}
+
+/// Per-shard pseudo-random pair. Deterministic in the cell index, so a shard
+/// keeps the same trajectory for the whole burst instead of jittering per frame.
+static inline float2 shardNoise(float2 cell) {
+	float3 a = fract(float3(cell.xyx) * float3(0.1031, 0.1030, 0.0973));
+	a += dot(a, a.yzx + 33.33);
+	return fract(float2((a.x + a.y) * a.z, (a.x + a.z) * a.y));
+}
+
+/// Ignition burst: the mark shatters outward and reassembles.
+///
+/// A layer effect (rather than a distortion) because each shard has to read
+/// from somewhere else in the image: sampling `position - offset` with an
+/// offset that is constant across a grid cell translates that whole cell as a
+/// rigid chip, which is what reads as breaking apart. A distortion shader can
+/// only nudge its own pixel, so it smears instead of shattering.
+///
+/// `progress` runs 0 -> 1 once per burst and the displacement rides
+/// `sin(p * pi)`, so the shards fly out and land back exactly where they
+/// started — no separate reassembly pass, and the mark cannot get stranded
+/// mid-explosion if a frame is dropped.
+[[ stitchable ]] half4 octaneShatter(float2 position, SwiftUI::Layer layer, float2 size, float progress) {
+	if (progress <= 0.0001) {
+		return layer.sample(position);
+	}
+
+	float p = clamp(progress, 0.0, 1.0);
+	float fly = sin(p * M_PI_F);
+	float ease = fly * fly;
+
+	float2 cells = float2(22.0, 5.0);
+	float2 cellSize = size / cells;
+	float2 rnd = shardNoise(floor(position / cellSize));
+
+	float2 centre = size * 0.5;
+	float2 radial = (position - centre) / max(size.x * 0.5, 1.0);
+	float2 dir = radial + (rnd - 0.5) * 0.9;
+	float len = max(length(dir), 0.0001);
+	dir /= len;
+
+	// Capped so the outermost shards stay inside the host view; anything
+	// travelling further is clipped by its bounds rather than fading out.
+	float2 offset = dir * mix(22.0, 70.0, rnd.x) * ease;
+	offset.y += (rnd.y - 0.5) * 42.0 * ease;
+	float2 src = position - offset;
+
+	// Chromatic split along the flight path — the shards read as moving fast
+	// rather than merely being displaced.
+	float split = ease * 3.5;
+	half4 cr = layer.sample(src + dir * split);
+	half4 cg = layer.sample(src);
+	half4 cb = layer.sample(src - dir * split);
+	half alpha = max(max(cr.a, cg.a), cb.a);
+	if (alpha < 0.004h) {
+		return half4(0.0h);
+	}
+	half3 rgb = half3(cr.r, cg.g, cb.b) / alpha;
+
+	// Expanding shockwave ring, brightest just after the tap.
+	float ring = exp(-pow((length(radial) - p * 1.5) * 5.0, 2.0)) * (1.0 - p);
+
+	half3 ember = half3(1.0h, 0.255h, 0.353h);
+	half3 gold = half3(1.0h, 0.78h, 0.35h);
+	half heat = half(ease);
+	// Ember-leaning, and only a partial mix: pushing all the way to `hot` turns
+	// every shard the same flat gold and the mark stops being recognisable
+	// mid-flight. Holding some ink back keeps them reading as burning pieces
+	// of the logo.
+	half3 hot = mix(ember, gold, heat * 0.75h);
+
+	rgb = mix(rgb, hot, heat * 0.6h);
+	rgb += half3(heat * 0.18h * half(rnd.x) + half(ring) * 0.45h);
+
+	alpha *= 1.0h - heat * 0.2h;
+	return half4(saturate(rgb) * alpha, alpha);
+}

package/template/gitignore

@@ -1,2 +1,4 @@
 node_modules
 dist
+platforms/
+hooks/

package/template/index.html

@@ -7,6 +7,6 @@
   </head>
   <body>
     <div id="root"></div>
-    <script type="module" src="/src/main.tsrx"></script>
+    <script type="module" src="/src/main.web.tsrx"></script>
   </body>
 </html>

package/template/nativescript.config.ts

@@ -0,0 +1,13 @@
+import { NativeScriptConfig } from '@nativescript/core';
+
+export default {
+  id: 'org.nativescript.octanexplat',
+  appPath: 'src',
+  appResourcesPath: 'App_Resources',
+  android: {
+    v8Flags: '--expose_gc',
+    markingMode: 'none',
+  },
+  bundler: 'vite',
+  bundlerConfigPath: 'vite.config.native.mts',
+} as NativeScriptConfig;

package/template/package.json

@@ -2,18 +2,35 @@
   "name": "octane-xplat-app",
   "private": true,
   "type": "module",
+  "main": "src/native.ts",
   "scripts": {
+    "xplat": "xplat",
     "dev": "vite",
+    "dev:ios": "ns run ios",
+    "dev:android": "ns run android",
     "build": "vite build",
-    "typecheck": "tsrx-tsc --noEmit"
+    "build:ios": "ns build ios",
+    "build:android": "ns build android",
+    "typecheck": "tsrx-tsc --noEmit && tsrx-tsc --noEmit -p tsconfig.native.json"
   },
   "dependencies": {
-    "@octane-xplat/ui": "^0.2.0",
+    "@nativescript-community/octane": "0.2.1",
+    "@nativescript-community/ui-canvas": "4.6.52",
+    "@nativescript/core": "9.1.2",
+    "@octane-xplat/ui": "^0.3.0",
+    "@valor/nativescript-websockets": "2.0.3",
     "octane": "0.4.0"
   },
   "devDependencies": {
+    "@nativescript-community/vite-octane": "0.2.1",
+    "@nativescript/android": "9.1.1",
+    "@nativescript/ios": "9.1.0",
+    "@nativescript/types": "9.0.0",
+    "@nativescript/vite": "8.0.11",
+    "@octane-xplat/cli": "^0.3.0",
     "@octanejs/vite-plugin": "0.1.58",
     "@tsrx/typescript-plugin": "0.4.7",
+    "nativescript": "9.1.1",
     "typescript": "5.9.3",
     "vite": "8.3.0"
   }

package/template/patches/@nativescript-community__vite-octane@0.2.1.patch

@@ -0,0 +1,41 @@
+diff --git a/dist/server/strategy.js b/dist/server/strategy.js
+index 7d84b37e2ed3a026da5b31c8a11027e0580877b2..f6594a913ba64837135e994cb183add13c6a0530 100644
+--- a/dist/server/strategy.js
++++ b/dist/server/strategy.js
+@@ -14,7 +14,9 @@ import { purgeTransformCachesForHotUpdate, runHotUpdatePrologue, typescriptServe
+  * otherwise the re-fetch can be served from the previous save's transform and
+  * the screen ends up one save behind.
+  */
+-const SCRIPT_FILE_RE = /\.(?:[mc]?[jt]sx?)$/i;
++// `.tsrx` is Octane's component extension — without it the deferred delta is
++// never emitted and component edits silently never reach the device.
++const SCRIPT_FILE_RE = /\.(?:[mc]?[jt]sx?|tsrx)$/i;
+ export const octaneServerStrategy = {
+     ...typescriptServerStrategy,
+     flavor: 'octane',
+@@ -24,7 +26,7 @@ export const octaneServerStrategy = {
+         if (!state)
+             return;
+         const { root, metrics, emitSummary } = state;
+-        const { moduleGraph, verbose, sharedTransformRequest } = deps;
++        const { moduleGraph, verbose, sharedTransformRequest, wss, isSocketClientOpen } = deps;
+         const { file, server } = ctx;
+         if (!SCRIPT_FILE_RE.test(file)) {
+             emitSummary();
+@@ -71,6 +73,16 @@ export const octaneServerStrategy = {
+             const gm = moduleGraph.get(normalizedId);
+             if (gm)
+                 moduleGraph.emitDelta([gm], []);
++            // The ns:hmr-delta broadcast IS the update delivery for this flavor —
++            // count open sockets so the always-on summary reflects reality
++            // instead of reporting recipients=0 for a delivered update.
++            try {
++                wss?.clients?.forEach((client) => {
++                    if (isSocketClientOpen?.(client))
++                        metrics.recipients += 1;
++                });
++            }
++            catch { }
+         }
+         catch (e) {
+             if (verbose)

package/template/patches/@nativescript__vite@8.0.11.patch

@@ -0,0 +1,294 @@
+diff --git a/hmr/server/core-bundle.js b/hmr/server/core-bundle.js
+index 993097b9d861a2a7c477f4e664213efec3eb6293..7a9b95180cbd47e1d9c71180bc4582a450333a7c 100644
+--- a/hmr/server/core-bundle.js
++++ b/hmr/server/core-bundle.js
+@@ -607,17 +607,32 @@ export function buildCoreMainShimCode() {
+  * class/function values. `exportNames` comes from the same disk-based export
+  * discovery the per-module bridge relies on (collectStaticExportNamesFromFile).
+  */
+-const RESERVED_EXPORT_NAMES = new Set(['default', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'let', 'static', 'yield', 'await', 'eval', 'arguments', '__ns_core_sub_ns__']);
++// `default` is emitted separately (below); `__ns_core_sub_ns__` is this shim's
++// own local — a module exporting that name can't collide with it.
++const NON_DECLARABLE_EXPORT_NAMES = new Set(['default', '__ns_core_sub_ns__']);
++// Reserved words can't be declaration bindings (`export const enum` is a
++// syntax error), but they ARE legal export names — the specifier position in
++// `export { x as name }` accepts any IdentifierName. Emit those through a
++// temp + alias so a reserved-word export (zod's `enum`/`catch`/… shapes this
++// same code path) still reaches the bridged namespace.
++const RESERVED_EXPORT_NAMES = new Set(['break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'let', 'static', 'yield', 'await', 'eval', 'arguments']);
+ export function buildCoreSubShimCode(sub, exportNames, hasOwnDefaultExport = false) {
+     const canonical = normalizeCoreSub(sub);
+     const registryKey = `@nativescript/core/${canonical}`;
+-    const names = Array.from(new Set(exportNames)).filter((n) => /^[A-Za-z_$][\w$]*$/.test(n) && !RESERVED_EXPORT_NAMES.has(n));
++    const names = Array.from(new Set(exportNames)).filter((n) => /^[A-Za-z_$][\w$]*$/.test(n) && !NON_DECLARABLE_EXPORT_NAMES.has(n));
+     const lines = [];
+     lines.push(`/* @nativescript/core bridge (bundle mode) — sub: ${canonical} */`);
+     lines.push(`import ${JSON.stringify(CORE_BUNDLE_PATH)};`);
+     lines.push(`const __ns_core_sub_ns__ = (globalThis.__NS_CORE_MODULES__ || {})[${JSON.stringify(registryKey)}];`);
+     lines.push(`if (!__ns_core_sub_ns__) { throw new Error(${JSON.stringify(`[ns-core] core bundle registry missing '${registryKey}' — restart the dev server or set NS_CORE_PER_MODULE=1`)}); }`);
++    let aliasIdx = 0;
+     for (const name of names) {
++        if (RESERVED_EXPORT_NAMES.has(name)) {
++            const alias = `__ns_core_alias_${aliasIdx++}`;
++            lines.push(`const ${alias} = __ns_core_sub_ns__[${JSON.stringify(name)}];`);
++            lines.push(`export { ${alias} as ${name} };`);
++            continue;
++        }
+         lines.push(`export const ${name} = __ns_core_sub_ns__.${name};`);
+     }
+     // Deep-subpath contract (see isDeepCoreSubpath / per-module bridge): a sub
+diff --git a/hmr/server/deps-bundle.js b/hmr/server/deps-bundle.js
+index 50e5abddddf80b35044d45eb108a64dd175bf6e7..799c7257a8a730515633f19f6221ad26ff8678eb 100644
+--- a/hmr/server/deps-bundle.js
++++ b/hmr/server/deps-bundle.js
+@@ -219,8 +219,37 @@ function isPackageRootSpec(spec) {
+         return false;
+     return pkgSub.split('/').length === (pkgSub.startsWith('@') ? 2 : 1);
+ }
+-function resolveSpecToFile(spec, projectRoot, workspaceRoot, platform) {
++/**
++ * `/node_modules/<pkg>/<sub...>` → the exports-mapped file on disk
++ * (`rouzer/http` → `rouzer/dist/http.js`). Without this, non-root specs fall
++ * back to `resolveId` and land on Vite's dep-optimizer artifacts under
++ * `.vite/deps/` — flat bundles whose generated shared chunks
++ * (`foo-<hash>.js`) this pipeline cannot serve to the device.
++ */
++function resolvePackageSubpathFromSpecRoots(spec, roots, platform) {
++    const pkgSub = spec.replace(/^\/node_modules\//, '');
++    const parts = pkgSub.split('/');
++    const nameSegs = parts[0].startsWith('@') ? 2 : 1;
++    if (parts.length <= nameSegs)
++        return null;
++    const subpath = parts.slice(nameSegs).join('/');
++    for (const root of roots) {
++        const pkgDir = path.join(root, 'node_modules', ...parts.slice(0, nameSegs));
++        if (!existsSync(path.join(pkgDir, 'package.json')))
++            continue;
++        const resolved = resolvePackageSubpathEntry(pkgDir, subpath, platform);
++        if (resolved)
++            return resolved;
++    }
++    return null;
++}
++export function resolveSpecToFile(spec, projectRoot, workspaceRoot, platform) {
+     const roots = [projectRoot, ...(workspaceRoot && path.resolve(workspaceRoot) !== path.resolve(projectRoot) ? [workspaceRoot] : [])];
++    // `.vite/` is Vite's dep-optimizer store — generated artifacts with
++    // content-hashed names, not package files. Resolving them here would mint
++    // deps-bundle entries/shims for files whose names churn per optimization.
++    if (spec.includes('/.vite/'))
++        return null;
+     // Package roots honor the declared entry (exports/module/main) FIRST —
+     // matching esbuild's resolution of bare imports inside the bundle. The
+     // index fan-out would otherwise pick stray root files like a shipped
+@@ -236,6 +265,12 @@ function resolveSpecToFile(spec, projectRoot, workspaceRoot, platform) {
+         if (abs)
+             return abs;
+     }
++    // Non-root specs (`rouzer/http`, `qubu/sqlite`): consult the package's
++    // exports map so the real dist file wins — the alternative downstream is
++    // the dep optimizer's `.vite/deps` artifact, whose sibling chunks 404.
++    const subpathEntry = resolvePackageSubpathFromSpecRoots(spec, roots, platform);
++    if (subpathEntry)
++        return subpathEntry;
+     return isPackageRootSpec(spec) ? null : resolvePackageRootEntry(spec, roots, platform);
+ }
+ // Never bundled: `@nativescript/core` belongs to the /ns/core bridge realm,
+@@ -869,7 +904,15 @@ export function collectDepsModuleExportInfo(absPath, platform, seen = new Set())
+     names.delete('default');
+     return { names: Array.from(names).sort(), hasDefault: hasExistingDefaultExport(code) };
+ }
+-const RESERVED_EXPORT_NAMES = new Set(['default', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'let', 'static', 'yield', 'await', 'eval', 'arguments', '__ns_dep_ns__']);
++// `default` is emitted separately (below); `__ns_dep_ns__` is this shim's own
++// local — a package exporting that name can't collide with it.
++const NON_DECLARABLE_EXPORT_NAMES = new Set(['default', '__ns_dep_ns__']);
++// Reserved words can't be declaration bindings (`export const enum` is a
++// syntax error), but they ARE legal export names — the specifier position in
++// `export { x as name }` accepts any IdentifierName. Emit those through a
++// temp + alias so packages like zod (`enum`, `catch`, `function`, …) keep
++// their full surface on the bridged namespace.
++const RESERVED_EXPORT_NAMES = new Set(['break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'let', 'static', 'yield', 'await', 'eval', 'arguments']);
+ /**
+  * Shim served at `/ns/m/node_modules/...` for a bundled module. The static
+  * bundle import guarantees the registry is populated before the body reads it
+@@ -880,13 +923,20 @@ const RESERVED_EXPORT_NAMES = new Set(['default', 'break', 'case', 'catch', 'cla
+ export function buildDepsShimCode(key, exportNames, hasOwnDefaultExport) {
+     // JS_IDENTIFIER_RE (not ASCII \w): Angular exports `ɵɵdefineInjectable`-style
+     // names — dropping them here breaks every `import * as i0` consumer.
+-    const names = Array.from(new Set(exportNames)).filter((n) => JS_IDENTIFIER_RE.test(n) && !RESERVED_EXPORT_NAMES.has(n));
++    const names = Array.from(new Set(exportNames)).filter((n) => JS_IDENTIFIER_RE.test(n) && !NON_DECLARABLE_EXPORT_NAMES.has(n));
+     const lines = [];
+     lines.push(`/* ns-deps bridge (bundle mode) — ${key} */`);
+     lines.push(`import ${JSON.stringify(DEPS_BUNDLE_PATH)};`);
+     lines.push(`const __ns_dep_ns__ = (globalThis.__NS_DEPS_MODULES__ || {})[${JSON.stringify(key)}];`);
+     lines.push(`if (!__ns_dep_ns__) { throw new Error(${JSON.stringify(`[ns-deps] deps bundle registry missing '${key}' — restart the dev server or set NS_DEPS_PER_MODULE=1`)}); }`);
++    let aliasIdx = 0;
+     for (const name of names) {
++        if (RESERVED_EXPORT_NAMES.has(name)) {
++            const alias = `__ns_dep_alias_${aliasIdx++}`;
++            lines.push(`const ${alias} = __ns_dep_ns__[${JSON.stringify(name)}];`);
++            lines.push(`export { ${alias} as ${name} };`);
++            continue;
++        }
+         lines.push(`export const ${name} = __ns_dep_ns__.${name};`);
+     }
+     if (hasOwnDefaultExport) {
+diff --git a/hmr/server/device-transform-helpers.js b/hmr/server/device-transform-helpers.js
+index 9364ce9942b84fffd0e3a6eb6700d8253fa66e7e..93ee2bf2570303277d7b4350018b00fbbb31e2a4 100644
+--- a/hmr/server/device-transform-helpers.js
++++ b/hmr/server/device-transform-helpers.js
+@@ -81,12 +81,18 @@ function bareSpecifierFromFlatDepPath(depPath) {
+         }
+         catch { }
+     }
+-    const bareSpecifier = resolved || candidates[0];
++    // Unverified decode → NOT a package: `depPath` is a generated optimizer
++    // artifact (a hash-named shared chunk like `http-Dm_BQhab.js`, whose
++    // base64url '_' decodes to a bogus '/'). Returning null lets the caller
++    // keep the real `.vite/deps` URL instead of emitting a garbage specifier.
++    if (!resolved) {
++        return null;
++    }
+     if (!warnedVendorMisses.has(depPath)) {
+         warnedVendorMisses.add(depPath);
+-        console.warn(`[ns-vite] vendor-manifest miss: prebundled dep '${depPath}' is not in the vendor bundle — serving '${bareSpecifier}' over HTTP via /ns/m/node_modules/${resolved ? '' : ' (could not verify the package on disk; the specifier is a best-effort decode of the flattened id)'}.`);
++        console.warn(`[ns-vite] vendor-manifest miss: prebundled dep '${depPath}' is not in the vendor bundle — serving '${resolved}' over HTTP via /ns/m/node_modules/${resolved}.`);
+     }
+-    return bareSpecifier;
++    return resolved;
+ }
+ function rewriteVitePrebundleImportsForDevice(code, preserveVendorImports) {
+     const imports = collectTopLevelImportRecords(code);
+@@ -111,6 +117,15 @@ function rewriteVitePrebundleImportsForDevice(code, preserveVendorImports) {
+             if (bareSpecifier) {
+                 replacement = imp.text.replace(source, bareSpecifier);
+             }
++            else {
++                // Generated optimizer chunk (hash-named sibling of an
++                // optimized entry) — not a package and not decodable to one.
++                // Route the real artifact URL back through the bridge: the
++                // /ns/m route serves it from the dep-optimizer store (the
++                // `?v` stamp rides along as forcedVer) or emits an
++                // actionable optimizeDeps.exclude error.
++                replacement = imp.text.replace(source, `/ns/m/node_modules/.vite/deps/${depPath}`);
++            }
+         }
+         edits.push({
+             start: imp.start,
+diff --git a/hmr/server/websocket-ns-m-request.js b/hmr/server/websocket-ns-m-request.js
+index b54aefcc839e95906d76d02e522c052a706ca76f..d49159de94ba05dcfc372aa7a3c513e0f5c0a0d3 100644
+--- a/hmr/server/websocket-ns-m-request.js
++++ b/hmr/server/websocket-ns-m-request.js
+@@ -1,6 +1,9 @@
+ import * as path from 'path';
++import { realpathSync } from 'fs';
+ import { filterExistingNodeModulesTransformCandidates, getBlockedDeviceNodeModulesReason, resolveCandidateFilePath, tryReadRawExplicitJavaScriptModule } from './websocket-module-specifiers.js';
+ import { collapseLegacyNsMTags } from './websocket-ns-m-paths.js';
++import { resolveSpecToFile } from './deps-bundle.js';
++import { resolvePlatform } from '../../helpers/cli-flags.js';
+ function normalizeAbsoluteFilesystemSpec(spec, serverRoot) {
+     const toPosix = (value) => value.replace(/\\/g, '/');
+     const rootPosix = toPosix(serverRoot);
+@@ -93,6 +96,29 @@ export function createNsMRequestContext(requestUrl, serverRoot, appVirtualWithSl
+         return { kind: 'next' };
+     }
+ }
++/**
++ * Canonical request URL for a resolved node_modules file. Project-root files
++ * keep the `/node_modules/...` form so module identity matches the /ns/m
++ * spec space; files outside the project root (hoisted/workspace) use the
++ * `/@fs` form Vite can load directly. Symlinked workspace-source packages
++ * resolve to their realpath so the TS transform applies — same policy as
++ * filterExistingNodeModulesTransformCandidates.
++ */
++function nodeModulesFileToRequestUrl(absPath, serverRoot) {
++    try {
++        const real = realpathSync(absPath);
++        if (real !== absPath && !real.split(path.sep).includes('node_modules')) {
++            return `/@fs${real.replace(/\\/g, '/')}`;
++        }
++    }
++    catch { }
++    const rootPosix = path.resolve(serverRoot).replace(/\\/g, '/').replace(/\/+$/, '');
++    const absPosix = absPath.replace(/\\/g, '/');
++    if (absPosix.startsWith(`${rootPosix}/`)) {
++        return absPosix.slice(rootPosix.length);
++    }
++    return `/@fs${absPosix}`;
++}
+ async function tryTransformRequest(transformRequest, url, timeoutMs) {
+     try {
+         return await transformRequest(url, timeoutMs);
+@@ -146,6 +172,38 @@ export async function resolveNsMTransformedModule(options) {
+             return { transformed, resolvedCandidate };
+         }
+     }
++    // Optimizer-artifact requests (`/node_modules/.vite/deps/<file>`): flat
++    // entries and hash-named shared chunks live in the dep-optimizer's store
++    // (often memory-only), keyed by the `?v=<browserHash>` stamp Vite emits —
++    // captured inbound as `forcedVer`. Replay it so Vite resolves the artifact
++    // as-is; a miss falls through to the route's transform-miss branch, which
++    // names optimizeDeps.exclude as the fix.
++    if (spec.includes('/.vite/deps/')) {
++        const depUrl = context.forcedVer ? `${spec}?v=${context.forcedVer}` : spec;
++        transformed = await tryTransformRequest(transformRequest, depUrl, timeoutMs);
++        if (transformed?.code) {
++            return { transformed, resolvedCandidate: depUrl };
++        }
++        return { transformed: null, resolvedCandidate };
++    }
++    // Bare or subpath node_modules specs (`rouzer/http`, `qubu/sqlite`) that
++    // survive the on-disk candidate fan-out would otherwise hit `resolveId`
++    // and land on Vite's dep-optimizer output: `/node_modules/.vite/deps/
++    // <flat>.js` bundles whose generated sibling chunks (`foo-<hash>.js`)
++    // this pipeline cannot serve — and whose flattened ids decode to bogus
++    // bare specifiers downstream (`http-Dm/BQhab`). Prefer the real package
++    // file (exports-map aware) so the device gets the same per-module source
++    // an `optimizeDeps.exclude` entry produces.
++    if (spec.includes('/node_modules/')) {
++        const realFile = resolveSpecToFile(spec.slice(spec.lastIndexOf('/node_modules/')), serverRoot, workspaceRoot, resolvePlatform() || 'ios');
++        const realUrl = realFile ? nodeModulesFileToRequestUrl(realFile, serverRoot) : null;
++        if (realUrl) {
++            transformed = await tryTransformRequest(transformRequest, realUrl, timeoutMs);
++            if (transformed?.code) {
++                return { transformed, resolvedCandidate: realUrl };
++            }
++        }
++    }
+     const resolvedId = await resolveId(spec);
+     if (resolvedId) {
+         transformed = await tryTransformRequest(transformRequest, resolvedId, timeoutMs);
+diff --git a/hmr/server/websocket-ns-m.js b/hmr/server/websocket-ns-m.js
+index 8eeb51ab59497e7f775da3117c4207e05f1814c7..346b676fbb67ce6bebe81cc379fdbe0d0aeac876 100644
+--- a/hmr/server/websocket-ns-m.js
++++ b/hmr/server/websocket-ns-m.js
+@@ -265,6 +265,30 @@ export function registerNsModuleServerRoute(server, options) {
+             catch { }
+             // If transformRequest failed, handle bare-module vendor shims for 'vue' and 'pinia'
+             if (!transformed?.code) {
++                // Dep-optimizer artifacts (`.vite/deps` entries + generated
++                // shared chunks) aren't package files — when one reaches the
++                // bridge unserved, the fix is keeping that dep out of
++                // optimizeDeps. Name the optimized set so the on-device
++                // error is actionable instead of a generic transform miss.
++                if (spec.includes('/.vite/deps/')) {
++                    const optimizedIds = [];
++                    try {
++                        for (const env of Object.values(server.environments || {})) {
++                            const meta = env?.depsOptimizer?.metadata;
++                            for (const record of [meta?.optimized, meta?.discovered]) {
++                                if (record)
++                                    optimizedIds.push(...Object.keys(record));
++                            }
++                        }
++                    }
++                    catch { }
++                    const hint = optimizedIds.length
++                        ? ` Currently optimized: ${Array.from(new Set(optimizedIds)).join(', ')} — add the package that pulls in this chunk to optimizeDeps.exclude in the native vite config (or restart with NS_DEPS_PER_MODULE=1).`
++                        : ' Add the importing package to optimizeDeps.exclude in the native vite config.';
++                    res.statusCode = 404;
++                    res.end(`throw new Error(${JSON.stringify(`[ns/m] Vite optimizeDeps artifact '${spec}' is not servable on device — its shared chunks are generated files outside the package tree.${hint}`)});\nexport {};\n`);
++                    return;
++                }
+                 const bare = spec.startsWith('/') ? spec.slice(1) : spec;
+                 const isBare = bare && !bare.includes('/') && !/\.(ts|tsx|js|jsx|mjs|mts|cts|vue)$/i.test(bare);
+                 if (isBare && (bare === 'vue' || bare === 'nativescript-vue' || bare === 'pinia')) {

package/template/pnpm-workspace.yaml

@@ -1,7 +1,29 @@
 # pnpm 11 settings live here, not in package.json.
-# esbuild needs its install script to place the platform binary.
-# @nativescript/core lands via optional peers — its scripts are native
-# toolchain prep the ns CLI does itself; skipping keeps installs clean.
+#
+# nodeLinker hoisted: Node ESM resolves package imports relative to the
+# symlink path (node_modules/octane/...), not the realpath — so octane's
+# transitive deps (@tsrx/core etc.) must sit at top-level node_modules.
+# NativeScript's bundler wants a flat tree for the same reason.
+nodeLinker: hoisted
+#
+# esbuild + @parcel/watcher need install scripts to place binaries;
+# nativescript's postinstall sets up the local CLI. @nativescript/core's
+# scripts are native toolchain prep the ns CLI does itself.
 allowBuilds:
   esbuild: true
+  '@parcel/watcher': true
+  nativescript: true
   '@nativescript/core': false
+#
+# vite-octane's octaneServerStrategy early-returns for `.tsrx` files (its
+# SCRIPT_FILE_RE only covers [jt]sx?), so component edits never emit the
+# deferred ns:hmr-delta broadcast — on-device HMR looks dead. The patch also
+# counts open /ns-hmr sockets so `recipients=N` in update logs is real.
+# Drop once a release carries the fix.
+patchedDependencies:
+  '@nativescript-community/vite-octane@0.2.1': patches/@nativescript-community__vite-octane@0.2.1.patch
+  # Dep/core shims dropped reserved-word named exports (zod's `enum`, `catch`,
+  # `function`, …) because `export const enum` is a syntax error — emit them
+  # via temp+alias so bridged namespaces keep their full surface. Without it,
+  # any app importing such a dep fails module eval on boot/graph-reload.
+  '@nativescript/vite@8.0.11': patches/@nativescript__vite@8.0.11.patch

package/template/references.d.ts

@@ -0,0 +1 @@
+/// <reference types="@nativescript/types" />