@gjsify/rolldown-plugin-gjsify 0.42.0 → 0.44.0

package/lib/app/browser.d.ts

@@ -1,6 +1,8 @@
 import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
 import type { PluginOptions } from '../types/plugin-options.js';
 export interface BrowserBuildConfig {
+    /** Transforms that must see the ORIGINAL source; composed before the caller's plugins. */
+    prePlugins: RolldownPluginOption[];
     options: RolldownOptions;
     plugins: RolldownPluginOption[];
 }

package/lib/app/browser.js

@@ -86,11 +86,13 @@ export const setupForBrowser = async (input) => {
     // the unresolved-workspace-import guard below so the guard reports the same
     // promise the alias layer made.
     const aliasEntries = flattenAliases(aliasMap);
+    // Reflection reads the ORIGINAL TypeScript, so it runs before any user
+    // transform can strip the annotations out from under it (see `GjsifyConfig`).
+    const prePlugins = [deepkitPlugin({ reflection: input.pluginOptions.reflection })];
     const plugins = [
         gjsImportsEmptyPlugin(),
         aliasPlugin({ entries: aliasEntries }),
         blueprintPlugin(),
-        deepkitPlugin({ reflection: input.pluginOptions.reflection }),
         cssAsStringPlugin(),
         // `order: 'post'` — see app/gjs.ts. The browser target's whole job is to
         // replace Node builtins with their `@gjsify/*` browser entries; when one
@@ -103,7 +105,7 @@ export const setupForBrowser = async (input) => {
             isExternal: (id) => external.includes(id),
         }),
     ];
-    return { options, plugins };
+    return { options, prePlugins, plugins };
 };
 function flattenAliases(map) {
     const out = {};

package/lib/app/gjs.d.ts

@@ -3,6 +3,8 @@ import type { PluginOptions } from '../types/plugin-options.js';
 import type { GiSystemProbe } from '../plugins/gi-runtime-paths.js';
 /** Resolved Rolldown configuration template + plugins for `--app gjs`. */
 export interface GjsBuildConfig {
+    /** Transforms that must see the ORIGINAL source; composed before the caller's plugins. */
+    prePlugins: RolldownPluginOption[];
     options: RolldownOptions;
     plugins: RolldownPluginOption[];
 }

package/lib/app/gjs.js

@@ -9,6 +9,9 @@ import { aliasPlugin } from '../plugins/alias.js';
 import { externalsPlugin } from '../plugins/externals.js';
 import { napiNodeAddonPlugin } from '../plugins/napi-node-addon.js';
 import { unresolvedWorkspaceImportPlugin } from '../plugins/unresolved-workspace-import.js';
+import { platformResolvePlugin, desktopSuffixChain, desktopOsSuffix, DESKTOP_REFUSED_SUFFIXES, } from '../plugins/platform-resolve.js';
+import { reactNativeAliasPlugin } from '../plugins/react-native-alias.js';
+import { reactNativeSupportGatePlugin } from '../plugins/react-native-gate.js';
 import { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
 import blueprintPlugin from '@gjsify/vite-plugin-blueprint';
 import { getAliasesForGjs } from '../utils/alias.js';
@@ -158,6 +161,18 @@ export const setupForGjs = async (input) => {
         'random-access-file': 'random-access-file/index.js',
         ...flattenAliases(aliasMap),
     };
+    // Reflection reads the ORIGINAL TypeScript, so it runs before any user
+    // transform can strip the annotations out from under it (see `GjsifyConfig`).
+    const prePlugins = [deepkitPlugin({ reflection: input.pluginOptions.reflection })];
+    // ADR 0032 § 8's build-time gate reads the ORIGINAL source for the same reason
+    // reflection does: `import type { ViewProps }` is what tells it a name costs
+    // nothing, and a normal-order transform may already have stripped it.
+    // This target composes a dialect, so it is one of `DIALECT_APPS` — the set
+    // the CLI refuses `--dialect` against for every OTHER target. Adding a
+    // dialect here without adding the target there means a flag accepted and
+    // silently ignored.
+    if (input.pluginOptions.dialect === 'react-native')
+        prePlugins.push(reactNativeSupportGatePlugin());
     const plugins = [
         // Virtual-entry plugin runs FIRST so its resolveId/load match the
         // synthetic input ids that `wrapInputWithSideEffects` produces.
@@ -167,6 +182,22 @@ export const setupForGjs = async (input) => {
         // banner, and acorn (the auto-globals detector) rejects the `#` byte.
         // The final-output shebang is composed by shebangPlugin's renderChunk.
         inputShebangStripPlugin(),
+        // Platform-file forks for the desktop, ADR 0032 § 9: `.gtk` → `.<os>` →
+        // `.desktop` → base. BEFORE the alias layer, so a platform fork of a
+        // module that also has a Node-builtin substitution wins over the
+        // substitution — the fork is the more specific statement. `.native` and
+        // `.web` are deliberately absent from the chain and warned about when
+        // present; `DESKTOP_REFUSED_SUFFIXES` carries the reason.
+        platformResolvePlugin({
+            suffixes: desktopSuffixChain(desktopOsSuffix()),
+            refusedSuffixes: DESKTOP_REFUSED_SUFFIXES,
+            siblingIndex: true,
+        }),
+        // ADR 0032 § 2's alias line, only when the consumer asked for it
+        // (`--dialect react-native`). `pre`, ahead of the substitution table and the
+        // externals policy — a redirect after `externalsPlugin` would find the
+        // specifier already externalised.
+        ...(input.pluginOptions.dialect === 'react-native' ? [reactNativeAliasPlugin()] : []),
         // random-access-file's 'browser' field maps to a throwing stub; the alias
         // table forces the fs-backed Node entry.
         aliasPlugin({ entries: aliasEntries }),
@@ -184,7 +215,6 @@ export const setupForGjs = async (input) => {
         // first.
         externalsPlugin(external, { name: 'gjsify-gjs-externalize' }),
         blueprintPlugin(),
-        deepkitPlugin({ reflection: input.pluginOptions.reflection }),
         // GTK4's CSS engine is much older than browser engines — its
         // parser predates nesting + many modern selectors. Targeting
         // `firefox: 60 << 16` makes lightningcss flatten the source
@@ -218,7 +248,7 @@ export const setupForGjs = async (input) => {
                 : {}),
         }),
     ];
-    return { options, plugins };
+    return { options, prePlugins, plugins };
 };
 /** Copy the alias map, dropping entries with an empty target. */
 function flattenAliases(map) {

package/lib/app/nativescript.d.ts

@@ -1,6 +1,8 @@
 import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
 import type { PluginOptions } from '../types/plugin-options.js';
 export interface NativescriptBuildConfig {
+    /** Transforms that must see the ORIGINAL source; composed before the caller's plugins. */
+    prePlugins: RolldownPluginOption[];
     options: RolldownOptions;
     plugins: RolldownPluginOption[];
 }

package/lib/app/nativescript.js

@@ -37,7 +37,7 @@ 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';
+import { platformResolvePlugin, nativescriptSuffixChain, detectNativescriptPlatform, nativescriptPlatformDefines, } from '../plugins/platform-resolve.js';
 import { unresolvedWorkspaceImportPlugin } from '../plugins/unresolved-workspace-import.js';
 // Never bundled: an app works only with the ONE core instance the runtime boots, and what
 // this target emits is an ENTRY the NS bundler resolves it for. An optional peer absent from
@@ -124,18 +124,20 @@ export const setupForNativescript = async (input) => {
     // the unresolved-workspace-import guard below so the guard reports the same
     // promise the alias layer made.
     const aliasEntries = flattenAliases(aliasMap);
+    // Reflection reads the ORIGINAL TypeScript, so it runs before any user
+    // transform can strip the annotations out from under it (see `GjsifyConfig`).
+    const prePlugins = [deepkitPlugin({ reflection: input.pluginOptions.reflection })];
     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 }),
+        platformResolvePlugin({ suffixes: nativescriptSuffixChain(platform) }),
         aliasPlugin({ entries: aliasEntries }),
         // 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 }),
         // `order: 'post'` — see app/gjs.ts. Native-bridge identifiers
         // (`java.*`, `NS*`, …) are ambient GLOBALS on this target, never
         // imports, so they never reach this hook; only a `@gjsify/*` edge does,
@@ -147,7 +149,7 @@ export const setupForNativescript = async (input) => {
             isExternal,
         }),
     ];
-    return { options, plugins };
+    return { options, prePlugins, plugins };
 };
 function flattenAliases(map) {
     const out = {};

package/lib/app/node.d.ts

@@ -6,12 +6,15 @@ import type { PluginOptions } from '../types/plugin-options.js';
  * factory, matchMedia, …) over `@gjsify/node-gi`, not the default `@gjsify/empty`
  * stubs that keep CROSS-PLATFORM node bundles loadable on plain Node.
  *
- * Two adjustments over the standard node alias map:
+ * Three adjustments over the standard node alias map:
  *  1. every `<pkg>/register…` → `@gjsify/empty` entry is DROPPED so the register
  *     import resolves to its real body;
  *  2. the gjs target's bare→scoped register routes (`xmlhttprequest/register` →
  *     `@gjsify/fetch/register/xhr`, …) are merged in so the inject stub's bare
- *     specifiers resolve on node exactly as they do on gjs.
+ *     specifiers resolve on node exactly as they do on gjs;
+ *  3. `REVERSE_BRIDGE_ENTRY_ROUTES` is merged in, so a package whose `node`
+ *     export condition is a different program (solid-js's SSR build) is routed
+ *     to the entry the `--app gjs` build of the same source gets.
  *
  * Applied to the BASE map only, when `isGjsSourceBuild` — `pluginOptions.aliases` /
  * user aliases still override, and a non-reverse-bridge build is untouched.
@@ -54,6 +57,8 @@ export declare function isGjsSourceBuild(options: {
     registerInject?: string | undefined;
 }): boolean;
 export interface NodeBuildConfig {
+    /** Transforms that must see the ORIGINAL source; composed before the caller's plugins. */
+    prePlugins: RolldownPluginOption[];
     options: RolldownOptions;
     plugins: RolldownPluginOption[];
 }

package/lib/app/node.js

@@ -1,4 +1,5 @@
 // `--app node` Rolldown configuration factory.
+import { createRequire } from 'node:module';
 import { aliasPlugin } from '../plugins/alias.js';
 import blueprintPlugin from '@gjsify/vite-plugin-blueprint';
 import { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
@@ -10,6 +11,9 @@ import { cssAsStringPlugin } from '../plugins/css-as-string.js';
 import { gjsImportsEmptyPlugin } from '../plugins/gjs-imports-empty.js';
 import { gjsGiNodePlugin, gjsBuiltinModulesNodePlugin } from '../plugins/gjs-gi-node.js';
 import { unresolvedWorkspaceImportPlugin } from '../plugins/unresolved-workspace-import.js';
+import { platformResolvePlugin, desktopSuffixChain, desktopOsSuffix, DESKTOP_REFUSED_SUFFIXES, } from '../plugins/platform-resolve.js';
+import { reactNativeAliasPlugin } from '../plugins/react-native-alias.js';
+import { reactNativeSupportGatePlugin } from '../plugins/react-native-gate.js';
 import { wrapInputWithSideEffects } from '../utils/entry-wrapper.js';
 /**
  * Side-effect specifier the node target injects when GJS ambient globals
@@ -38,18 +42,100 @@ const NODE_GI_GLOBALS_SPECIFIER = '@gjsify/node-gi/globals';
 const NODE_GI_BARE_MODULE_SPECIFIERS = Object.values(ALIASES_GJS_FOR_NODE);
 /** Matches a register subpath in an alias key: `<pkg>/register` or `<pkg>/register/<feature>`. */
 const REGISTER_SUBPATH_RE = /\/register(\/|$)/;
+/**
+ * npm packages a REVERSE-BRIDGE build must be routed away from, because their
+ * `node` export condition is not a node build of the same program — it is a
+ * DIFFERENT program, chosen for an assumption a GJS-on-node bundle does not
+ * hold. The value is the entry the `--app gjs` build of the same source gets,
+ * so the two ADR 0030 legs run one program.
+ *
+ * `solid-js` is the measured case and so far the only one. Its export map
+ * routes `node` (and `deno`, and `worker`) to `dist/server.js` — the SSR
+ * build, whose `createEffect` is `function createEffect(fn, value) {}`, an
+ * empty body. The initial render is therefore PERFECT and every reactive
+ * update silently never reaches GTK: sixteen of @gjsify/gtk-host's node-leg
+ * suites failed as `Expected ["second"], Actual ["first"]` while the identical
+ * source passed on gjs, and under ADR 0030's "same suite green on gjs ⇒
+ * node-gi defect" that read as a binding defect for as long as it stood. The
+ * map's own top-level `import`/`require` keys already point at the client
+ * build — `node` merely shadows them, being declared first.
+ *
+ * A ROUTE and not a condition change, deliberately. The obvious fix is to stop
+ * applying `node`, and it does not work: `platform: 'node'` implies that
+ * condition whatever `conditionNames` says (measured — dropping it from the
+ * list left solid-js on the SSR build). The reachable lever is `browser`,
+ * which outranks `node` in solid-js's map, and taking it wholesale is the
+ * SYMMETRIC defect: the gjs target can afford `browser` only because
+ * `getAliasesForGjs` has already replaced the node-facing npm packages, while
+ * the reverse bridge lifts the `/register` routes and keeps the rest real. Then
+ * `ws` — whose map declares `browser` FIRST, pointing at a one-line
+ * `throw new Error('ws does not work in the browser…')` — took the node-gi
+ * consumer harness from `pass 19/19` to `0/5 passed, 10 failed`, every one
+ * `W.WebSocket is not a constructor`. One named package resolves differently;
+ * every other package, and every cross-platform node bundle, is byte-unchanged.
+ */
+const REVERSE_BRIDGE_ENTRY_ROUTES = {
+    // The client build both legs share. Subpaths need no route: `solid-js/universal`
+    // (the renderer @gjsify/gtk-host binds to) declares no `node` condition at all,
+    // and reaches the root through this same specifier.
+    'solid-js': 'solid-js/dist/solid.js',
+};
+/**
+ * A dangling route above is SILENT, and silence here restores exactly the bug
+ * the route exists to prevent. MEASURED: point the solid-js route at a file
+ * that does not exist and the build exits 0 with an EMPTY log — `aliasPlugin`
+ * answers an unresolvable target with `null`, which a `pre`-order `resolveId`
+ * means as "let the default chain continue", and the default chain is the
+ * `node` condition, i.e. the SSR build with the empty `createEffect`. So a
+ * route that stops resolving fails the BUILD instead, naming the package.
+ *
+ * The CONTROL is the unrouted resolution of the same specifier — what the
+ * route replaces. If that does not resolve, the package is not in this
+ * project's graph at all and there is nothing to route (the routes are a
+ * table, not a dependency list). If it DOES resolve, the routed entry must
+ * too: a package that is installed and whose client entry has moved is the
+ * one case that must not pass quietly.
+ *
+ * `createRequire` is used only as an `exports`-map-aware RESOLVER, as in
+ * `app/gjs.ts`'s `resolveShim`; nothing is loaded through it.
+ */
+function assertReverseBridgeRoutes() {
+    const require_ = createRequire(import.meta.url);
+    const resolves = (specifier) => {
+        try {
+            require_.resolve(specifier);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    for (const [pkg, target] of Object.entries(REVERSE_BRIDGE_ENTRY_ROUTES)) {
+        if (!resolves(pkg))
+            continue; // not in this graph — see the CONTROL note
+        if (resolves(target))
+            continue;
+        throw new Error(`@gjsify/rolldown-plugin-gjsify: the reverse-bridge entry route for "${pkg}" is dangling — ` +
+            `"${target}" does not resolve, while "${pkg}" does. Without the route this build silently ` +
+            `takes ${pkg}'s "node" export condition, which is why the route exists; update ` +
+            `REVERSE_BRIDGE_ENTRY_ROUTES in app/node.ts to the entry the --app gjs build resolves.`);
+    }
+}
 /**
  * Reverse-bridge register routing: a node build of a GENUINE GJS SOURCE needs the
  * REAL `@gjsify/*` register bodies (document, HTMLCanvasElement, the `'2d'` context
  * factory, matchMedia, …) over `@gjsify/node-gi`, not the default `@gjsify/empty`
  * stubs that keep CROSS-PLATFORM node bundles loadable on plain Node.
  *
- * Two adjustments over the standard node alias map:
+ * Three adjustments over the standard node alias map:
  *  1. every `<pkg>/register…` → `@gjsify/empty` entry is DROPPED so the register
  *     import resolves to its real body;
  *  2. the gjs target's bare→scoped register routes (`xmlhttprequest/register` →
  *     `@gjsify/fetch/register/xhr`, …) are merged in so the inject stub's bare
- *     specifiers resolve on node exactly as they do on gjs.
+ *     specifiers resolve on node exactly as they do on gjs;
+ *  3. `REVERSE_BRIDGE_ENTRY_ROUTES` is merged in, so a package whose `node`
+ *     export condition is a different program (solid-js's SSR build) is routed
+ *     to the entry the `--app gjs` build of the same source gets.
  *
  * Applied to the BASE map only, when `isGjsSourceBuild` — `pluginOptions.aliases` /
  * user aliases still override, and a non-reverse-bridge build is untouched.
@@ -65,6 +151,8 @@ export function enableGjsRegistersForNode(baseAliases) {
         if (REGISTER_SUBPATH_RE.test(key))
             out[key] = value;
     }
+    // 3. the packages whose `node` export is a different PROGRAM — see the table.
+    Object.assign(out, REVERSE_BRIDGE_ENTRY_ROUTES);
     return out;
 }
 /**
@@ -153,6 +241,9 @@ export const setupForNode = async (input) => {
     // predicate's doc comment. The node-gi golden `test/canvas2d-bridge.test.mjs`
     // pins the asymmetry it fixed.
     const gjsSourceBuild = isGjsSourceBuild({ ...input.pluginOptions, registerInject });
+    // Only a reverse-bridge build carries the routes, so only it is held to them.
+    if (gjsSourceBuild)
+        assertReverseBridgeRoutes();
     const baseAliases = getAliasesForNode({ external });
     const aliasMap = {
         ...(gjsSourceBuild ? enableGjsRegistersForNode(baseAliases) : baseAliases),
@@ -206,6 +297,18 @@ export const setupForNode = async (input) => {
         },
         treeshake: true,
     };
+    // Reflection reads the ORIGINAL TypeScript, so it runs before any user
+    // transform can strip the annotations out from under it (see `GjsifyConfig`).
+    const prePlugins = [deepkitPlugin({ reflection: input.pluginOptions.reflection })];
+    // ADR 0032 § 8's build-time gate reads the ORIGINAL source for the same reason
+    // reflection does: `import type { ViewProps }` is what tells it a name costs
+    // nothing, and a normal-order transform may already have stripped it.
+    // This target composes a dialect, so it is one of `DIALECT_APPS` — the set
+    // the CLI refuses `--dialect` against for every OTHER target. Adding a
+    // dialect here without adding the target there means a flag accepted and
+    // silently ignored.
+    if (input.pluginOptions.dialect === 'react-native')
+        prePlugins.push(reactNativeSupportGatePlugin());
     const plugins = [
         // Virtual-entry plugin runs FIRST so its resolveId/load match the synthetic
         // `\0gjsify-entry:` ids `wrapInputWithSideEffects` produces (no-op when
@@ -233,12 +336,27 @@ export const setupForNode = async (input) => {
         //     `requireGi('Adw','1')` with no lowercased-pkg→namespace map needed.
         //     This plugin's own `gi://` branch is dead on the node target.
         gjsImportsEmptyPlugin({ emptyGirs: !gjsSourceBuild }),
+        // Platform-file forks for the desktop, ADR 0032 § 9: `.gtk` → `.<os>` →
+        // `.desktop` → base. BEFORE the alias layer, so a platform fork of a
+        // module that also has a Node-builtin substitution wins over the
+        // substitution — the fork is the more specific statement. `.native` and
+        // `.web` are deliberately absent from the chain and warned about when
+        // present; `DESKTOP_REFUSED_SUFFIXES` carries the reason.
+        platformResolvePlugin({
+            suffixes: desktopSuffixChain(desktopOsSuffix()),
+            refusedSuffixes: DESKTOP_REFUSED_SUFFIXES,
+            siblingIndex: true,
+        }),
+        // ADR 0032 § 2's alias line, only when the consumer asked for it
+        // (`--dialect react-native`). `pre`, ahead of the substitution table and the
+        // externals policy — a redirect after `externalsPlugin` would find the
+        // specifier already externalised.
+        ...(input.pluginOptions.dialect === 'react-native' ? [reactNativeAliasPlugin()] : []),
         aliasPlugin({ entries: aliasEntries }),
         // Blueprint (.blp → XML string): the reverse bridge runs REAL GTK on Node,
         // so a GJS app entry with composite-template windows must build for
         // `--app node` too. Claims only `.blp` — inert for plain-Node bundles.
         blueprintPlugin(),
-        deepkitPlugin({ reflection: input.pluginOptions.reflection }),
         // On a node-gi build (REAL GTK on Node) lower the CSS to GTK 4's subset just
         // as `--app gjs` does, so nesting/`&` is FLATTENED before it reaches
         // `Gtk.CssProvider.load_from_string` — GTK 4's parser otherwise rejects
@@ -254,7 +372,7 @@ export const setupForNode = async (input) => {
         // specifier at runtime.
         unresolvedWorkspaceImportPlugin({ target: 'node', aliases: aliasEntries, isExternal: external }),
     ];
-    return { options, plugins };
+    return { options, prePlugins, plugins };
 };
 function flattenAliases(map) {
     const out = {};

package/lib/index.d.ts

@@ -22,8 +22,16 @@ export { unresolvedWorkspaceImportPlugin, classifyImport, isWorkspaceSpecifier,
 export type { WorkspaceImportGuardOptions, WorkspaceImportGuardTarget, ImportVerdict, ClassifyImportInput, UnresolvedWorkspaceImportDetails, } from './plugins/unresolved-workspace-import.js';
 export { napiNodeAddonPlugin, resolveAddonPath, nearestPackageRoot, classifySpecifier, directNodeShim, nodeGypBuildShim, bindingsShim, napiRsShim, ADDON_FILTER_RE, isNapiRsPackageJson, isNapiRsSibling, isGjsifyNativeBridge, detectNapiRsEntry, hostNapiRsTriple, AddonNotBuiltError, } from './plugins/napi-node-addon.js';
 export type { NapiNodeAddonPluginOptions, AddonPackageJson } from './plugins/napi-node-addon.js';
-export { platformResolvePlugin, detectNativescriptPlatform, nativescriptPlatformDefines, } from './plugins/platform-resolve.js';
+export { platformResolvePlugin, nativescriptSuffixChain, desktopSuffixChain, desktopOsSuffix, DESKTOP_OS_SUFFIXES, DESKTOP_REFUSED_SUFFIXES, PlatformVariantExternalError, detectNativescriptPlatform, nativescriptPlatformDefines, } from './plugins/platform-resolve.js';
 export type { PlatformResolvePluginOptions, NativescriptPlatform } from './plugins/platform-resolve.js';
+export { rnRouteManifestPlugin, renderRouteManifest, walkRoutes, RouteManifestError, RN_ROUTES_MODULE_ID, MAX_ROUTE_DEPTH, } from './plugins/rn-route-manifest.js';
+export type { RnRouteManifestOptions, FoundRoute } from './plugins/rn-route-manifest.js';
+export { reactNativeAliasPlugin, classifyReactNativeSpecifier, REACT_NATIVE_ALIAS_TARGET, REACT_NATIVE_SPECIFIER, ReactNativeDeepImportError, ReactNativeAliasTargetMissingError, } from './plugins/react-native-alias.js';
+export type { ReactNativeSpecifierKind } from './plugins/react-native-alias.js';
+export { reactNativeSupportGatePlugin, loadSupportTable, findSupportViolations, formatSupportViolations, formatOpaqueReference, formatUnreadableModule, SUPPORT_TABLE_SUBPATH, WATCHED_SPECIFIERS, ReactNativeUnsupportedImportError, SupportTableUnreadableError, } from './plugins/react-native-gate.js';
+export type { ReactNativeSupportGateOptions, SupportTableReader, SupportTableResolver, SupportViolation, } from './plugins/react-native-gate.js';
+export { scanNamedImports, ImportScanParseError } from './utils/scan-named-imports.js';
+export type { NamedImport, OpaqueReference, ScanResult } from './utils/scan-named-imports.js';
 export * from './plugin.js';
 import { gjsifyPlugin } from './plugin.js';
 export { gjsifyPlugin };

package/lib/index.js

@@ -14,7 +14,11 @@ export { gjsImportsEmptyPlugin } from './plugins/gjs-imports-empty.js';
 export { externalsPlugin } from './plugins/externals.js';
 export { unresolvedWorkspaceImportPlugin, classifyImport, isWorkspaceSpecifier, formatUnresolvedWorkspaceImport, buildReverseAliasIndex, UnresolvedWorkspaceImportError, } from './plugins/unresolved-workspace-import.js';
 export { napiNodeAddonPlugin, resolveAddonPath, nearestPackageRoot, classifySpecifier, directNodeShim, nodeGypBuildShim, bindingsShim, napiRsShim, ADDON_FILTER_RE, isNapiRsPackageJson, isNapiRsSibling, isGjsifyNativeBridge, detectNapiRsEntry, hostNapiRsTriple, AddonNotBuiltError, } from './plugins/napi-node-addon.js';
-export { platformResolvePlugin, detectNativescriptPlatform, nativescriptPlatformDefines, } from './plugins/platform-resolve.js';
+export { platformResolvePlugin, nativescriptSuffixChain, desktopSuffixChain, desktopOsSuffix, DESKTOP_OS_SUFFIXES, DESKTOP_REFUSED_SUFFIXES, PlatformVariantExternalError, detectNativescriptPlatform, nativescriptPlatformDefines, } from './plugins/platform-resolve.js';
+export { rnRouteManifestPlugin, renderRouteManifest, walkRoutes, RouteManifestError, RN_ROUTES_MODULE_ID, MAX_ROUTE_DEPTH, } from './plugins/rn-route-manifest.js';
+export { reactNativeAliasPlugin, classifyReactNativeSpecifier, REACT_NATIVE_ALIAS_TARGET, REACT_NATIVE_SPECIFIER, ReactNativeDeepImportError, ReactNativeAliasTargetMissingError, } from './plugins/react-native-alias.js';
+export { reactNativeSupportGatePlugin, loadSupportTable, findSupportViolations, formatSupportViolations, formatOpaqueReference, formatUnreadableModule, SUPPORT_TABLE_SUBPATH, WATCHED_SPECIFIERS, ReactNativeUnsupportedImportError, SupportTableUnreadableError, } from './plugins/react-native-gate.js';
+export { scanNamedImports, ImportScanParseError } from './utils/scan-named-imports.js';
 export * from './plugin.js';
 import { gjsifyPlugin } from './plugin.js';
 export { gjsifyPlugin };

package/lib/library/lib.d.ts

@@ -1,6 +1,8 @@
 import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
 import type { PluginOptions } from '../types/plugin-options.js';
 export interface LibBuildConfig {
+    /** Transforms that must see the ORIGINAL source; composed before the caller's plugins. */
+    prePlugins: RolldownPluginOption[];
     options: RolldownOptions;
     plugins: RolldownPluginOption[];
 }

package/lib/library/lib.js

@@ -9,6 +9,7 @@
 // library config: consumers downstream (downstream apps using `gjsify
 // build --app gjs|node|browser`) re-bundle and apply their own target
 // lowering. Library output stays maximally portable.
+import blueprintPlugin from '@gjsify/vite-plugin-blueprint';
 import { aliasPlugin } from '../plugins/alias.js';
 import { cssAsStringPlugin } from '../plugins/css-as-string.js';
 import { externalsPlugin } from '../plugins/externals.js';
@@ -90,8 +91,18 @@ export const setupLib = async (input) => {
         // tiny JS module re-exporting the CSS source, which preserveModules
         // emits 1:1.
         cssAsStringPlugin(),
+        // Same shape as the CSS hook above, and needed for the same reason: without it a `.blp`
+        // import reaches rolldown's JS parser, and a Blueprint file's first line — `using Gtk 4.0;`
+        // — is VALID JavaScript (a `using` resource declaration missing its initializer), so the
+        // build dies on "Using declarations must have an initializer" and nothing points at
+        // Blueprint. Only the app factories installed it, which quietly made Blueprint an
+        // application-only feature: a shared widget in a library package could not have a
+        // template, so its captions had to be assigned from TypeScript, where they carry no
+        // `translatable` attribute and no catalogue can ever reach them.
+        blueprintPlugin(),
     ];
-    return { options, plugins };
+    // Library mode wires no reflection at all; the empty slot says so out loud.
+    return { options, prePlugins: [], plugins };
 };
 /**
  * Whether a specifier should stay external in library mode: a bare /

package/lib/plugin.d.ts

@@ -3,6 +3,21 @@ import type { PluginOptions } from './types/plugin-options.js';
 import type { GiSystemProbe } from './plugins/gi-runtime-paths.js';
 export interface GjsifyConfig {
     options: RolldownOptions;
+    /**
+     * Transforms that must see the ORIGINAL module source — composed BEFORE the
+     * caller's own plugins, while `plugins` stays after them.
+     *
+     * The split exists because the two positions answer different questions. User
+     * plugins go first so their `resolveId`/`load` wins over gjsify's alias and
+     * externals chain. But a user `transform: { order: 'pre' }` that REWRITES the
+     * source then also beats gjsify's own pre-transforms, and Deepkit's type
+     * compiler is one of them: `@gjsify/rolldown-plugin-solid` runs
+     * `@babel/preset-typescript` over every `.tsx`, so Deepkit was handed a file
+     * with no type annotations left. MEASURED on one `.tsx` carrying both a
+     * `typeOf<T>()` and a JSX tag: `const reflected = typeOf()` in the artifact,
+     * exit 0, not one diagnostic, and `Error: No type given` thrown at runtime.
+     */
+    prePlugins: RolldownPluginOption[];
     plugins: RolldownPluginOption[];
 }
 export interface GjsifyPluginInput {

package/lib/plugins/intl-segmenter-banner.d.ts

@@ -0,0 +1 @@
+export declare const GJS_INTL_SEGMENTER_STUB: string;

package/lib/plugins/intl-segmenter-banner.js

@@ -0,0 +1,42 @@
+// One-line banner that supplies `Intl.Segmenter` on a GJS built without it.
+//
+// THE INCIDENT — measured, not hypothetical. `gjsify ship`'s first CI leg on a
+// bare `ubuntu-latest` (the one that exists to hand a `.deb` to a real `dpkg`)
+// installed the shipped package, ran the binary, and got:
+//
+//     JS ERROR: TypeError: Intl.Segmenter is not a constructor
+//
+// Not an old runtime: that host had **gjs 1.88.1**, the same version as the
+// Fedora container where everything passes. The difference is the ICU the two
+// were built against, so a version number does not predict it — and the `.deb`
+// this project ships declares `Depends: gjs >= 1.82`, which apt satisfies on
+// that host. Install succeeds, program does not start: verbatim the failure
+// class `depends.ts` was written to prevent, one layer below where it looks.
+//
+// WHY THE CLI NEEDS IT AT ALL, and why no application code is involved:
+// `@gjsify/cli` → `yargs@18` → `string-width@7` → `get-east-asian-width`, which
+// constructs a `Intl.Segmenter` AT MODULE SCOPE. It is the argument parser, so
+// every command dies, `--help` included — reproduced locally by deleting
+// `Intl.Segmenter` before importing the published bundle.
+//
+// WHAT THIS FALLBACK IS, AND IS NOT. It segments by CODE POINT, not by grapheme
+// cluster, because a correct cluster algorithm is a Unicode table this banner
+// cannot carry. Measured against native, via `string-width`:
+//
+//     'hello' 5→5   'あいう' 6→6   '🇩🇪' 2→2   'café' 4→4      (identical)
+//     '👨‍👩‍👧‍👦'  2→8   '👍🏽'    2→4                            (over-counted)
+//
+// So ASCII, CJK, flags and combining accents are exact; ZWJ sequences and skin
+// tone modifiers come out too wide. The cost is a misaligned column in terminal
+// output containing those emoji. The cost of not having it is that nothing runs
+// at all. It is installed ONLY when the constructor is missing, so on every GJS
+// with a full ICU — every currently green CI leg — this line does nothing.
+//
+// Kept on a single line, like the sibling banners: the banner runs before any
+// source-map-aware machinery, so a newline here shifts every bundle line by one.
+export const GJS_INTL_SEGMENTER_STUB = 'if(typeof Intl.Segmenter!=="function")Intl.Segmenter=class Segmenter{' +
+    'constructor(){}' +
+    'resolvedOptions(){return{locale:"en",granularity:"grapheme"}}' +
+    'segment(input){const s=String(input);return{input:s,[Symbol.iterator]:function*(){' +
+    'let i=0;for(const c of s){yield{segment:c,index:i,input:s};i+=c.length}}}}' +
+    '};';