@gjsify/rolldown-plugin-gjsify 0.42.0 → 0.44.0

package/lib/types/source-dialect.js

@@ -0,0 +1,21 @@
+/** Every dialect this build understands, for CLI choices and error messages. */
+export const SOURCE_DIALECTS = ['react-native'];
+/** Whether `value` names a dialect this build understands. */
+export function isSourceDialect(value) {
+    return typeof value === 'string' && SOURCE_DIALECTS.includes(value);
+}
+/**
+ * The `--app` targets that actually compose a dialect's plugins.
+ *
+ * Declared here rather than inferred, because it cannot be inferred: the
+ * composition happens in `app/gjs.ts` and `app/node.ts`, and a plugin only ever
+ * sees the target it was composed on — so nothing downstream can tell "this
+ * target has no dialect support" from "this dialect asked for nothing". The CLI
+ * refuses the pair up front instead, and this is the set it refuses against.
+ *
+ * KEEP IN STEP with the two composition sites. A third target that starts
+ * composing and is not added here gets a build refused for no reason; one added
+ * here without composing gets a flag accepted and silently ignored, which is the
+ * failure this set exists to prevent.
+ */
+export const DIALECT_APPS = new Set(['gjs', 'node']);

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/lib/utils/scan-named-imports.d.ts

@@ -0,0 +1,47 @@
+/** One named import (or re-export) of `name` from a watched package. */
+export interface NamedImport {
+    /** The name as the SOURCE module exports it, not the local alias. */
+    readonly name: string;
+    /** The verbatim specifier it came from. */
+    readonly specifier: string;
+    /** 1-based line, as acorn reports it. */
+    readonly line: number;
+    /** 0-based column, as acorn reports it. */
+    readonly column: number;
+}
+/** A reference to a watched package whose imported NAMES are not statically knowable. */
+export interface OpaqueReference {
+    /** Which form hid the names. */
+    readonly form: 'namespace' | 'default' | 'export-all' | 'dynamic-import' | 'require';
+    readonly specifier: string;
+    readonly line: number;
+    readonly column: number;
+}
+export interface ScanResult {
+    readonly named: readonly NamedImport[];
+    readonly opaque: readonly OpaqueReference[];
+}
+/** Raised when a module that mentions a watched package cannot be parsed. */
+export declare class ImportScanParseError extends Error {
+    readonly id: string;
+    readonly name = "ImportScanParseError";
+    constructor(id: string, cause: unknown);
+}
+/**
+ * Every named import and every opaque reference to one of `specifiers`.
+ *
+ * `specifiers` is matched EXACTLY. `react-native-web` and
+ * `react-native/Libraries/…` are different modules with different contracts, and
+ * a prefix match would fail a build over a package this layer never claimed —
+ * the deep-subpath case has its own named error in the alias plugin, where the
+ * importer is known and the message can say what to do.
+ *
+ * Type-only imports are absent from the result by construction. ADR 0032 counted
+ * five of them (`ViewProps`, `TextProps`, `PressableProps`, `LayoutChangeEvent`,
+ * `ColorValue`) in the measured application and recorded that they cost nothing:
+ * a type erases at build time and reaches no runtime, so a gate that failed on
+ * `import type { ViewProps }` would refuse a program that cannot fail.
+ *
+ * @throws {ImportScanParseError} when the source cannot be parsed.
+ */
+export declare function scanNamedImports(code: string, id: string, specifiers: readonly string[]): ScanResult;

package/lib/utils/scan-named-imports.js

@@ -0,0 +1,239 @@
+// Which NAMES a module imports from one package — the input the ADR 0032 § 8
+// build-time gate needs and no bundler hook hands over.
+//
+// WHY A PARSE HERE RATHER THAN A HOOK. The gate has to name the IDENTIFIER, not
+// the module: § 8's whole advantage over the runtime backstop is failing on
+// `import { FlatList } from 'react-native'` with the importing file and position.
+// Of the hooks BOTH engines honour — `@gjsify/rolldown-native`'s `NativePlugin`
+// lists load, transform, resolveId, renderChunk, the four addons and the
+// lifecycle pair, and that list is the ceiling — `resolveId` sees the specifier
+// and never the bindings, and there is no `moduleParsed`, no `ModuleInfo.ast` and
+// no `this.parse`. `transform` hands over the source and nothing else does, so
+// the import list is ours to read.
+//
+// WHY NOT A TEXT SCAN. A regex over `import {…} from '<pkg>'` cannot tell a live
+// import from one inside a block comment or a template literal, and it cannot
+// see `importKind` — which is the difference between a build error and five
+// type-only imports that ADR 0032 measured as costing nothing. Both of those are
+// false POSITIVES, the failure mode that teaches people to switch a gate off.
+//
+// WHY ACORN AND NOT THE BUNDLER'S PARSER. Same measured reason as
+// `inline-static-reads.ts`: under GJS the engine is `@gjsify/rolldown-native`,
+// npm `rolldown` is a Node-only N-API crate, and a top-level
+// `import { parseAst } from 'rolldown/parseAst'` puts it in a module that has to
+// load under GJS — the CLI's own bundle died at startup with `createRequire:
+// Cannot require builtin module "fs" synchronously in GJS`. `acorn-typescript`
+// is pure JS and reports `importKind` on both the declaration and each specifier
+// (verified against `.tsx` with JSX, a namespace import and inline `type`
+// specifiers), which is exactly the discrimination the gate turns on.
+//
+// TWO BLIND SPOTS, BOTH MEASURED, AND NEITHER IS SILENT.
+//
+// 1. FORMS THAT CARRY NO NAME — the point of `opaque`. A named import is the
+//    only form that carries a name at build time. `import * as RN`, a default
+//    import, `export * from`, `await import('…')` and `require('…')` all reach
+//    the surface through a value whose members are resolved at RUNTIME, and no
+//    parser recovers them without type information this layer does not have.
+//    They come back as {@link OpaqueReference}s so the caller can say out loud
+//    that the gate cannot answer for this module and that the runtime refusal is
+//    what covers it.
+//
+// 2. SYNTAX acorn-typescript 1.4.13 DOES NOT HAVE. Measured against the pinned
+//    version (acorn 8.17.0): `const x = 1 satisfies number` fails with
+//    `Unexpected token (1:12)`, and a `const` type parameter
+//    (`<const T,>(x: T) => x`) fails with `Unexpected token (1:18)`. Both are
+//    ordinary TypeScript, and this repository pins `typescript: "^6.0.3"`, so
+//    both WILL appear in consumer source. This function throws
+//    {@link ImportScanParseError} for them, and the plugin turns that into a
+//    warning rather than a build failure — see `react-native-gate.ts` for why a
+//    false violation is the worse outcome. `react-native-gate.spec.ts` pins the
+//    gap as a fixture that must NOT parse, beside the modern syntax that must, so
+//    the day acorn-typescript gains it that vector goes red and someone moves it.
+//
+// A gate whose limits are undocumented is worse than no gate; a gate that fails
+// a valid program is how a gate gets switched off.
+import * as acorn from 'acorn';
+import { tsPlugin } from 'acorn-typescript';
+/**
+ * The TypeScript/TSX-capable parser, built once.
+ *
+ * `acorn-typescript` refuses to parse without `locations: true` (measured in
+ * `inline-static-reads.ts`), and the gate needs the positions anyway.
+ */
+const TS_PARSER = acorn.Parser.extend(tsPlugin());
+const PARSE_OPTIONS = {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    locations: true,
+    allowAwaitOutsideFunction: true,
+    allowReturnOutsideFunction: true,
+    allowImportExportEverywhere: true,
+};
+/** Raised when a module that mentions a watched package cannot be parsed. */
+export class ImportScanParseError extends Error {
+    id;
+    name = 'ImportScanParseError';
+    constructor(id, cause) {
+        const detail = cause instanceof Error ? cause.message : String(cause);
+        super(`gjsify import scan: cannot read the import list of ${id} — ${detail}. This module mentions a ` +
+            `package the build-time support gate watches, so for THIS file the gate is downgraded to ` +
+            `the runtime backstop. Known causes, both measured on acorn-typescript 1.4.13: a ` +
+            `\`satisfies\` expression, or a \`const\` type parameter. Otherwise the syntax is newer ` +
+            `than the bundled parser, or the file is not the module type its extension claims.`, { cause });
+        this.id = id;
+    }
+}
+function positionOf(node) {
+    return { line: node.loc?.start?.line ?? 0, column: node.loc?.start?.column ?? 0 };
+}
+/** The string value of a node when it is a plain string literal, else `undefined`. */
+function literalString(node) {
+    const value = node?.value;
+    return node?.type === 'Literal' && typeof value === 'string' ? value : undefined;
+}
+/**
+ * Visit every node in the tree, generically.
+ *
+ * A bare descent rather than `acorn-walk`, and not as a preference: `walk.simple`
+ * looks its visitor up in a table keyed by node type and throws `No walker
+ * function defined for node type TSInterfaceDeclaration` on the first interface
+ * in a first-party source. A walker with no node table cannot fall behind the
+ * parser — which matters precisely because the parser emits TS node types this
+ * file has never heard of.
+ */
+function forEachNode(root, visit) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node === null || typeof node !== 'object')
+            continue;
+        if (Array.isArray(node)) {
+            for (const child of node)
+                stack.push(child);
+            continue;
+        }
+        if (typeof node.type === 'string')
+            visit(node);
+        for (const value of Object.values(node)) {
+            if (value !== null && typeof value === 'object')
+                stack.push(value);
+        }
+    }
+}
+/**
+ * Every named import and every opaque reference to one of `specifiers`.
+ *
+ * `specifiers` is matched EXACTLY. `react-native-web` and
+ * `react-native/Libraries/…` are different modules with different contracts, and
+ * a prefix match would fail a build over a package this layer never claimed —
+ * the deep-subpath case has its own named error in the alias plugin, where the
+ * importer is known and the message can say what to do.
+ *
+ * Type-only imports are absent from the result by construction. ADR 0032 counted
+ * five of them (`ViewProps`, `TextProps`, `PressableProps`, `LayoutChangeEvent`,
+ * `ColorValue`) in the measured application and recorded that they cost nothing:
+ * a type erases at build time and reaches no runtime, so a gate that failed on
+ * `import type { ViewProps }` would refuse a program that cannot fail.
+ *
+ * @throws {ImportScanParseError} when the source cannot be parsed.
+ */
+export function scanNamedImports(code, id, specifiers) {
+    const named = [];
+    const opaque = [];
+    const watched = new Set(specifiers);
+    let ast;
+    try {
+        ast = TS_PARSER.parse(code, PARSE_OPTIONS);
+    }
+    catch (cause) {
+        throw new ImportScanParseError(id, cause);
+    }
+    // Import and re-export declarations are top level by grammar, so `body` is
+    // the whole population — no descent needed and none wanted, because a
+    // descent would also visit a `TSModuleDeclaration`'s ambient imports, which
+    // declare types and import nothing.
+    for (const node of ast.body) {
+        if (node.type === 'ImportDeclaration') {
+            const specifier = literalString(node.source);
+            if (specifier === undefined || !watched.has(specifier))
+                continue;
+            // `import type { X } from …` — the whole declaration erases.
+            if (node.importKind === 'type')
+                continue;
+            for (const spec of node.specifiers) {
+                const at = positionOf(spec);
+                if (spec.type === 'ImportSpecifier') {
+                    // `import { type X }` — the one specifier erases while its
+                    // value-importing siblings in the same declaration do not.
+                    if (spec.importKind === 'type')
+                        continue;
+                    const imported = spec.imported;
+                    const name = imported.name ?? (typeof imported.value === 'string' ? imported.value : undefined);
+                    if (name !== undefined)
+                        named.push({ name, specifier, ...at });
+                }
+                else {
+                    opaque.push({
+                        form: spec.type === 'ImportNamespaceSpecifier' ? 'namespace' : 'default',
+                        specifier,
+                        ...at,
+                    });
+                }
+            }
+            continue;
+        }
+        if (node.type === 'ExportNamedDeclaration') {
+            const specifier = literalString(node.source);
+            if (specifier === undefined || !watched.has(specifier))
+                continue;
+            if (node.exportKind === 'type')
+                continue;
+            for (const spec of node.specifiers) {
+                if (spec.exportKind === 'type')
+                    continue;
+                // On an `ExportSpecifier` it is `local` that names the binding in
+                // the SOURCE module; `exported` is the name this module publishes.
+                const local = spec.local;
+                const name = local.name ?? (typeof local.value === 'string' ? local.value : undefined);
+                if (name !== undefined)
+                    named.push({ name, specifier, ...positionOf(spec) });
+            }
+            continue;
+        }
+        if (node.type === 'ExportAllDeclaration') {
+            const specifier = literalString(node.source);
+            if (specifier === undefined || !watched.has(specifier))
+                continue;
+            if (node.exportKind === 'type')
+                continue;
+            opaque.push({ form: 'export-all', specifier, ...positionOf(node) });
+        }
+    }
+    // `import('…')` and `require('…')` can sit anywhere, so these need the
+    // descent. Only the specifier is recoverable — which member of the namespace
+    // the caller reaches for is a runtime question by construction.
+    forEachNode(ast, (node) => {
+        if (node.type === 'ImportExpression') {
+            const specifier = literalString(node.source);
+            if (specifier !== undefined && watched.has(specifier)) {
+                opaque.push({ form: 'dynamic-import', specifier, ...positionOf(node) });
+            }
+            return;
+        }
+        if (node.type !== 'CallExpression')
+            return;
+        const call = node;
+        // `import(…)` also arrives as a CallExpression with an `Import` callee on
+        // some acorn versions; both spellings are accepted so the form is not
+        // silently missed by a parser upgrade.
+        const isImport = call.callee?.type === 'Import';
+        const isRequire = call.callee?.type === 'Identifier' && call.callee.name === 'require';
+        if (!isImport && !isRequire)
+            return;
+        const specifier = literalString(call.arguments?.[0]);
+        if (specifier === undefined || !watched.has(specifier))
+            return;
+        opaque.push({ form: isImport ? 'dynamic-import' : 'require', specifier, ...positionOf(node) });
+    });
+    return { named, opaque };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/rolldown-plugin-gjsify",
-    "version": "0.42.0",
+    "version": "0.44.0",
     "description": "Rolldown / Rollup / Vite plugin orchestrator for GJS, Node, and Browser targets",
     "type": "module",
     "main": "lib/index.js",
@@ -33,13 +33,18 @@
         "lib"
     ],
     "scripts": {
-        "clear": "gjsify clear lib tsconfig.tsbuildinfo",
+        "clear": "gjsify clear lib tsconfig.tsbuildinfo test.node.mjs",
         "check": "gjsify tsc --noEmit",
-        "build": "gjsify tsc"
+        "build": "gjsify tsc -p tsconfig.build.json",
+        "build:test": "gjsify run build:test:node",
+        "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+        "test": "gjsify run build:test && gjsify run test:node",
+        "test:node": "node test.node.mjs"
     },
     "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 +60,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.44.0",
+        "@gjsify/resolve-npm": "^0.44.0",
+        "@gjsify/rolldown-plugin-deepkit": "^0.44.0",
+        "@gjsify/rolldown-plugin-pnp": "^0.44.0",
+        "@gjsify/vite-plugin-blueprint": "^0.44.0",
         "@rollup/pluginutils": "^5.4.0",
         "acorn": "^8.17.0",
         "acorn-typescript": "^1.4.13",
@@ -69,7 +74,7 @@
         "sass": "^1.101.0"
     },
     "peerDependencies": {
-        "@gjsify/lightningcss-native": "^0.42.0",
+        "@gjsify/lightningcss-native": "^0.44.0",
         "rolldown": "^1.1.4"
     },
     "peerDependenciesMeta": {
@@ -81,6 +86,8 @@
         }
     },
     "devDependencies": {
+        "@gjsify/cli": "^0.44.0",
+        "@gjsify/unit": "^0.44.0",
         "@types/node": "^25.9.2",
         "rolldown": "^1.1.4",
         "typescript": "^6.0.3"