@gjsify/rolldown-plugin-gjsify 0.54.0 → 0.56.0

package/lib/app/browser.js

@@ -30,6 +30,7 @@ import { platformResolvePlugin, browserSuffixChain, BROWSER_REFUSED_SUFFIXES } f
 import { giRendererPlugin } from '../plugins/gi-renderer.js';
 import { cssAsStringPlugin } from '../plugins/css-as-string.js';
 import { unresolvedWorkspaceImportPlugin } from '../plugins/unresolved-workspace-import.js';
+import { implicitGlobalAssignPlugin } from '../plugins/implicit-global-assign.js';
 export const setupForBrowser = async (input) => {
     const userExternal = input.userExternal ?? [];
     const external = [...userExternal];
@@ -135,6 +136,11 @@ export const setupForBrowser = async (input) => {
         // GJS app's sources must not start failing on an import that used to resolve — and the
         // exit a browser can actually use is now beside it.
         blueprintPlugin(),
+        // ADR 0079's addendum. The `window` define above replaces an assignment TARGET as
+        // readily as a read, so `window = {…}` would emit `globalThis = {…}` — code that
+        // replaces the whole global object. This transform runs first and leaves the define
+        // nothing to rewrite; the guarded branch stays unreachable on a page either way.
+        implicitGlobalAssignPlugin(),
         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

package/lib/app/gjs.js

@@ -21,6 +21,7 @@ import { nodeModulesPathRewritePlugin, getBundleDirFromOutput } from '../plugins
 import { processStubPlugin } from '../plugins/process-stub.js';
 import { cssAsStringPlugin } from '../plugins/css-as-string.js';
 import { consoleAssignPlugin } from '../plugins/console-assign.js';
+import { implicitGlobalAssignPlugin } from '../plugins/implicit-global-assign.js';
 import { shebangPlugin, resolveShebangLine, inputShebangStripPlugin } from '../plugins/shebang.js';
 import { wrapInputWithSideEffects } from '../utils/entry-wrapper.js';
 const _shimDir = dirname(fileURLToPath(import.meta.url));
@@ -97,6 +98,7 @@ export const setupForGjs = async (input) => {
         sideEffectImports.push(input.pluginOptions.autoGlobalsInject);
     const virtualEntries = wrapInputWithSideEffects(entryPoints, sideEffectImports, {
         preserveDefaultExport: input.pluginOptions.preserveDefaultExport === true,
+        exitOnReportedCode: true,
     });
     const finalInput = virtualEntries.input;
     const options = {
@@ -192,6 +194,14 @@ export const setupForGjs = async (input) => {
         // A module assigning the global `console` gets a local binding, or the inject
         // below turns its assignment into `ASSIGN_TO_IMPORT` and fails the build.
         ...(consoleShimPath ? [consoleAssignPlugin()] : []),
+        // ADR 0079's addendum: a bare `window = …` reaches a module body that is strict
+        // once bundled, so it is a `ReferenceError` rather than the "this runtime has no
+        // window, make one" its `typeof` guard asked for. Here the guarded branch is dead
+        // anyway — the host has a `window` — but WITHOUT this transform the `window`
+        // define in `transform.define` replaces the assignment TARGET, emitting
+        // `globalThis = {…}`, i.e. code that would replace the whole global object if the
+        // branch ever ran. Measured; the plugin header carries the artifact diff.
+        implicitGlobalAssignPlugin(),
         // `gi://Ns?version=X&optional` → a guarded import (ADR 0087), claimed `pre`
         // so the externals policy never sees the flagged specifier.
         giOptionalPlugin('gjs'),
@@ -237,11 +247,19 @@ export const setupForGjs = async (input) => {
         // into the subset GTK4 understands.
         cssAsStringPlugin({ targets: { firefox: 60 << 16 } }),
         nodeModulesPathRewritePlugin({ bundleDir, runtimeResolve: format === 'esm' }),
-        processStubPlugin({
-            userBanner: input.userBanner,
-            captureBundleUrl: format === 'esm',
-            giSystemProbes: input.giSystemProbes,
-        }),
+        // ADR 0081: the byte-1 banner ASSIGNS `globalThis.process`, so a
+        // `--globals auto` ANALYSIS bundle that carries it reads its own stub
+        // back as a live global and injects `@gjsify/process` into every build.
+        // The final build keeps the stub — `glob`/`path-scurry` need it.
+        ...(input.pluginOptions.skipProcessStub
+            ? []
+            : [
+                processStubPlugin({
+                    userBanner: input.userBanner,
+                    captureBundleUrl: format === 'esm',
+                    giSystemProbes: input.giSystemProbes,
+                }),
+            ]),
         // resolveShebangLine returns null when disabled, else the resolved line
         // with `${env:…}` expanded.
         (() => {

package/lib/app/nativescript.js

@@ -46,6 +46,7 @@ import { gjsImportsEmptyPlugin } from '../plugins/gjs-imports-empty.js';
 import { giRendererPlugin } from '../plugins/gi-renderer.js';
 import { platformResolvePlugin, nativescriptSuffixChain, detectNativescriptPlatform, nativescriptPlatformDefines, } from '../plugins/platform-resolve.js';
 import { unresolvedWorkspaceImportPlugin } from '../plugins/unresolved-workspace-import.js';
+import { implicitGlobalAssignPlugin } from '../plugins/implicit-global-assign.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
 // the workspace install, it was not resolvable either — every UI-widget bridge failed to build.
@@ -159,6 +160,11 @@ export const setupForNativescript = async (input) => {
         // consumes. A `.blp` whose projection loses anything is refused at build time
         // rather than rendered partially; see `SHARED_TREE_QUERY` in the plugin.
         blueprintPlugin(),
+        // ADR 0079's addendum, and the `define` comment above is why it is needed here:
+        // a NativeScript app gates on the absence of `window`, but a WRITE to it is a
+        // `ReferenceError` in a strict module body, not a gate. `globalThis.window = …`
+        // holds the author's intent; the guard and the absence are untouched.
+        implicitGlobalAssignPlugin(),
         // NO cssAsStringPlugin — NS ships its own CSS pipeline via
         // @nativescript/core; .css imports are handled by the consuming
         // @nativescript/webpack or @nativescript/vite build

package/lib/app/node.js

@@ -11,6 +11,7 @@ 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 { giOptionalPlugin } from '../plugins/gi-optional.js';
+import { implicitGlobalAssignPlugin } from '../plugins/implicit-global-assign.js';
 import { unresolvedWorkspaceImportPlugin } from '../plugins/unresolved-workspace-import.js';
 import { nodeNativeExternalPlugin } from '../plugins/node-native-external.js';
 import { platformResolvePlugin, desktopSuffixChain, desktopOsSuffix, DESKTOP_REFUSED_SUFFIXES, } from '../plugins/platform-resolve.js';
@@ -344,6 +345,13 @@ export const setupForNode = async (input) => {
         // externalisation itself rides `NODE_GI_BARE_MODULE_SPECIFIERS` in
         // `exactExternal` — see that const's doc comment.
         gjsBuiltinModulesNodePlugin(ALIASES_GJS_FOR_NODE),
+        // ADR 0079's addendum, and the target that NEEDS it: `transform.define` above
+        // deliberately does not define `window`, so Excalibur's
+        // `if (typeof window === 'undefined') window = {…}` is a LIVE branch here — and
+        // in a strict module body that write is a `ReferenceError` (map-editor#300).
+        // `globalThis.window = {…}` is the same statement, the guard is untouched, and
+        // nothing defines `window`.
+        implicitGlobalAssignPlugin(),
         // Decides the fate of `@girs/*` before `aliasPlugin` and the default
         // resolver (same composition order as `app/browser.ts`). `emptyGirs` is
         // gated on `gjsSourceBuild`:

package/lib/index.d.ts

@@ -11,6 +11,8 @@ export type { GiOptionalTarget } from './plugins/gi-optional.js';
 export { bindConsoleLocally, consoleAssignPlugin, freeConsoleAssignmentInsertion, CONSOLE_LOCAL_BINDING, } from './plugins/console-assign.js';
 export type { GiSystemProbe } from './plugins/gi-runtime-paths.js';
 export type { ProcessStubPluginOptions } from './plugins/process-stub.js';
+export { findImplicitGlobalAssignments, rewriteImplicitGlobalAssignments, implicitGlobalAssignPlugin, IMPLICIT_GLOBAL_ASSIGN_PLUGIN, } from './plugins/implicit-global-assign.js';
+export type { ImplicitGlobalAssignment } from './plugins/implicit-global-assign.js';
 export { cssAsStringPlugin } from './plugins/css-as-string.js';
 export { textLoaderPlugin } from './plugins/text-loader.js';
 export type { TextLoaderPluginOptions, LoaderKind } from './plugins/text-loader.js';

package/lib/index.js

@@ -8,6 +8,7 @@ export { processStubPlugin, GJS_PROCESS_STUB, composeBanner } from './plugins/pr
 export { giRuntimePathsStub } from './plugins/gi-runtime-paths.js';
 export { giOptionalPlugin, giOptionalShimSource, giOptionalNodeShimSource, giOptionalMarkerSource, parseOptionalGiSpecifier, GI_OPTIONAL_FLAG, GI_OPTIONAL_MARKER, } from './plugins/gi-optional.js';
 export { bindConsoleLocally, consoleAssignPlugin, freeConsoleAssignmentInsertion, CONSOLE_LOCAL_BINDING, } from './plugins/console-assign.js';
+export { findImplicitGlobalAssignments, rewriteImplicitGlobalAssignments, implicitGlobalAssignPlugin, IMPLICIT_GLOBAL_ASSIGN_PLUGIN, } from './plugins/implicit-global-assign.js';
 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';

package/lib/plugins/implicit-global-assign.d.ts

@@ -0,0 +1,26 @@
+import type { Plugin } from 'rolldown';
+/** The plugin's name — what the four app orchestrators are pinned on. */
+export declare const IMPLICIT_GLOBAL_ASSIGN_PLUGIN = "gjsify-implicit-global-assign";
+/** One free assignment: the identifier to prefix, and the name that was free. */
+export interface ImplicitGlobalAssignment {
+    /** The undeclared name — the property the rewrite writes. */
+    readonly name: string;
+    /** Inclusive start offset. */
+    readonly start: number;
+    /** Exclusive end offset. */
+    readonly end: number;
+}
+/**
+ * The free assignments in `code` (one entry per undeclared name written to), or `null` when
+ * the module cannot be read — the whole module in the `with` case, since its bindings there
+ * are dynamic.
+ */
+export declare function findImplicitGlobalAssignments(code: string, id: string): ImplicitGlobalAssignment[] | null;
+/** `code` with every free assignment rewritten, or null when it needs none. */
+export declare function rewriteImplicitGlobalAssignments(code: string, id: string): string | null;
+/**
+ * Composed by ALL FOUR `--app` targets (ADR 0079's addendum) — for the measured reason in
+ * the header: it is the fix on node and nativescript, and on gjs and browser it keeps the
+ * `window` define from turning the assignment target into `globalThis = …`.
+ */
+export declare function implicitGlobalAssignPlugin(): Plugin;

package/lib/plugins/implicit-global-assign.js

@@ -0,0 +1,350 @@
+// A bare ASSIGNMENT to an UNDECLARED identifier is rewritten to `globalThis.X = …`.
+//
+// ADR 0079 dropped the `window` define on `--app node`, and code that was only green
+// because the define supplied the binding came apart. Excalibur 0.32.0's
+// `src/engine/polyfill.ts` opens with
+//
+//     if (typeof window === 'undefined') { window = <any>{ audioContext() { return; } }; }
+//
+// An ES module body is strict, so the write is a `ReferenceError` on every runtime that
+// has no `window` — the branch has never been able to run (PixelRPG/map-editor#300), and
+// on GJS or in a browser the guard is false, so nothing noticed.
+//
+// `window` is the MOTIVATING case, not the subject. The bug is sloppy mode's IMPLICIT
+// GLOBAL CREATION, and it is not window-shaped: `self = …`, `document = …` and `foo = 1` in
+// a CommonJS file the bundler wrapped into a strict ES module all die the same way, and
+// only the first of them has an ADR behind it. So the subject here is any identifier no
+// enclosing scope binds, and `globalThis.X = …` is that same statement with the author's
+// intent spelled out — it holds on Node, Bun, Deno, GJS and in a page alike.
+//
+// NOT A DEFINE AND NOT A REGISTER (ADR 0079's addendum). A define rewrites the very
+// `typeof` guard that decides the branch — the @mtcute/web failure ADR 0079 documents —
+// and a register that defines `window` flips every guard in the ecosystem. The guard stays a
+// guard and nothing anywhere defines a global, so no allowlist is needed either: writing a
+// global the runtime ALREADY has (`onerror = fn`, `self = globalThis`) is legal in strict
+// mode, which makes `globalThis.X = …` an identity rather than a change.
+//
+// WHY ALL FOUR TARGETS AND NOT THE TWO THAT NEED IT, measured on the bundled artifact of
+// the shape above. On `--app node` and `--app nativescript` the plugin IS the fix: without
+// it the `--app node` bundle dies at load with `ReferenceError: window is not defined`,
+// and with it the same bundle runs and the author's `audioContext` stub is there. On the
+// two targets that DO define `window`, the `define` replaces the assignment TARGET too —
+// `window = {…}` becomes `globalThis = {…}`, which REPLACES THE WHOLE GLOBAL OBJECT — and a
+// plugin `transform` runs before it, so the line is already `globalThis.window = {…}` and
+// the define finds nothing left to rewrite.
+//
+// WHY AN AST AND NOT A TEXT PASS: the question is "is X a BINDING in scope at this
+// assignment", which no regex answers. `X.y = 1`, `foo.X = 1`, `{ X: 1 }`, `typeof X` and
+// an `X` that is a parameter of the enclosing function all share the bytes of the shape,
+// and rewriting a local binding would silently retarget a program that means something
+// else. Same reason `utils/detect-free-globals.ts` parses.
+//
+// ONE WALK FOR EVERY NAME. The descent records bindings as ROOT → the names bound in it,
+// rather than answering "is `window` bound" for one name at a time: a module has as many
+// implicit globals as it has typos, and re-walking per name made the pass quadratic for an
+// answer that is one set lookup once the chain is there.
+//
+// THE REFUSALS, each where its fact is knowable:
+//  - a member expression on the left (`X.y = 1`, `foo.X = 1`): a write ONTO a runtime
+//    object, which is exactly what the guarded branches around the Excalibur assignment do,
+//    and no error to fix;
+//  - an assignment whose name a `var`/`let`/`const`, a parameter, a `catch` binding, a
+//    function or class name, or an import binds: a local variable, not a global;
+//  - an ARITHMETIC compound assignment (`X += 1`) and `X++`/`X--`: their left side is a
+//    value USE, so sloppy mode threw there too and rewriting would trade that
+//    `ReferenceError` for a silent `NaN`. `||=`, `&&=` and `??=` read the name too, so on
+//    an undeclared one sloppy mode threw there as well and they stay untouched;
+//  - a name that can never be an implicit global (below): it is a binding, an unassignable
+//    global, or a `SyntaxError` before this pass ever sees it;
+//  - a module containing `with`: the binding is dynamic there, and no static pass can see
+//    which object supplies it;
+//  - a source the pinned parser cannot read: the module keeps the bug and the bundler
+//    reports the parse itself, loudly and with its own position. The measured list is
+//    `utils/scan-named-imports.ts`'s (`satisfies`, a `const` type parameter) plus
+//    acorn-typescript 1.4.13's blind spot on an angle-bracket assertion — `window =
+//    <any>{…}`, which is how Excalibur's SOURCE spells the line and what its shipped
+//    dist (the shape a build actually reads) has already erased.
+//
+// NOT HANDLED: a DESTRUCTURING target (`({ a, b } = obj)`) keeps its bare names.
+// `extractBindingNames` yields names, not source ranges, so a pattern would need a second
+// positional walk over every pattern shape (defaults, rest, computed keys) that nothing
+// here already carries — an implicit global spelled `({ foo } = obj)` stays broken until
+// that walk exists. `for (X in/of …)` IS handled, because its left is the same bare
+// `Identifier` the assignment case already asks for, and sloppy mode created that `X` too.
+import { extractBindingNames } from '../utils/detect-free-globals.js';
+import { parseSource } from '../utils/inline-static-reads.js';
+import { REWRITE_FILTER } from './rewrite-node-modules-paths.js';
+/** The plugin's name — what the four app orchestrators are pinned on. */
+export const IMPLICIT_GLOBAL_ASSIGN_PLUGIN = 'gjsify-implicit-global-assign';
+/**
+ * Names that are never an implicit global, whatever the scope says.
+ *
+ * `undefined`/`NaN`/`Infinity` are non-writable own properties of the global object, so
+ * assigning to them is a `TypeError` in strict mode and a silent no-op in sloppy mode —
+ * never the `ReferenceError` this plugin exists for, and `globalThis.` would only spell the
+ * same failure out. `arguments` and `eval` are rejected by the parser in a strict body
+ * (`SyntaxError: Unexpected eval or arguments`), so they cannot reach a build; they are
+ * listed because a name this pass must not rewrite should not depend on that. `globalThis`
+ * IS a writable global property on every runtime, so `globalThis = x` already works — and
+ * rewriting it would write the property through itself.
+ *
+ * The CommonJS WRAPPER bindings are here for a measured reason, and it is the incident that
+ * put them in the set rather than a rule of thumb: `exports`, `module`, `require`,
+ * `__filename` and `__dirname` are parameters of the function the bundler wraps a
+ * CommonJS module in, so `exports = module.exports = require('./lib/_stream_readable.js')`
+ * — `readable-stream/readable.js`, the polyfill behind `node:stream` — is a LOCAL write. The
+ * descent cannot see the wrapper, because it parses with `sourceType: 'module'`, so the pass
+ * rewrote it to `globalThis.exports = …`: `module.exports` was still set, but every
+ * `exports.Writable = require('./lib/_stream_writable.js')` beside it landed on the wrapper's
+ * original object, which nothing returns. Measured on a bundle of `readable-stream` with and
+ * without the plugin: `Writable`, `Duplex`, `Transform`, `PassThrough` and `Readable` went
+ * from `function` to `undefined` with no error anywhere — and a consumer that inherits from
+ * one of them is what throws next, as `util.inherits(Child, undefined)`. The same line
+ * appears in every bundled copy of `semver`, whose default import is what a Babel-based
+ * plugin bundle then calls. Refusing them unconditionally costs one rewrite that no build
+ * can use: in an ES module these names resolve to nothing at all.
+ */
+const NEVER_IMPLICIT_GLOBAL = new Set([
+    'undefined',
+    'NaN',
+    'Infinity',
+    'arguments',
+    'eval',
+    'globalThis',
+    // The CommonJS wrapper parameters — a local write in the module that has them.
+    'exports',
+    'module',
+    'require',
+    '__filename',
+    '__dirname',
+]);
+/** Where the write lands: the global object, on every runtime there is one (ADR 0079). */
+const GLOBAL_PREFIX = 'globalThis.';
+/** Operators whose left side is a PLACE — see the third refusal for what is absent. */
+const PLACE_ASSIGNMENTS = new Set(['=']);
+/** `extractBindingNames` speaks acorn's node union, which a generic descent cannot be. */
+const asAcornNode = (node) => node;
+/**
+ * A container a `var`/lexical binding is scoped to: the function, or the module.
+ *
+ * A BLOCK is deliberately not one. Precision is needed between functions — a parameter
+ * named `window` in one function does not bind the name in its neighbour — and every
+ * coarsening above this line (a block, or a hoisted name marked in the scope enclosing the
+ * function it is written in) can only LOSE a rewrite, never retarget a program.
+ */
+function isScopeRoot(node) {
+    switch (node.type) {
+        case 'Program':
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+        case 'ArrowFunctionExpression':
+        // Bodyless TypeScript overload signatures still bind their parameters.
+        case 'TSDeclareFunction':
+        case 'TSDeclareMethod':
+        case 'TSEmptyBodyFunctionExpression':
+            return true;
+        default:
+            return false;
+    }
+}
+/** Every name this node binds in the scope it stands in, empty when it binds none. */
+function bindingNames(node) {
+    switch (node.type) {
+        case 'VariableDeclarator':
+            return node.id ? extractBindingNames(asAcornNode(node.id)) : [];
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+        case 'ArrowFunctionExpression':
+        case 'TSDeclareFunction':
+        case 'TSDeclareMethod':
+        case 'TSEmptyBodyFunctionExpression': {
+            // A function's own name and its parameters bind in ITS scope, so the chain is
+            // already one root deeper by the time this is asked.
+            const names = node.id?.name === undefined ? [] : [node.id.name];
+            for (const param of node.params ?? [])
+                names.push(...extractBindingNames(asAcornNode(param)));
+            return names;
+        }
+        case 'ClassDeclaration':
+        case 'ClassExpression':
+            return node.id?.name === undefined ? [] : [node.id.name];
+        case 'CatchClause':
+            return node.param ? extractBindingNames(asAcornNode(node.param)) : [];
+        case 'ImportSpecifier':
+        case 'ImportDefaultSpecifier':
+        case 'ImportNamespaceSpecifier':
+            return node.local?.name === undefined ? [] : [node.local.name];
+        default:
+            return [];
+    }
+}
+/**
+ * Does `name` bind OUTSIDE this node as well?
+ *
+ * A `function`/`class` DECLARATION's name is hoisted into the enclosing scope like a
+ * `var`, so `function window() {}` hides the name from its module; a PARAMETER binds only
+ * inside its function, which is why a neighbouring function's `window` parameter must not
+ * cost the module its rewrite.
+ */
+function hoistsOutward(node, name) {
+    switch (node.type) {
+        case 'FunctionDeclaration':
+        case 'ClassDeclaration':
+        case 'TSDeclareFunction':
+            return node.id?.name === name;
+        default:
+            return false;
+    }
+}
+/**
+ * The bare identifier a statement writes to, or null.
+ *
+ * Both accepted shapes are an implicit global in sloppy mode, so both become a write to the
+ * global object; everything else here is a refusal, and the reason is at each branch.
+ */
+function freeTarget(node) {
+    if (node.type === 'AssignmentExpression') {
+        // A member expression on the left is a write ONTO a runtime object, not a write of
+        // one — the first refusal, and the reason `left.type` is asked at all.
+        if (node.left?.type !== 'Identifier')
+            return null;
+        // Every compound operator (`+=`, `||=`, `??=`, …) and `++` READS the left side
+        // first, so on an undeclared name sloppy mode threw there too: only plain `=` creates.
+        return PLACE_ASSIGNMENTS.has(node.operator ?? '') ? node.left : null;
+    }
+    // `for (X in/of …)` declares `X` in sloppy mode exactly as `X = …` does, and its left
+    // is the same bare Identifier — so it costs nothing to accept here. A `for (var X …)`
+    // or `for (const X …)` left is a VariableDeclaration and never reaches this branch.
+    if (node.type === 'ForInStatement' || node.type === 'ForOfStatement') {
+        return node.left?.type === 'Identifier' ? node.left : null;
+    }
+    return null;
+}
+function collectAssignments(ast) {
+    const candidates = [];
+    // Every scope root that has bound a name, and which names.
+    const boundInRoot = new Map();
+    let hasWith = false;
+    const stack = [{ node: ast, roots: [] }];
+    while (stack.length > 0) {
+        const frame = stack.pop();
+        const { node, roots } = frame;
+        // A function's own name and parameters bind in ITS scope, so a node that opens a
+        // scope joins the chain before it is asked what it binds.
+        const nodeRoots = isScopeRoot(node) ? [node, ...roots] : roots;
+        if (node.type === 'WithStatement')
+            hasWith = true;
+        for (const name of bindingNames(node)) {
+            // The NEAREST enclosing root — index 0, the chain is innermost-first — and only
+            // that one. Marking every root up the chain would degrade this into a
+            // module-wide "does any declaration anywhere mention the name" test, which loses
+            // the rewrite for a module whose unrelated function takes such a parameter.
+            const nearest = nodeRoots[0];
+            if (!nearest)
+                continue;
+            addBinding(boundInRoot, nearest, name);
+            if (hoistsOutward(node, name)) {
+                const enclosing = nodeRoots[1];
+                if (enclosing)
+                    addBinding(boundInRoot, enclosing, name);
+            }
+        }
+        const target = freeTarget(node);
+        if (target && target.name !== undefined && !NEVER_IMPLICIT_GLOBAL.has(target.name)) {
+            candidates.push({ name: target.name, start: target.start, end: target.end, roots: nodeRoots });
+        }
+        for (const child of childrenOf(node))
+            stack.push({ node: child, roots: nodeRoots });
+    }
+    // A binding in scope for an assignment is declared in one of its ENCLOSING roots, so
+    // walking the chain is what makes the rewrite safe — an undeclared name has none.
+    // `with` is refused here rather than above: its answer is "no idea", not "rewrite".
+    if (hasWith)
+        return null;
+    return candidates
+        .filter(({ name, roots }) => !roots.some((root) => boundInRoot.get(root)?.has(name)))
+        .map(({ name, start, end }) => ({ name, start, end }));
+}
+function addBinding(boundInRoot, root, name) {
+    const names = boundInRoot.get(root);
+    if (names) {
+        names.add(name);
+        return;
+    }
+    boundInRoot.set(root, new Set([name]));
+}
+/** Every own-property value that is a node — `Object.values` order is irrelevant here. */
+function childrenOf(node) {
+    const out = [];
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                pushIfNode(item, out);
+            continue;
+        }
+        pushIfNode(value, out);
+    }
+    return out;
+}
+function pushIfNode(value, out) {
+    if (value === null || typeof value !== 'object')
+        return;
+    if (typeof value.type !== 'string')
+        return;
+    out.push(value);
+}
+/**
+ * The free assignments in `code` (one entry per undeclared name written to), or `null` when
+ * the module cannot be read — the whole module in the `with` case, since its bindings there
+ * are dynamic.
+ */
+export function findImplicitGlobalAssignments(code, id) {
+    let ast;
+    try {
+        // Extension-aware (a `.ts` source arrives with its type syntax intact), and the
+        // shared parser this package already parses source with — not a second copy.
+        ast = parseSource(code, id);
+    }
+    catch {
+        return null;
+    }
+    return collectAssignments(ast);
+}
+/** `code` with every free assignment rewritten, or null when it needs none. */
+export function rewriteImplicitGlobalAssignments(code, id) {
+    const edits = findImplicitGlobalAssignments(code, id);
+    if (!edits || edits.length === 0)
+        return null;
+    // Descending, so each splice leaves the offsets of the ones after it valid. The name
+    // from the AST rather than the source slice, so an escaped `\u0061ssignments` writes
+    // the property it means.
+    let out = code;
+    for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
+        out = out.slice(0, edit.start) + GLOBAL_PREFIX + edit.name + out.slice(edit.end);
+    }
+    return out;
+}
+/**
+ * Composed by ALL FOUR `--app` targets (ADR 0079's addendum) — for the measured reason in
+ * the header: it is the fix on node and nativescript, and on gjs and browser it keeps the
+ * `window` define from turning the assignment target into `globalThis = …`.
+ */
+export function implicitGlobalAssignPlugin() {
+    return {
+        name: IMPLICIT_GLOBAL_ASSIGN_PLUGIN,
+        transform: {
+            filter: { id: REWRITE_FILTER },
+            handler(code, id) {
+                // Re-applied inside the handler, the way `react-native-gate.ts` does: the
+                // object form is engine plumbing (under GJS `filter.id` is lifted into a
+                // plugin-level `idFilter`), and a source rewrite must not depend on
+                // plumbing to stay off `.css`, `.blp` and a data URL, none of which acorn
+                // can read.
+                if (!REWRITE_FILTER.test(id))
+                    return null;
+                const out = rewriteImplicitGlobalAssignments(code, id);
+                return out === null ? null : { code: out, map: null };
+            },
+        },
+    };
+}

package/lib/types/plugin-options.d.ts

@@ -117,4 +117,19 @@ export interface PluginOptions {
      * measured incident: `WorkspaceImportGuardOptions.toolchainAnchor`.
      */
     toolchainAnchor?: string;
+    /**
+     * Leave the byte-1 `globalThis.process` stub OUT of the bundle (ADR 0081).
+     *
+     * The stub is not inert to `--globals auto`: `renderChunk` ASSIGNS
+     * `globalThis.process` before any module body, and the detector reads the
+     * ANALYSIS bundle's own output — so every pass saw `process` as a free
+     * global it had detected and injected `@gjsify/process` unconditionally.
+     * Measured on an empty entry: 140 KB instead of ~3 KB.
+     *
+     * Set ONLY by `detectAutoGlobals`, which builds a throwaway bundle to
+     * analyse. The FINAL build must keep the stub: `glob`, `path-scurry` and
+     * `readable-stream` read `process.platform` at top level during `__esm`
+     * lazy init, before any import side effect fires. A consumer never sets it.
+     */
+    skipProcessStub?: boolean;
 }

package/lib/utils/auto-globals.js

@@ -284,6 +284,7 @@ export async function detectAutoGlobals(analysisOptions, pluginOptions, gjsifyPl
         const factoryResult = await gjsifyPluginFactory({
             ...pluginOptions,
             autoGlobalsInject: currentInject,
+            skipProcessStub: true,
         });
         let gjsifyInstance;
         let orchestratorOptions;

package/lib/utils/entry-wrapper.d.ts

@@ -15,4 +15,5 @@ export interface VirtualEntriesResult {
  */
 export declare function wrapInputWithSideEffects(input: RolldownOptions['input'], sideEffects: string[], opts?: {
     preserveDefaultExport?: boolean;
+    exitOnReportedCode?: boolean;
 }): VirtualEntriesResult;

package/lib/utils/entry-wrapper.js

@@ -8,6 +8,22 @@
 // convention for synthetic modules — Rolldown treats them as not-from-disk and
 // skips the default loader.
 import { GJSIFY_VIRTUAL_PREFIX } from './virtual-module-id.js';
+/**
+ * The wrapper's last statement, GJS only (`opts.exitOnReportedCode`).
+ *
+ * GJS has no atexit hook: nothing reads `process.exitCode` when the entry ends
+ * naturally, so `process.exitCode = 1` exited 0 where Node exits 1. The wrapper
+ * body is the one place that runs after the entry's body AND its top-level
+ * awaits (ESM evaluates the imported entry first), so it is the end of main.
+ *
+ * Reaches `process` through `globalThis` (see the process-stub banner: a bare
+ * identifier can bind to a bundled module's own top-level). `exit(code)` is
+ * passed the number explicitly because the byte-1 stub's `exit(c)` ignores
+ * `exitCode`; the full `@gjsify/process` then also emits `'exit'`. Zero,
+ * `undefined` and non-numeric values stay a natural 0, as on Node.
+ */
+const END_OF_MAIN_EXIT = 'const __gjsify_p = globalThis.process, __gjsify_c = Number(__gjsify_p?.exitCode);\n' +
+    'if (Number.isInteger(__gjsify_c) && __gjsify_c !== 0) __gjsify_p.exit(__gjsify_c);';
 /**
  * If there are side-effect imports to land alongside the user's entry, wrap each
  * entry in a virtual module that imports them first then re-exports the entry.
@@ -19,7 +35,7 @@ import { GJSIFY_VIRTUAL_PREFIX } from './virtual-module-id.js';
  * Record-input case: values get wrapped, keys preserved.
  */
 export function wrapInputWithSideEffects(input, sideEffects, opts = {}) {
-    if (sideEffects.length === 0 || input === undefined) {
+    if ((sideEffects.length === 0 && !opts.exitOnReportedCode) || input === undefined) {
         return { input, plugin: null };
     }
     const userEntries = new Map(); // virtualId → realPath
@@ -49,6 +65,7 @@ export function wrapInputWithSideEffects(input, sideEffects, opts = {}) {
         wrappedInput = out;
     }
     const sideEffectImports = sideEffects.map((p) => `import ${JSON.stringify(p)};`).join('\n');
+    const endOfMain = opts.exitOnReportedCode ? `\n${END_OF_MAIN_EXIT}\n` : '';
     // Resolved real-path targets from `userEntries` get their moduleSideEffects
     // forced to 'no-treeshake' so the user-entry's top-level body (`run({...})`,
     // side-effect calls) survives tree-shake even when its package.json restricts
@@ -95,12 +112,12 @@ export function wrapInputWithSideEffects(input, sideEffects, opts = {}) {
                 const ns = '__gjsify_entry__';
                 return {
                     code: `${sideEffectImports}\nimport * as ${ns} from ${JSON.stringify(target)};\n` +
-                        `export * from ${JSON.stringify(target)};\nexport default ${ns}.default;\n`,
+                        `export * from ${JSON.stringify(target)};\nexport default ${ns}.default;\n${endOfMain}`,
                     moduleSideEffects: 'no-treeshake',
                 };
             }
             return {
-                code: `${sideEffectImports}\nimport ${JSON.stringify(target)};\nexport * from ${JSON.stringify(target)};\n`,
+                code: `${sideEffectImports}\nimport ${JSON.stringify(target)};\nexport * from ${JSON.stringify(target)};\n${endOfMain}`,
                 moduleSideEffects: 'no-treeshake',
             };
         },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/rolldown-plugin-gjsify",
-    "version": "0.54.0",
+    "version": "0.56.0",
     "description": "Rolldown / Rollup / Vite plugin orchestrator for GJS, Node, and Browser targets",
     "type": "module",
     "main": "lib/index.js",
@@ -63,12 +63,12 @@
     ],
     "license": "MIT",
     "dependencies": {
-        "@gjsify/console": "^0.54.0",
-        "@gjsify/resolve-npm": "^0.54.0",
-        "@gjsify/rolldown-plugin-deepkit": "^0.54.0",
-        "@gjsify/rolldown-plugin-pnp": "^0.54.0",
-        "@gjsify/utils": "^0.54.0",
-        "@gjsify/vite-plugin-blueprint": "^0.54.0",
+        "@gjsify/console": "^0.56.0",
+        "@gjsify/resolve-npm": "^0.56.0",
+        "@gjsify/rolldown-plugin-deepkit": "^0.56.0",
+        "@gjsify/rolldown-plugin-pnp": "^0.56.0",
+        "@gjsify/utils": "^0.56.0",
+        "@gjsify/vite-plugin-blueprint": "^0.56.0",
         "@rollup/pluginutils": "^5.4.0",
         "acorn": "^8.17.0",
         "acorn-typescript": "^1.4.13",
@@ -78,7 +78,7 @@
         "sass": "^1.101.0"
     },
     "peerDependencies": {
-        "@gjsify/lightningcss-native": "^0.54.0",
+        "@gjsify/lightningcss-native": "^0.56.0",
         "rolldown": "^1.1.4"
     },
     "peerDependenciesMeta": {
@@ -90,8 +90,8 @@
         }
     },
     "devDependencies": {
-        "@gjsify/cli": "^0.54.0",
-        "@gjsify/unit": "^0.54.0",
+        "@gjsify/cli": "^0.56.0",
+        "@gjsify/unit": "^0.56.0",
         "@types/node": "^25.9.2",
         "rolldown": "^1.1.4",
         "typescript": "^6.0.3"