@gjsify/rolldown-plugin-gjsify 0.4.35 → 0.4.37

package/lib/app/browser.js

@@ -2,13 +2,16 @@
 //
 // Browser builds redirect `@girs/*` and `gi://*` to an empty virtual module
 // (they appear transitively via `@gjsify/unit` and similar packages with
-// GJS-specific code paths). Standard Node.js → browser polyfill aliases
-// for `process` and `assert` keep `@gjsify/unit`'s top-level imports
-// resolvable in a browser bundle.
+// GJS-specific code paths). Bare Node specifiers + their `node:*` prefix
+// variants are routed to `@gjsify/<X>` via the curated
+// `ALIASES_NODE_FOR_BROWSER` table — the dynamic per-runtimes-triplet
+// resolver (`getDerivedAliasesSync`) finishes the routing in a second pass
+// (`@gjsify/<X>` → `@gjsify/<X>/globals` / `@gjsify/empty` depending on the
+// slot declaration).
 import { aliasPlugin } from '../plugins/alias.js';
 import { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
 import blueprintPlugin from '@gjsify/vite-plugin-blueprint';
-import { getDerivedAliasesSync } from '@gjsify/resolve-npm';
+import { ALIASES_NODE_FOR_BROWSER, getDerivedAliasesSync } from '@gjsify/resolve-npm';
 import { globToEntryPoints } from '../utils/entry-points.js';
 import { gjsImportsEmptyPlugin } from '../plugins/gjs-imports-empty.js';
 import { cssAsStringPlugin } from '../plugins/css-as-string.js';
@@ -17,23 +20,34 @@ export const setupForBrowser = async (input) => {
     const external = [...userExternal];
     const exclude = input.pluginOptions.exclude ?? [];
     const entryPoints = await globToEntryPoints(input.input, exclude);
-    // `@gjsify/unit` has `await import('process')` inside a try-catch that
-    // is unreachable in browser (typeof document check comes first), but
-    // Rolldown still resolves it statically. Map to `@gjsify/empty` so the
-    // build succeeds. `assert` → `@gjsify/assert` because `@gjsify/unit`
-    // imports `node:assert` at the top level.
-    const browserPolyfillAliases = {
-        process: '@gjsify/empty',
-        'node:process': '@gjsify/empty',
-        assert: '@gjsify/assert',
-        'node:assert': '@gjsify/assert',
-    };
+    // Bare Node-builtin + `node:*` prefix aliases — both forms route to the
+    // same `@gjsify/<X>` target. Generated deterministically from
+    // `ALIASES_NODE_FOR_BROWSER` so a single source-of-truth in
+    // `@gjsify/resolve-npm` drives every browser-app build (no per-target
+    // hand-curation drift). The `process` entry here flips today's
+    // accidental `@gjsify/empty` to the polyfill (`@gjsify/process`) —
+    // `@gjsify/unit`'s `await import('process')` is unreachable in browser
+    // (typeof document check comes first), but Rolldown still resolves it
+    // statically; the polyfill is the more honest target.
+    const nodePrefixAliases = {};
+    for (const [bare, target] of Object.entries(ALIASES_NODE_FOR_BROWSER)) {
+        nodePrefixAliases[bare] = target;
+        nodePrefixAliases[`node:${bare}`] = target;
+    }
+    // Legacy overrides — kept as a separate Record so future per-target
+    // shims have an explicit landing pad. Today: empty. The `process` /
+    // `assert` entries that lived here historically have moved into
+    // `ALIASES_NODE_FOR_BROWSER` (assert → `@gjsify/assert`, process →
+    // `@gjsify/process`) — pulling them out of this layer means the new
+    // tabular values are not silently shadowed by a stale `@gjsify/empty`.
+    const browserPolyfillAliases = {};
     // Derived `@gjsify/<X>` aliases driven by per-package `gjsify.runtimes`
-    // triplet declarations. Merge order: derived (lowest priority) → hardcoded
-    // browser polyfills → user. Hardcoded entries WIN for the curated specifier
-    // set, preserving 100% backwards-compatible behavior.
+    // triplet declarations. Merge order: derived (lowest priority) → curated
+    // bare/`node:*` Node-builtin map → legacy per-target overrides → user.
+    // Higher tiers WIN on conflict — the user always retains final say.
     const aliasMap = {
         ...getDerivedAliasesSync('browser'),
+        ...nodePrefixAliases,
         ...browserPolyfillAliases,
         ...input.pluginOptions.aliases,
         ...input.userAliases,

package/lib/app/gjs.d.ts

@@ -30,3 +30,20 @@ export interface GjsFactoryInput {
     pluginOptions: PluginOptions;
 }
 export declare const setupForGjs: (input: GjsFactoryInput) => Promise<GjsBuildConfig>;
+/**
+ * Recognize the `/register` and `/register/<feature>` subpath shapes that
+ * `--globals auto` injects into the bundle as side-effect imports.
+ *
+ * Matches every shape that goes through the alias layer + Rolldown
+ * resolution chain to a `@gjsify/<pkg>/register*` target:
+ *   - bare:           `<pkg>/register`, `<pkg>/register/<feature>`
+ *   - fully qualified `@gjsify/<pkg>/register`, `@gjsify/<pkg>/register/<feature>`
+ *   - resolved disk paths under a real `node_modules/<scope>/<pkg>/lib/esm/register*`
+ *
+ * Used by the `--app gjs` externals predicate to force-inline these even
+ * when the user passes them via `bundler.external`. Exported for direct
+ * use by the regression test in `auto-globals.spec.ts`; this is the
+ * canonical contract — change-detector status. Keep in sync with the
+ * `AGENTS.md` §Tree-shakeable globals subpath convention.
+ */
+export declare function isRegisterSubpath(id: string): boolean;

package/lib/app/gjs.js

@@ -58,6 +58,24 @@ export const setupForGjs = async (input) => {
     // string specifiers stay externalised by name.
     const exactExternal = ['cairo', 'gettext', 'system', ...userExternal];
     const external = (id) => {
+        // `@gjsify/<pkg>/register[/<feature>]` and the bare-`<pkg>/register`
+        // form MUST NEVER be externalized for `--app gjs`. These are the
+        // side-effect entry points that `--globals auto` injects to wire
+        // up `globalThis.{Buffer,fetch,…}`; GJS's native ESM loader has no
+        // node_modules walker AND does not follow `package.json#exports`
+        // maps for bare specifiers, so an externalized
+        // `import '@gjsify/buffer/register/buffer'` at runtime would throw
+        // `Module not found` even when `<pkg>/lib/esm/register/buffer.js`
+        // is on disk via the exports map.
+        //
+        // Inlining is the only safe option — the exclusion is by SHAPE
+        // (`*/register` or `*/register/*` substring), not by an explicit
+        // package list, so the invariant scales to every package added
+        // by the tree-shakeable-globals convention. See AGENTS.md
+        // §Tree-shakeable globals — /register subpath convention, and
+        // §Build — Rolldown, platform plugins for the externals policy.
+        if (isRegisterSubpath(id))
+            return false;
         if (id.startsWith('gi://'))
             return true;
         if (exactExternal.includes(id))
@@ -294,3 +312,48 @@ function flattenAliases(map) {
     }
     return out;
 }
+/**
+ * Recognize the `/register` and `/register/<feature>` subpath shapes that
+ * `--globals auto` injects into the bundle as side-effect imports.
+ *
+ * Matches every shape that goes through the alias layer + Rolldown
+ * resolution chain to a `@gjsify/<pkg>/register*` target:
+ *   - bare:           `<pkg>/register`, `<pkg>/register/<feature>`
+ *   - fully qualified `@gjsify/<pkg>/register`, `@gjsify/<pkg>/register/<feature>`
+ *   - resolved disk paths under a real `node_modules/<scope>/<pkg>/lib/esm/register*`
+ *
+ * Used by the `--app gjs` externals predicate to force-inline these even
+ * when the user passes them via `bundler.external`. Exported for direct
+ * use by the regression test in `auto-globals.spec.ts`; this is the
+ * canonical contract — change-detector status. Keep in sync with the
+ * `AGENTS.md` §Tree-shakeable globals subpath convention.
+ */
+export function isRegisterSubpath(id) {
+    // Source-shape: a bare or fully-qualified specifier ending in
+    // `/register` or `/register/<feature>`. The leading `/` rules out
+    // false positives like `register` (the bare word) or
+    // `@scope/unregister`.
+    //
+    //   ✓ `fetch/register`
+    //   ✓ `@gjsify/buffer/register`
+    //   ✓ `@gjsify/node-globals/register/buffer`
+    //   ✗ `register`        (no `/` prefix)
+    //   ✗ `@scope/unregister`  (the `/` is followed by `un`, not `register`)
+    //   ✗ `foo/register.js?query=1`  (query-suffix → treat as resolved-path,
+    //                                  caught by the second branch only when
+    //                                  the file extension is intact)
+    if (/\/register(?:\/[^?]*)?$/.test(id)) {
+        return true;
+    }
+    // Resolved disk-path shape — Rolldown sees these after the alias
+    // plugin + node_modules resolver run. Matches both ESM build output
+    // (`lib/esm/register/<feature>.js`) and any future TS-direct setup
+    // that points the export at `src/register/<feature>.ts`. Strictly
+    // requires the file extension at the end — a Rolldown synthetic-id
+    // suffix like `?query=1` therefore does NOT match (those callers
+    // expect to flow through the normal externals path).
+    if (/[/\\]register(?:[/\\][^/\\]+)?\.(?:[mc]?js|ts)$/.test(id)) {
+        return true;
+    }
+    return false;
+}

package/lib/app/index.d.ts

@@ -1,6 +1,8 @@
-export { setupForGjs } from './gjs.js';
+export { setupForGjs, isRegisterSubpath } from './gjs.js';
 export type { GjsBuildConfig, GjsFactoryInput } from './gjs.js';
 export { setupForNode } from './node.js';
 export type { NodeBuildConfig, NodeFactoryInput } from './node.js';
 export { setupForBrowser } from './browser.js';
 export type { BrowserBuildConfig, BrowserFactoryInput } from './browser.js';
+export { setupForNativescript } from './nativescript.js';
+export type { NativescriptBuildConfig, NativescriptFactoryInput } from './nativescript.js';

package/lib/app/index.js

@@ -1,3 +1,4 @@
-export { setupForGjs } from './gjs.js';
+export { setupForGjs, isRegisterSubpath } from './gjs.js';
 export { setupForNode } from './node.js';
 export { setupForBrowser } from './browser.js';
+export { setupForNativescript } from './nativescript.js';

package/lib/app/nativescript.d.ts

@@ -0,0 +1,17 @@
+import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
+import type { PluginOptions } from '../types/plugin-options.js';
+export interface NativescriptBuildConfig {
+    options: RolldownOptions;
+    plugins: RolldownPluginOption[];
+}
+export interface NativescriptFactoryInput {
+    input?: RolldownOptions['input'];
+    output: {
+        file?: string;
+        dir?: string;
+    };
+    userExternal?: string[];
+    userAliases?: Record<string, string>;
+    pluginOptions: PluginOptions;
+}
+export declare const setupForNativescript: (input: NativescriptFactoryInput) => Promise<NativescriptBuildConfig>;

package/lib/app/nativescript.js

@@ -0,0 +1,130 @@
+// `--app nativescript` Rolldown configuration factory.
+//
+// NativeScript builds target the V8 engine bundled into the NS Android (JNI)
+// and iOS (Objective-C bridge) runtimes. Both runtimes have aligned V8
+// versions since NS 8.5 (V8 10.3.22+) and ship full ES2024 surface, so the
+// transform target is `esnext`.
+//
+// Native bridges (`java.*`, `android.*`, `androidx.*`, `kotlin.*`, `NS*`,
+// `UI*`, `CG*`, `NSObject`, etc.) are exposed as GLOBAL identifiers by the
+// NativeScript runtime at load time — like GJS's `imports.gi.*`, but ambient
+// rather than module-namespaced. They are NOT aliased and NOT externalized;
+// any value reference resolves at runtime against the host globals.
+//
+// `@girs/*` and `gi://*` imports are silenced via `gjsImportsEmptyPlugin` —
+// they appear transitively through `@gjsify/unit` and similar packages with
+// GJS-specific code paths that never execute on NS.
+//
+// Bare Node specifiers + their `node:*` prefix variants are routed to
+// `@gjsify/<X>` via the curated `ALIASES_NODE_FOR_NATIVESCRIPT` table — the
+// dynamic per-runtimes-triplet resolver (`getDerivedAliasesSync`) finishes
+// the routing in a second pass (`@gjsify/<X>` → `@gjsify/<X>/globals` /
+// `@gjsify/empty` depending on the slot declaration).
+//
+// No `cssAsStringPlugin` (NativeScript ships its own CSS pipeline as part
+// of `@nativescript/core`) and no `blueprintPlugin` (Blueprint is GTK-only).
+import { aliasPlugin } from '../plugins/alias.js';
+import { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
+import { ALIASES_NODE_FOR_NATIVESCRIPT, getDerivedAliasesSync } from '@gjsify/resolve-npm';
+import { globToEntryPoints } from '../utils/entry-points.js';
+import { gjsImportsEmptyPlugin } from '../plugins/gjs-imports-empty.js';
+import { platformResolvePlugin, detectNativescriptPlatform, nativescriptPlatformDefines, } from '../plugins/platform-resolve.js';
+export const setupForNativescript = async (input) => {
+    const userExternal = input.userExternal ?? [];
+    const external = [...userExternal];
+    const exclude = input.pluginOptions.exclude ?? [];
+    const entryPoints = await globToEntryPoints(input.input, exclude);
+    // Target platform — discovered from the env NS' CLI sets when it spawns a
+    // bundler (else `undefined` → `.native`-only resolution + neutral defines).
+    // `gjsify build` is a production bundler, so `__DEV__` is `false` here.
+    const platform = detectNativescriptPlatform();
+    // Bare Node-builtin + `node:*` prefix aliases — both forms route to the
+    // same `@gjsify/<X>` target. Generated deterministically from
+    // `ALIASES_NODE_FOR_NATIVESCRIPT` so a single source-of-truth in
+    // `@gjsify/resolve-npm` drives every NS-app build (no per-target
+    // hand-curation drift).
+    const nodePrefixAliases = {};
+    for (const [bare, target] of Object.entries(ALIASES_NODE_FOR_NATIVESCRIPT)) {
+        nodePrefixAliases[bare] = target;
+        nodePrefixAliases[`node:${bare}`] = target;
+    }
+    // Legacy / per-target overrides — kept as a separate Record so future
+    // mobile-specific shims (e.g. an NS-equivalent of `@gjsify/process`)
+    // have an explicit landing pad. Today: empty. New entries SHOULD go
+    // into `ALIASES_NODE_FOR_NATIVESCRIPT` so the same wiring is reachable
+    // from the Vite-plugin track (`gjsifyNativescript()` preset) too.
+    const nativescriptOverrideAliases = {};
+    // Derived `@gjsify/<X>` aliases driven by per-package `gjsify.runtimes`
+    // triplet declarations. Merge order: derived (lowest priority) → curated
+    // bare/`node:*` Node-builtin map → per-target overrides → user.
+    // Higher tiers WIN on conflict — the user always retains final say.
+    const aliasMap = {
+        ...getDerivedAliasesSync('nativescript'),
+        ...nodePrefixAliases,
+        ...nativescriptOverrideAliases,
+        ...input.pluginOptions.aliases,
+        ...input.userAliases,
+    };
+    const options = {
+        input: entryPoints,
+        // NS's V8 is a "browser-shaped" runtime from Rolldown's perspective:
+        // no Node-builtin auto-externals, no globalThis-shaped node-only
+        // semantics. `browser` platform is the closest match — the actual
+        // host environment is provided by the NS runtime at load time, not
+        // by V8 itself.
+        platform: 'browser',
+        external,
+        resolve: {
+            mainFields: ['nativescript', 'module', 'main'],
+            conditionNames: ['import', 'nativescript'],
+        },
+        transform: {
+            target: 'esnext',
+            define: {
+                global: 'globalThis',
+                // NO `window` define — NativeScript apps don't have a DOM
+                // and rely on the canonical absence of `window` to gate
+                // their cross-platform branches.
+                //
+                // Standard NS compile-time platform flags (`__ANDROID__` /
+                // `__IOS__` / `__APPLE__` / `__VISIONOS__` / `__DEV__`) so app
+                // code branching on them is statically resolved + dead-code
+                // eliminated per target — matching the globals
+                // `@nativescript/vite` seeds in its main entry.
+                ...nativescriptPlatformDefines(platform, { dev: false }),
+            },
+        },
+        output: {
+            ...input.output,
+            format: 'esm',
+            sourcemap: false,
+            // Single-bundle output. The NS bundler (@nativescript/webpack or
+            // @nativescript/vite) consumes the resulting `.mjs` as an entry
+            // file and produces the final app bundle from there.
+            codeSplitting: false,
+        },
+        treeshake: true,
+    };
+    const plugins = [
+        gjsImportsEmptyPlugin(),
+        // Platform-specific source variants (`*.android` / `*.ios` /
+        // `*.native`) win over the base file — resolved BEFORE the Node-builtin
+        // alias routing so a platform fork of a portable module is honored.
+        platformResolvePlugin({ platform }),
+        aliasPlugin({ entries: flattenAliases(aliasMap) }),
+        // NO blueprintPlugin — Blueprint is a GTK-specific UI DSL
+        // NO cssAsStringPlugin — NS ships its own CSS pipeline via
+        // @nativescript/core; .css imports are handled by the consuming
+        // @nativescript/webpack or @nativescript/vite build
+        deepkitPlugin({ reflection: input.pluginOptions.reflection }),
+    ];
+    return { options, plugins };
+};
+function flattenAliases(map) {
+    const out = {};
+    for (const [from, to] of Object.entries(map)) {
+        if (to)
+            out[from] = to;
+    }
+    return out;
+}

package/lib/index.d.ts

@@ -12,6 +12,8 @@ export type { TextLoaderPluginOptions, LoaderKind } from './plugins/text-loader.
 export { shebangPlugin, GJS_SHEBANG, NODE_SHEBANG, expandEnvTemplate, resolveShebangLine } from './plugins/shebang.js';
 export type { ShebangPluginOptions } from './plugins/shebang.js';
 export { gjsImportsEmptyPlugin } from './plugins/gjs-imports-empty.js';
+export { platformResolvePlugin, detectNativescriptPlatform, nativescriptPlatformDefines, } from './plugins/platform-resolve.js';
+export type { PlatformResolvePluginOptions, NativescriptPlatform } from './plugins/platform-resolve.js';
 export * from './plugin.js';
 import { gjsifyPlugin } from './plugin.js';
 export { gjsifyPlugin };

package/lib/index.js

@@ -9,6 +9,7 @@ export { cssAsStringPlugin } from './plugins/css-as-string.js';
 export { textLoaderPlugin } from './plugins/text-loader.js';
 export { shebangPlugin, GJS_SHEBANG, NODE_SHEBANG, expandEnvTemplate, resolveShebangLine } from './plugins/shebang.js';
 export { gjsImportsEmptyPlugin } from './plugins/gjs-imports-empty.js';
+export { platformResolvePlugin, detectNativescriptPlatform, nativescriptPlatformDefines, } from './plugins/platform-resolve.js';
 export * from './plugin.js';
 import { gjsifyPlugin } from './plugin.js';
 export { gjsifyPlugin };

package/lib/plugin.js

@@ -10,7 +10,7 @@
 // The CLI consumer (`@gjsify/cli`) calls `gjsifyPlugin(...)` to get back
 // `{ options, plugins }`, then calls `rolldown({ ...options, plugins:
 // [...userPlugins, ...plugins] })`.
-import { setupForGjs, setupForNode, setupForBrowser } from './app/index.js';
+import { setupForGjs, setupForNode, setupForBrowser, setupForNativescript } from './app/index.js';
 import { setupLib } from './library/index.js';
 /**
  * Build the Rolldown configuration template + plugin array for the given
@@ -60,6 +60,14 @@ export const gjsifyPlugin = async (input, pluginOptions = {}) => {
                 userAliases: input.userAliases,
                 pluginOptions,
             });
+        case 'nativescript':
+            return await setupForNativescript({
+                input: input.input,
+                output: input.output,
+                userExternal: input.userExternal,
+                userAliases: input.userAliases,
+                pluginOptions,
+            });
         default:
             throw new TypeError('Unknown app platform: ' + app);
     }

package/lib/plugins/platform-resolve.d.ts

@@ -0,0 +1,34 @@
+import type { Plugin } from 'rolldown';
+export type NativescriptPlatform = 'android' | 'ios' | 'visionos';
+export interface PlatformResolvePluginOptions {
+    /**
+     * Target platform. When omitted, only `.native.*` variants are tried
+     * (the platform-specific `.android.*` / `.ios.*` lookups are skipped).
+     */
+    platform?: NativescriptPlatform;
+}
+/**
+ * Resolve platform-specific source-file variants (`*.android` / `*.ios` /
+ * `*.native`) ahead of the base file. Relative imports only — bare/package
+ * specifiers are left to the normal resolver chain (package platform-`main`
+ * fields are a separate, rarer concern handled by the alias layer).
+ */
+export declare function platformResolvePlugin(options?: PlatformResolvePluginOptions): Plugin;
+/**
+ * Best-effort detection of the NativeScript target platform from the
+ * environment NS' CLI sets when it spawns a bundler (`NATIVESCRIPT_BUNDLER_ENV`
+ * / `NATIVESCRIPT_WEBPACK_ENV` carry the platform; `NATIVESCRIPT_PLATFORM` is
+ * an explicit override). Returns `undefined` when no platform is discernible —
+ * callers then fall back to `.native`-only resolution + neutral defines.
+ */
+export declare function detectNativescriptPlatform(env?: Record<string, string | undefined>): NativescriptPlatform | undefined;
+/**
+ * The standard NativeScript compile-time platform flags, matching the globals
+ * `@nativescript/vite` seeds in its main entry (`__ANDROID__` / `__IOS__` /
+ * `__APPLE__` / `__VISIONOS__` / `__DEV__`). Fed into the bundler's
+ * `transform.define` (Rolldown) / `define` (Vite) so NS app code branching on
+ * these constants is statically resolved + dead-code-eliminated per target.
+ */
+export declare function nativescriptPlatformDefines(platform: NativescriptPlatform | undefined, opts?: {
+    dev?: boolean;
+}): Record<string, string>;

package/lib/plugins/platform-resolve.js

@@ -0,0 +1,135 @@
+// NativeScript / React-Native-style platform file resolution.
+//
+// Lets a shared codebase fork a single module per target platform by file
+// name — `foo.android.ts` / `foo.ios.ts` (platform-specific) or `foo.native.ts`
+// (any native platform, as opposed to the browser's `foo.ts`). An
+// `import './foo'` (or `import './foo.js'`) resolves to the most specific
+// variant that exists, in priority order:
+//
+//   ./foo.<platform>.<ext>   (e.g. ./foo.android.ts) — when a platform is known
+//   ./foo.native.<ext>       — native-but-not-browser
+//   ./foo.<ext>              — the base file (default resolver fallthrough)
+//
+// WHY THIS LIVES IN GJSIFY (not just a dependency on @nativescript/vite):
+// `@nativescript/vite` implements the same lookup as a Vite `resolve.alias`
+// whose `replacement` is a FUNCTION. Vite 8 / Rolldown rejects function
+// replacements on the native alias path (`Failed to convert builtin plugin
+// 'ViteAlias' … function replacement into rust type String`), which breaks the
+// NS production build under Vite 8. Implemented here as a proper `resolveId`
+// plugin HOOK (not a `resolve.alias`), it works identically under Rolldown
+// (the `gjsify build --app nativescript` CLI) AND under Vite 7/8 (the
+// `gjsifyNativescript()` preset) — the function-alias limitation only affects
+// the `resolve.alias` config shorthand, not plugin `resolveId` hooks.
+//
+// Reference: @nativescript/vite `helpers/package-platform-aliases.js`. Original
+// Copyright (c) NativeScript contributors, Apache-2.0. Reimplemented for the
+// gjsify Rolldown/Vite plugin pipeline.
+const PLATFORMS = ['android', 'ios', 'visionos'];
+// JS/TS extensions a source specifier may carry. Stripped so the platform
+// suffix lands BEFORE the extension (`./foo.js` → `./foo.android`).
+const KNOWN_EXT_RE = /\.(tsx?|jsx?|mts|cts|mjs|cjs)$/;
+function isPlatform(value) {
+    return PLATFORMS.includes(value);
+}
+/**
+ * Resolve platform-specific source-file variants (`*.android` / `*.ios` /
+ * `*.native`) ahead of the base file. Relative imports only — bare/package
+ * specifiers are left to the normal resolver chain (package platform-`main`
+ * fields are a separate, rarer concern handled by the alias layer).
+ */
+export function platformResolvePlugin(options = {}) {
+    const platform = options.platform;
+    // Priority: platform-specific suffix first, then the platform-agnostic
+    // `native` suffix. Without a known platform, only `native` applies.
+    const suffixes = platform ? [platform, 'native'] : ['native'];
+    return {
+        name: 'gjsify-nativescript-platform-resolve',
+        resolveId: {
+            order: 'pre',
+            async handler(source, importer, extraOptions) {
+                // Only relative source imports get platform variants.
+                if (!importer)
+                    return null;
+                if (!source.startsWith('./') && !source.startsWith('../'))
+                    return null;
+                const extMatch = KNOWN_EXT_RE.exec(source);
+                const origExt = extMatch ? extMatch[0] : '';
+                const base = origExt ? source.slice(0, -origExt.length) : source;
+                for (const suffix of suffixes) {
+                    // Try the bare form first (the resolver extension-probes,
+                    // so `./foo.android` finds `./foo.android.ts`), then the
+                    // extension-preserving form as a fallback.
+                    const candidates = origExt && `${base}.${suffix}` !== `${base}.${suffix}${origExt}`
+                        ? [`${base}.${suffix}`, `${base}.${suffix}${origExt}`]
+                        : [`${base}.${suffix}`];
+                    for (const candidate of candidates) {
+                        if (candidate === source)
+                            continue;
+                        // `skipSelf: true` re-runs the resolver chain WITHOUT
+                        // this plugin → no recursion on the nested resolve.
+                        const resolved = await this.resolve(candidate, importer, {
+                            skipSelf: true,
+                            ...(extraOptions?.kind ? { kind: extraOptions.kind } : {}),
+                        });
+                        if (resolved && !resolved.external)
+                            return resolved;
+                    }
+                }
+                // No variant on disk → let the default chain resolve the base.
+                return null;
+            },
+        },
+    };
+}
+/**
+ * Best-effort detection of the NativeScript target platform from the
+ * environment NS' CLI sets when it spawns a bundler (`NATIVESCRIPT_BUNDLER_ENV`
+ * / `NATIVESCRIPT_WEBPACK_ENV` carry the platform; `NATIVESCRIPT_PLATFORM` is
+ * an explicit override). Returns `undefined` when no platform is discernible —
+ * callers then fall back to `.native`-only resolution + neutral defines.
+ */
+export function detectNativescriptPlatform(env = process.env) {
+    const direct = env.NATIVESCRIPT_PLATFORM ?? env.NS_PLATFORM;
+    if (direct && isPlatform(direct))
+        return direct;
+    const raw = env.NATIVESCRIPT_BUNDLER_ENV ?? env.NATIVESCRIPT_WEBPACK_ENV;
+    if (raw) {
+        try {
+            const parsed = JSON.parse(raw);
+            // NS' webpack/vite env historically uses `{ android: true }` /
+            // `{ ios: true }` booleans; newer paths may pass `platform`.
+            if (parsed.android === true)
+                return 'android';
+            if (parsed.ios === true)
+                return 'ios';
+            if (parsed.visionos === true)
+                return 'visionos';
+            if (typeof parsed.platform === 'string' && isPlatform(parsed.platform)) {
+                return parsed.platform;
+            }
+        }
+        catch {
+            // Malformed env JSON → undefined (native-only fallback).
+        }
+    }
+    return undefined;
+}
+/**
+ * The standard NativeScript compile-time platform flags, matching the globals
+ * `@nativescript/vite` seeds in its main entry (`__ANDROID__` / `__IOS__` /
+ * `__APPLE__` / `__VISIONOS__` / `__DEV__`). Fed into the bundler's
+ * `transform.define` (Rolldown) / `define` (Vite) so NS app code branching on
+ * these constants is statically resolved + dead-code-eliminated per target.
+ */
+export function nativescriptPlatformDefines(platform, opts = {}) {
+    const isAndroid = platform === 'android';
+    const isIos = platform === 'ios';
+    const isVisionOs = platform === 'visionos';
+    return {
+        __ANDROID__: String(isAndroid),
+        __IOS__: String(isIos),
+        __VISIONOS__: String(isVisionOs),
+        __APPLE__: String(isIos || isVisionOs),
+        __DEV__: String(opts.dev ?? false),
+    };
+}

package/lib/types/app.d.ts

@@ -1 +1 @@
-export type App = 'gjs' | 'node' | 'browser';
+export type App = 'gjs' | 'node' | 'browser' | 'nativescript';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/rolldown-plugin-gjsify",
-    "version": "0.4.35",
+    "version": "0.4.37",
     "description": "Rolldown / Rollup / Vite plugin orchestrator for GJS, Node, and Browser targets",
     "type": "module",
     "main": "lib/index.js",
@@ -48,20 +48,20 @@
     ],
     "license": "MIT",
     "dependencies": {
-        "@gjsify/console": "^0.4.35",
-        "@gjsify/resolve-npm": "^0.4.35",
-        "@gjsify/rolldown-plugin-deepkit": "^0.4.35",
-        "@gjsify/rolldown-plugin-pnp": "^0.4.35",
-        "@gjsify/vite-plugin-blueprint": "^0.4.35",
-        "@rollup/pluginutils": "^5.3.0",
+        "@gjsify/console": "^0.4.37",
+        "@gjsify/resolve-npm": "^0.4.37",
+        "@gjsify/rolldown-plugin-deepkit": "^0.4.37",
+        "@gjsify/rolldown-plugin-pnp": "^0.4.37",
+        "@gjsify/vite-plugin-blueprint": "^0.4.37",
+        "@rollup/pluginutils": "^5.4.0",
         "acorn": "^8.16.0",
         "acorn-walk": "^8.3.5",
         "fast-glob": "^3.3.3",
         "lightningcss": "^1.32.0"
     },
     "peerDependencies": {
-        "@gjsify/lightningcss-native": "^0.4.35",
-        "rolldown": "^1.0.0"
+        "@gjsify/lightningcss-native": "^0.4.37",
+        "rolldown": "^1.0.3"
     },
     "peerDependenciesMeta": {
         "@gjsify/lightningcss-native": {
@@ -73,7 +73,7 @@
     },
     "devDependencies": {
         "@types/node": "^25.9.1",
-        "rolldown": "^1.0.0",
-        "typescript": "^6.0.3"
+        "rolldown": "^1.0.3",
+        "typescript": "^5.9.3"
     }
 }