@gjsify/rolldown-plugin-gjsify 0.42.0 → 0.43.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

@@ -158,6 +158,9 @@ 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 })];
     const plugins = [
         // Virtual-entry plugin runs FIRST so its resolveId/load match the
         // synthetic input ids that `wrapInputWithSideEffects` produces.
@@ -184,7 +187,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 +220,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

@@ -124,6 +124,9 @@ 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` /
@@ -135,7 +138,6 @@ export const setupForNativescript = async (input) => {
         // 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

@@ -54,6 +54,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

@@ -206,6 +206,9 @@ 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 })];
     const plugins = [
         // Virtual-entry plugin runs FIRST so its resolveId/load match the synthetic
         // `\0gjsify-entry:` ids `wrapInputWithSideEffects` produces (no-op when
@@ -238,7 +241,6 @@ export const setupForNode = async (input) => {
         // 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 +256,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/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}}}}' +
+    '};';

package/lib/plugins/process-stub.js

@@ -1,4 +1,5 @@
 import { BUNDLE_URL_BANNER } from './bundle-url-banner.js';
+import { GJS_INTL_SEGMENTER_STUB } from './intl-segmenter-banner.js';
 import { GJS_WELLKNOWN_SYMBOLS_STUB } from './wellknown-symbols-banner.js';
 import { giRuntimePathsStub } from './gi-runtime-paths.js';
 // Every GJS ambient global is reached through `globalThis.` — NEVER as a bare
@@ -84,6 +85,9 @@ export function processStubPlugin(options = {}) {
     // is single-line and idempotent.
     const stub = (options.captureBundleUrl ? BUNDLE_URL_BANNER : '') +
         GJS_WELLKNOWN_SYMBOLS_STUB +
+        // Before the process stub and before module init: `get-east-asian-width`
+        // constructs a Segmenter at module scope, so a later injection is too late.
+        GJS_INTL_SEGMENTER_STUB +
         GJS_PROCESS_STUB +
         giRuntimePathsStub(options.giRuntimePaths ?? [], options.giSystemProbes ?? []);
     const banner = composeBanner(stub, options.userBanner ?? '');

package/lib/utils/detect-free-globals.js

@@ -9,6 +9,7 @@
 import * as acorn from 'acorn';
 import * as walk from 'acorn-walk';
 import { GJS_GLOBALS_MAP } from '@gjsify/resolve-npm/globals-map';
+import { classifyJsxParseFailure, formatSurvivingJsx } from './jsx-survival.js';
 const KNOWN_GLOBALS = new Set(Object.keys(GJS_GLOBALS_MAP));
 /**
  * `<host>.<method>` patterns that must inject a global even though the identifier
@@ -88,6 +89,33 @@ function extractBindingNames(node) {
             return [];
     }
 }
+/**
+ * Parse one analysis chunk, and say what a JSX failure IS.
+ *
+ * This parse is the first thing a `--globals auto` build does with bundled output, so a
+ * `jsx: "preserve"` project with no framework compiler dies HERE — and acorn's own
+ * message is `Unexpected token (3:11)`, which names neither JSX, nor the file, nor a
+ * setting. Every other parse failure is re-thrown untouched: acorn trailing
+ * SpiderMonkey on new syntax is acorn's problem, not the project's, and claiming JSX
+ * for it would be a lie with a fix attached.
+ */
+function parseAnalysisChunk(code) {
+    try {
+        return acorn.parse(code, {
+            ecmaVersion: 'latest',
+            sourceType: 'module',
+            // Acorn rejects shebangs by default, and any project bundling its own CLI gets
+            // one hoisted to byte 0.
+            allowHashBang: true,
+        });
+    }
+    catch (err) {
+        const jsx = classifyJsxParseFailure(code, err);
+        if (jsx === null)
+            throw err;
+        throw new Error(formatSurvivingJsx(jsx, 'the analysis bundle'), { cause: err });
+    }
+}
 /**
  * Core scanner behind `detectFreeGlobals` (web/Node globals map) and
  * `detectGjsAmbientGlobals` (the `--app node` GJS-ambient set), parametrised so the node
@@ -108,13 +136,7 @@ function scanFreeGlobals(code, opts) {
     const knownGlobals = opts.knownGlobals;
     const methodMarkers = opts.methodMarkers ?? {};
     const wasmMarkers = opts.wasmMarkers ?? {};
-    const ast = acorn.parse(code, {
-        ecmaVersion: 'latest',
-        sourceType: 'module',
-        // Acorn rejects shebangs by default, and any project bundling its own CLI gets
-        // one hoisted to byte 0.
-        allowHashBang: true,
-    });
+    const ast = parseAnalysisChunk(code);
     // Pass 1: every declared name in the module.
     const declaredNames = new Set();
     walk.simple(ast, {

package/lib/utils/index.d.ts

@@ -7,3 +7,5 @@ export { detectFreeGlobals } from './detect-free-globals.js';
 export { resolveGlobalsList, writeRegisterInjectFile } from './scan-globals.js';
 export { inlineStaticReads, isAbsoluteFsPath } from './inline-static-reads.js';
 export { GJSIFY_VIRTUAL_PREFIX, isGjsifyVirtualModuleId } from './virtual-module-id.js';
+export { locateSurvivingJsx, classifyJsxParseFailure, formatSurvivingJsx } from './jsx-survival.js';
+export type { SurvivingJsx } from './jsx-survival.js';

package/lib/utils/index.js

@@ -7,3 +7,4 @@ export { detectFreeGlobals } from './detect-free-globals.js';
 export { resolveGlobalsList, writeRegisterInjectFile } from './scan-globals.js';
 export { inlineStaticReads, isAbsoluteFsPath } from './inline-static-reads.js';
 export { GJSIFY_VIRTUAL_PREFIX, isGjsifyVirtualModuleId } from './virtual-module-id.js';
+export { locateSurvivingJsx, classifyJsxParseFailure, formatSurvivingJsx } from './jsx-survival.js';

package/lib/utils/jsx-survival.d.ts

@@ -0,0 +1,31 @@
+/** Where the parser stopped, and on what. */
+export interface SurvivingJsx {
+    /** 1-based line, as acorn reports it. */
+    line: number;
+    /** 0-based column, as acorn reports it. */
+    column: number;
+    /** The text around the failure, trimmed so a minified bundle stays readable. */
+    excerpt: string;
+}
+/**
+ * Does `err` — a failure from parsing `code` — say that raw JSX survived? Returns the
+ * location when the position attributes it to JSX, `null` when it does not.
+ *
+ * Split from {@link locateSurvivingJsx} so a caller that ALREADY parsed (and threw) can
+ * attribute its own failure without parsing a second time.
+ */
+export declare function classifyJsxParseFailure(code: string, err: unknown): SurvivingJsx | null;
+/**
+ * Parse `code` as an ES module and report surviving JSX. `null` means either "parses
+ * fine" or "fails for a reason that is not JSX" — the two cases this must not conflate,
+ * because only the first is a healthy bundle and only the second is acorn's problem
+ * rather than the build's.
+ */
+export declare function locateSurvivingJsx(code: string): SurvivingJsx | null;
+/**
+ * The actionable message: what the artifact does, what the runtime will do with it, and
+ * the two settings that fix it. Shared by the post-bundle artifact gate and the
+ * `--globals auto` analysis pass, which hits the same source with a bare
+ * "Unexpected token (3:11)" naming neither JSX nor a setting.
+ */
+export declare function formatSurvivingJsx(found: SurvivingJsx, label: string): string;

package/lib/utils/jsx-survival.js

@@ -0,0 +1,102 @@
+// Raw JSX surviving into an emitted bundle — the syntax-level oracle, and why it is a
+// syntax check rather than a pattern match.
+//
+// `jsx: "preserve"` is the setting `babel-preset-solid` and the Vue SFC compiler need:
+// it tells oxc to leave JSX alone so the framework's own compiler can handle it. When
+// that compiler is absent, raw JSX travels all the way into the `.gjs.mjs` and NOTHING
+// between `gjsify build` and the artifact notices — rolldown emits it, the build exits
+// 0, and GJS refuses the file at LOAD, before one line runs. MEASURED on a two-line
+// `.tsx` built `--app gjs --globals none`: exit 0, `r=<box title="hi"/>` in the bundle,
+// and `SyntaxError: expected expression, got '<'` under `gjs -m`.
+//
+// A pattern match is the wrong oracle in both directions: `<div` hits a string inside a
+// test name, and misses `<Foo.Bar>`, `<>` and every tag the pattern did not think of.
+// The right question is the one GJS asks — "does this parse as an ES module?" — so this
+// asks acorn, the same parser the `--globals auto` detector already runs over bundled
+// output.
+//
+// A parse failure ALONE is not attributed to JSX: acorn trails SpiderMonkey on new
+// syntax, and blaming JSX for something else would send the reader after a setting that
+// is already right. The attribution is the FAILURE POSITION — a `<` followed by an
+// identifier start, `>` (fragment) or `/` (closing tag). That is where acorn stops on
+// every JSX shape measured: `<box …/>`, `<box>hi</box>`, `<>…</>`, `<Foo.Bar x={1}>`,
+// JSX as a call argument, and JSX in a multi-declarator `const`.
+import * as acorn from 'acorn';
+/**
+ * What may follow the `<` for the failure to read as JSX rather than as a broken
+ * comparison: a tag name, a fragment (`<>`) or a closing tag (`</`).
+ */
+const JSX_AFTER_ANGLE_RE = /^[A-Za-z_$>/]/;
+/** Characters of context kept around the failure position. */
+const EXCERPT_RADIUS = 60;
+function excerptAt(code, pos) {
+    const from = Math.max(0, pos - EXCERPT_RADIUS);
+    const to = Math.min(code.length, pos + EXCERPT_RADIUS);
+    // Newlines and tabs would break the one-line-per-fact shape of the message.
+    const text = code.slice(from, to).replace(/[\r\n\t]+/g, ' ');
+    return `${from > 0 ? '…' : ''}${text}${to < code.length ? '…' : ''}`;
+}
+/**
+ * Does `err` — a failure from parsing `code` — say that raw JSX survived? Returns the
+ * location when the position attributes it to JSX, `null` when it does not.
+ *
+ * Split from {@link locateSurvivingJsx} so a caller that ALREADY parsed (and threw) can
+ * attribute its own failure without parsing a second time.
+ */
+export function classifyJsxParseFailure(code, err) {
+    const pos = err.pos;
+    const loc = err.loc;
+    if (typeof pos !== 'number')
+        return null;
+    if (typeof loc?.line !== 'number' || typeof loc.column !== 'number')
+        return null;
+    if (code[pos] !== '<')
+        return null;
+    if (!JSX_AFTER_ANGLE_RE.test(code.slice(pos + 1, pos + 2)))
+        return null;
+    return { line: loc.line, column: loc.column, excerpt: excerptAt(code, pos) };
+}
+/**
+ * Parse `code` as an ES module and report surviving JSX. `null` means either "parses
+ * fine" or "fails for a reason that is not JSX" — the two cases this must not conflate,
+ * because only the first is a healthy bundle and only the second is acorn's problem
+ * rather than the build's.
+ */
+export function locateSurvivingJsx(code) {
+    try {
+        acorn.parse(code, {
+            ecmaVersion: 'latest',
+            sourceType: 'module',
+            // Any project bundling its own CLI gets a shebang hoisted to byte 0.
+            allowHashBang: true,
+        });
+        return null;
+    }
+    catch (err) {
+        return classifyJsxParseFailure(code, err);
+    }
+}
+/**
+ * The actionable message: what the artifact does, what the runtime will do with it, and
+ * the two settings that fix it. Shared by the post-bundle artifact gate and the
+ * `--globals auto` analysis pass, which hits the same source with a bare
+ * "Unexpected token (3:11)" naming neither JSX nor a setting.
+ */
+export function formatSurvivingJsx(found, label) {
+    return [
+        `gjsify build: ${label} still contains raw JSX at ${found.line}:${found.column} — it is not valid ` +
+            'JavaScript, so GJS aborts at load with "SyntaxError: expected expression, got \'<\'" before one ' +
+            'line runs.',
+        `  ${found.excerpt}`,
+        '',
+        'JSX reaches an artifact only when the transform was told to PRESERVE it (`jsx: "preserve"` in ' +
+            '`gjsify.bundler.transform.jsx` or in tsconfig `compilerOptions.jsx`) and nothing compiled it ' +
+            'afterwards. Either:',
+        '  - register the framework compiler that consumes preserved JSX (`babel-preset-solid` for Solid, the ' +
+            'Vue SFC compiler) under `gjsify.bundler.plugins`, or',
+        '  - drop `preserve` and give the automatic runtime an import source that resolves AND runs: ' +
+            '`bundler.transform.jsx: { "importSource": "<pkg exporting ./jsx-runtime>" }`, or tsconfig ' +
+            '`"jsx": "react-jsx"` + `"jsxImportSource"`. Not `@gjsify/gtk-host` — its `/jsx-runtime` is a ' +
+            'TYPE surface and throws when called.',
+    ].join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/rolldown-plugin-gjsify",
-    "version": "0.42.0",
+    "version": "0.43.0",
     "description": "Rolldown / Rollup / Vite plugin orchestrator for GJS, Node, and Browser targets",
     "type": "module",
     "main": "lib/index.js",
@@ -39,7 +39,8 @@
     },
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/gjsify/gjsify.git"
+        "url": "git+https://github.com/gjsify/gjsify.git",
+        "directory": "packages/infra/rolldown-plugin-gjsify"
     },
     "bugs": {
         "url": "https://github.com/gjsify/gjsify/issues"
@@ -55,11 +56,11 @@
     ],
     "license": "MIT",
     "dependencies": {
-        "@gjsify/console": "^0.42.0",
-        "@gjsify/resolve-npm": "^0.42.0",
-        "@gjsify/rolldown-plugin-deepkit": "^0.42.0",
-        "@gjsify/rolldown-plugin-pnp": "^0.42.0",
-        "@gjsify/vite-plugin-blueprint": "^0.42.0",
+        "@gjsify/console": "^0.43.0",
+        "@gjsify/resolve-npm": "^0.43.0",
+        "@gjsify/rolldown-plugin-deepkit": "^0.43.0",
+        "@gjsify/rolldown-plugin-pnp": "^0.43.0",
+        "@gjsify/vite-plugin-blueprint": "^0.43.0",
         "@rollup/pluginutils": "^5.4.0",
         "acorn": "^8.17.0",
         "acorn-typescript": "^1.4.13",
@@ -69,7 +70,7 @@
         "sass": "^1.101.0"
     },
     "peerDependencies": {
-        "@gjsify/lightningcss-native": "^0.42.0",
+        "@gjsify/lightningcss-native": "^0.43.0",
         "rolldown": "^1.1.4"
     },
     "peerDependenciesMeta": {