@gjsify/rolldown-plugin-gjsify 0.53.0 → 0.55.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

@@ -8,6 +8,7 @@ import { createRequire } from 'node:module';
 import { aliasPlugin } from '../plugins/alias.js';
 import { externalsPlugin } from '../plugins/externals.js';
 import { napiNodeAddonPlugin } from '../plugins/napi-node-addon.js';
+import { giOptionalPlugin } from '../plugins/gi-optional.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';
@@ -20,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));
@@ -96,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 = {
@@ -191,6 +194,17 @@ 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'),
         // 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
@@ -233,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

@@ -10,6 +10,8 @@ import { nodeModulesPathRewritePlugin, getBundleDirFromOutput } from '../plugins
 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';
@@ -326,6 +328,13 @@ export const setupForNode = async (input) => {
         // `\0gjsify-entry:` ids `wrapInputWithSideEffects` produces (no-op when
         // nothing was injected).
         ...(virtualEntries.plugin ? [virtualEntries.plugin] : []),
+        // `gi://Ns?version=X&optional` → the guarded load, claimed `pre` and
+        // AHEAD of `gjsGiNodePlugin` on array order, because both match a flagged
+        // specifier and the optional arm has to win: the hard arm's lazy Proxy
+        // answers every member access with `load()` and is never `undefined`, so an
+        // app that degrades on `Ns === undefined` would compile and then throw at
+        // the first real access — on one target only (ADR 0087).
+        giOptionalPlugin('node'),
         // Claims `gi://Ns?version=X` (resolveId `pre` + array order) and rewrites it
         // onto the `@gjsify/node-gi` runtime so a real GJS/GI source builds and runs
         // on Node. Returns null for `@girs/*`.
@@ -336,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

@@ -6,9 +6,13 @@ export { REWRITE_FILTER, extractPackageSpec, getBundleDirFromOutput, rewriteCont
 export type { NodeModulesPathRewriteOptions, RewriteResult } from './plugins/rewrite-node-modules-paths.js';
 export { processStubPlugin, GJS_PROCESS_STUB, composeBanner } from './plugins/process-stub.js';
 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 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

@@ -6,7 +6,9 @@ export * from './library/index.js';
 export { REWRITE_FILTER, extractPackageSpec, getBundleDirFromOutput, rewriteContents, shouldRewrite, shouldInline, nodeModulesPathRewritePlugin, } from './plugins/rewrite-node-modules-paths.js';
 export { processStubPlugin, GJS_PROCESS_STUB, composeBanner } from './plugins/process-stub.js';
 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/css-as-string.js

@@ -99,12 +99,14 @@ async function tryLoadNativeBundler() {
         // specifier. A library that will not load then names its missing
         // dependency and the npm fallback runs, instead of the nameless
         // "Unsupported type void" inside `transform()`.
-        // The same resolve-then-import dance as above, for the probe itself: by
-        // the time a CSS transform asks for the native bundler, utils' `lib/esm`
-        // is long built, so the lazy edge costs nothing and the static one would
-        // have cost a bootable CLI. `./native-library` rather than `./core`:
-        // `core` re-exports `main-loop`, whose module-level singleton would then
-        // exist twice in a process that already has it inlined in the GJS bundle.
+        // The same resolve-then-import dance as above, for the probe itself:
+        // off disk, so the lazy edge costs nothing and the static one would have
+        // cost a bootable CLI. `./native-library` rather than `./core`: `core`
+        // re-exports `main-loop`, whose module-level singleton would then exist
+        // twice in a process that already has it inlined in the GJS bundle. The
+        // walk follows the WORKSPACE, so `@gjsify/utils build:esm` must precede
+        // it — rule 5 of `scripts/check-build-infra-order.mjs` orders that edge,
+        // the one `bundler-pick.ts` is on the success path of.
         //
         // Its own `try` because the outer one cannot tell this apart from "there
         // is no native backend" — and reporting nothing is the one outcome this

package/lib/plugins/gi-optional.d.ts

@@ -0,0 +1,60 @@
+import type { Plugin } from 'rolldown';
+declare const GI_OPTIONAL_VIRTUAL_PREFIX: {
+    readonly gjs: "\0gjsify-gi-optional:";
+    readonly node: "\0gjsify-gi-optional-node:";
+};
+/** Which build target's shim a flagged specifier gets. */
+export type GiOptionalTarget = keyof typeof GI_OPTIONAL_VIRTUAL_PREFIX;
+/** The query flag that declares a `gi://` import optional. */
+export declare const GI_OPTIONAL_FLAG = "optional";
+/**
+ * `Symbol.for` key of the marker statement every optional shim emits, naming its own
+ * namespace so a reader of the ARTIFACT can tell an optional namespace from a hard one.
+ *
+ * WHY IT IS IN THE BUNDLE AND NOT ALONGSIDE IT, which is the design decision this
+ * constant exists to pin: `gjsify ship` reads the emitted file, not the build tree,
+ * and reads the STAGE MANIFEST when it packs on another host — so a sidecar next to
+ * the bundle is a second source that can be stale, absent, or a different file. The
+ * marker is therefore one statement in the module body the plugin already emits, and
+ * it is a `globalThis[Symbol.for(…)]?.(…)` call for two reasons, both measured on
+ * rolldown's own minifier: an unknown global call is not statically pure, so it
+ * survives minification where a bare string constant is dropped by tree-shaking, and
+ * the optional call means nothing on a host that never registers a handler.
+ */
+export declare const GI_OPTIONAL_MARKER = "gjsify.optionalGi";
+/**
+ * The statement that records `namespace` as optional in the artifact.
+ *
+ * Two string arguments in the spelling the node arm's `requireGi("Ns", "X")` already
+ * uses, so one reader answers both targets. The version argument is OMITTED when
+ * there is none, rather than sent empty: a `requireGi` call cannot tell `''` from a
+ * version, and neither can this.
+ */
+export declare function giOptionalMarkerSource(namespace: string, version?: string): string;
+/**
+ * Split `gi://Ns?version=X&optional` into the clean specifier the loader sees and the
+ * flag; `null` when the specifier is not a `gi://` one or does not carry the flag.
+ */
+export declare function parseOptionalGiSpecifier(source: string): {
+    specifier: string;
+    namespace: string;
+    version?: string;
+} | null;
+/**
+ * The module body for one optional namespace. Self-contained: it runs at module
+ * evaluation, where no bundled helper may be assumed, and reaches ambient globals
+ * through `globalThis.` only.
+ */
+export declare function giOptionalShimSource(specifier: string, namespace: string, version?: string): string;
+/**
+ * The `--app node` body: the same contract, reached through `@gjsify/node-gi`.
+ *
+ * The load is EAGER, which is the one place this arm differs from the hard node shim
+ * and the reason is the flag: `requireGi` only fails when it is called, so a lazy Proxy
+ * cannot answer "is it there" without loading it — and the answer is the whole point.
+ * A missing `@gjsify/node-gi` itself lands in the same catch and yields `undefined`,
+ * which is honest: without node-gi no GI namespace loads, optional or not.
+ */
+export declare function giOptionalNodeShimSource(namespace: string, version?: string): string;
+export declare function giOptionalPlugin(target: GiOptionalTarget): Plugin;
+export {};

package/lib/plugins/gi-optional.js

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: MIT
+// `import Goa from 'gi://Goa?version=1.0&optional'` — a GI namespace the app can run
+// without (ADR 0087). Composed by `--app gjs` and `--app node`.
+//
+// A plain `gi://` import is a hard edge: GJS loads the typelib when the specifier is
+// EVALUATED and a missing one aborts the module graph before the app decides anything.
+// The `optional` query flag is the declaration that the app has that decision to make.
+// The import resolves to a virtual module that loads the SAME specifier without the
+// flag inside a try/catch, so the emitted bundle still carries the verbatim
+// `gi://Goa?version=1.0` that `ship/gi-namespaces.ts` and `depends.ts` read, and the
+// namespace is `undefined` when it is absent.
+//
+// BOTH app targets, and the second one was the trap. `--app node` already loads a
+// `gi://` namespace LAZILY (`gjsGiNodePlugin` default-exports a Proxy that calls
+// `requireGi` on first member access), so with the flag ignored the same source kept
+// returning a truthy Proxy where the app checks `Goa === undefined`, and the first
+// real member access threw instead of degrading — a degrade path that works on one
+// build target and not the other is the defect, not the laziness. Hence a NODE
+// shim with the SAME contract: the namespace or `undefined`, plus one warn. It is
+// synchronous rather than a top-level `await import()` (the shape the node arm's
+// synchronous `require()` already has), because a flag whose whole point is that
+// the app can branch on the result must not force every importer to be async.
+import { GJSIFY_VIRTUAL_PREFIX } from '../utils/virtual-module-id.js';
+import { parseGiSpecifier } from './gjs-gi-node.js';
+const GI_OPTIONAL_VIRTUAL_PREFIX = {
+    gjs: `${GJSIFY_VIRTUAL_PREFIX}gi-optional:`,
+    node: `${GJSIFY_VIRTUAL_PREFIX}gi-optional-node:`,
+};
+/** The query flag that declares a `gi://` import optional. */
+export const GI_OPTIONAL_FLAG = 'optional';
+/**
+ * `Symbol.for` key of the marker statement every optional shim emits, naming its own
+ * namespace so a reader of the ARTIFACT can tell an optional namespace from a hard one.
+ *
+ * WHY IT IS IN THE BUNDLE AND NOT ALONGSIDE IT, which is the design decision this
+ * constant exists to pin: `gjsify ship` reads the emitted file, not the build tree,
+ * and reads the STAGE MANIFEST when it packs on another host — so a sidecar next to
+ * the bundle is a second source that can be stale, absent, or a different file. The
+ * marker is therefore one statement in the module body the plugin already emits, and
+ * it is a `globalThis[Symbol.for(…)]?.(…)` call for two reasons, both measured on
+ * rolldown's own minifier: an unknown global call is not statically pure, so it
+ * survives minification where a bare string constant is dropped by tree-shaking, and
+ * the optional call means nothing on a host that never registers a handler.
+ */
+export const GI_OPTIONAL_MARKER = 'gjsify.optionalGi';
+/**
+ * The statement that records `namespace` as optional in the artifact.
+ *
+ * Two string arguments in the spelling the node arm's `requireGi("Ns", "X")` already
+ * uses, so one reader answers both targets. The version argument is OMITTED when
+ * there is none, rather than sent empty: a `requireGi` call cannot tell `''` from a
+ * version, and neither can this.
+ */
+export function giOptionalMarkerSource(namespace, version) {
+    const args = version === undefined ? JSON.stringify(namespace) : `${JSON.stringify(namespace)}, ${JSON.stringify(version)}`;
+    return `globalThis[Symbol.for(${JSON.stringify(GI_OPTIONAL_MARKER)})]?.(${args});`;
+}
+/**
+ * Split `gi://Ns?version=X&optional` into the clean specifier the loader sees and the
+ * flag; `null` when the specifier is not a `gi://` one or does not carry the flag.
+ */
+export function parseOptionalGiSpecifier(source) {
+    if (!source.startsWith('gi://'))
+        return null;
+    const queryIndex = source.indexOf('?');
+    if (queryIndex === -1)
+        return null;
+    const params = new URLSearchParams(source.slice(queryIndex + 1));
+    if (!params.has(GI_OPTIONAL_FLAG))
+        return null;
+    params.delete(GI_OPTIONAL_FLAG);
+    const rest = params.toString();
+    const specifier = source.slice(0, queryIndex) + (rest ? `?${rest}` : '');
+    const parsed = parseGiSpecifier(specifier);
+    if (parsed === null)
+        return null;
+    return { specifier, ...parsed };
+}
+/**
+ * The module body for one optional namespace. Self-contained: it runs at module
+ * evaluation, where no bundled helper may be assumed, and reaches ambient globals
+ * through `globalThis.` only.
+ */
+export function giOptionalShimSource(specifier, namespace, version) {
+    const label = version ? `${namespace} ${version}` : namespace;
+    return (`let ns;\n` +
+        `try {\n` +
+        `  const m = await import(${JSON.stringify(specifier)});\n` +
+        `  ns = m.default ?? m;\n` +
+        `} catch (error) {\n` +
+        `  let searched = '';\n` +
+        `  try {\n` +
+        `    const r = globalThis.imports.gi.GIRepository.Repository.dup_default();\n` +
+        `    searched = ' (typelib search path: ' + r.get_search_path().join(':') + ')';\n` +
+        `  } catch {}\n` +
+        `  console.warn(${JSON.stringify(`optional GI namespace ${label} is not available`)} + searched + ': ' + (error && error.message ? error.message : String(error)));\n` +
+        `}\n` +
+        `${giOptionalMarkerSource(namespace, version)}\n` +
+        `export default ns;\n`);
+}
+/**
+ * The `--app node` body: the same contract, reached through `@gjsify/node-gi`.
+ *
+ * The load is EAGER, which is the one place this arm differs from the hard node shim
+ * and the reason is the flag: `requireGi` only fails when it is called, so a lazy Proxy
+ * cannot answer "is it there" without loading it — and the answer is the whole point.
+ * A missing `@gjsify/node-gi` itself lands in the same catch and yields `undefined`,
+ * which is honest: without node-gi no GI namespace loads, optional or not.
+ */
+export function giOptionalNodeShimSource(namespace, version) {
+    const label = version ? `${namespace} ${version}` : namespace;
+    const versionArg = version === undefined ? '' : `, ${JSON.stringify(version)}`;
+    return (`import { createRequire } from 'node:module';\n` +
+        `const require = createRequire(import.meta.url);\n` +
+        `let ns;\n` +
+        `try {\n` +
+        `  ns = require('@gjsify/node-gi/gi').requireGi(${JSON.stringify(namespace)}${versionArg});\n` +
+        `} catch (error) {\n` +
+        `  console.warn(${JSON.stringify(`optional GI namespace ${label} is not available`)} + ': ' + (error && error.message ? error.message : String(error)));\n` +
+        `}\n` +
+        `${giOptionalMarkerSource(namespace, version)}\n` +
+        `export default ns;\n`);
+}
+export function giOptionalPlugin(target) {
+    const prefix = GI_OPTIONAL_VIRTUAL_PREFIX[target];
+    return {
+        name: `gjsify-gi-optional-${target}`,
+        resolveId: {
+            order: 'pre',
+            filter: { id: /^gi:\/\/.*[?&]optional(?:&|=|$)/ },
+            handler(source) {
+                const parsed = parseOptionalGiSpecifier(source);
+                if (parsed === null)
+                    return null;
+                const version = parsed.version ? `@${parsed.version}` : '';
+                return { id: `${prefix}${parsed.namespace}${version}` };
+            },
+        },
+        load(id) {
+            if (!id.startsWith(prefix))
+                return null;
+            const spec = id.slice(prefix.length);
+            const at = spec.lastIndexOf('@');
+            const namespace = at === -1 ? spec : spec.slice(0, at);
+            const version = at === -1 ? undefined : spec.slice(at + 1);
+            const code = target === 'gjs'
+                ? giOptionalShimSource(`gi://${namespace}${version ? `?version=${version}` : ''}`, namespace, version)
+                : giOptionalNodeShimSource(namespace, version);
+            return { code, moduleSideEffects: false };
+        },
+    };
+}

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.53.0",
+    "version": "0.55.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.53.0",
-        "@gjsify/resolve-npm": "^0.53.0",
-        "@gjsify/rolldown-plugin-deepkit": "^0.53.0",
-        "@gjsify/rolldown-plugin-pnp": "^0.53.0",
-        "@gjsify/utils": "^0.53.0",
-        "@gjsify/vite-plugin-blueprint": "^0.53.0",
+        "@gjsify/console": "^0.55.0",
+        "@gjsify/resolve-npm": "^0.55.0",
+        "@gjsify/rolldown-plugin-deepkit": "^0.55.0",
+        "@gjsify/rolldown-plugin-pnp": "^0.55.0",
+        "@gjsify/utils": "^0.55.0",
+        "@gjsify/vite-plugin-blueprint": "^0.55.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.53.0",
+        "@gjsify/lightningcss-native": "^0.55.0",
         "rolldown": "^1.1.4"
     },
     "peerDependenciesMeta": {
@@ -90,8 +90,8 @@
         }
     },
     "devDependencies": {
-        "@gjsify/cli": "^0.53.0",
-        "@gjsify/unit": "^0.53.0",
+        "@gjsify/cli": "^0.55.0",
+        "@gjsify/unit": "^0.55.0",
         "@types/node": "^25.9.2",
         "rolldown": "^1.1.4",
         "typescript": "^6.0.3"