react-native-gtkx 0.1.0-alpha.4 → 0.2.0-alpha.1

package/dist/sea/bundle.js

@@ -0,0 +1,202 @@
+// Bundles a Metro-built react-native-gtkx app (main.jsbundle) into a
+// single CJS file suitable for Node's --experimental-sea-config, undoing
+// exactly the externalization HOST_MODULE_EXTERNALS performs at Metro
+// build time.
+//
+// Design, and where this follows/diverges from gtkx's own tutorial
+// (gtkx-org/gtkx examples/tutorial/scripts/bundle.ts and
+// bundle-postject.ts — read before any of this was written):
+//
+// - Bundling mechanics (bundle → single minified CJS file) and the
+//   SEA/postject pipeline itself (./assemble.ts) follow the tutorial
+//   closely. The bundler is rolldown rather than the tutorial's esbuild —
+//   NOT a preference: rolldown is vite's own engine (vite 8 depends on it
+//   outright, esbuild is only an optional peer there), and vite is a hard
+//   dependency of @gtkx/cli, which is a hard dependency of this package.
+//   So rolldown is already installed for every consumer, and esbuild would
+//   have been the one genuinely new bundler in the tree.
+// - Native addon: the tutorial's shim assumes the addon file sits BESIDE
+//   the built executable (require resolved from
+//   dirname(process.execPath)). That is two files, not one — the actual
+//   central design decision this epic exists to make — so this diverges:
+//   the addon is embedded IN the artifact (as a SEA asset, or as a base64
+//   literal for the --standalone .cjs) and extracted to a per-user cache
+//   directory on first run. See ./native-shim.ts's header for the full
+//   reasoning.
+// - Metro's externals: the tutorial has no equivalent problem, its source
+//   is already a single vite/rollup bundle. Metro deliberately
+//   externalizes @gtkx/*, react and yoga-layout (../metro/index.ts,
+//   HOST_MODULE_EXTERNALS) so main.jsbundle expects
+//   globalThis.__hostModules/__hostRequire to exist before it runs (see
+//   ../runner/host.ts). This module is a third host implementation
+//   (host.ts and host-dev.ts are the other two — see host-dev.ts's header
+//   for why they don't share code) that builds those globals from real,
+//   STATICALLY imported modules — every name in HOST_MODULE_EXTERNALS
+//   becomes a literal `import * as` statement in the generated entry — so
+//   the bundler can inline them instead of the app needing a runtime
+//   node_modules to dynamically load them from. gtkx.config.ts is also
+//   resolved once here, at bundle time (see ./gtkx-config-module.ts).
+//
+// Not attempted here: the vite path. Investigated, not a drop-in of this
+// same technique — see docs/getting-started.md's "Shipping an app"
+// section for the concrete blocker found empirically while building this:
+// the vite bundle loads the native addon through a DYNAMICALLY obtained
+// require (`createRequire(import.meta.url)("./gtkx.node")`), which a
+// bundler does not intercept the way it intercepts a static import
+// (verified: the resolve hook never fires for it), and which is unlikely
+// to resolve at all once running from inside a real SEA blob, where
+// import.meta.url no longer points at a file with real siblings on disk.
+import { mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { rolldown } from "rolldown";
+import { HOST_MODULE_EXTERNALS } from "../metro/index.js";
+import { buildGtkxConfigModule, virtualConfigModulePlugin, } from "./gtkx-config-module.js";
+import { NATIVE_ASSET_KEY, nativeAddonShimPlugin, } from "./native-shim.js";
+import { reactAnchorPlugin } from "./react-anchor-plugin.js";
+/**
+ * Locates the ONE native addon file npm installed for this machine.
+ * @gtkx/native picks exactly one optionalDependency per platform/libc at
+ * install time (see @gtkx/native/index.js's NAPI-RS-generated loader) —
+ * failing loudly on anything other than exactly one match matters here:
+ * silently picking the wrong one would embed an addon for the wrong
+ * architecture with no error until the app actually launches.
+ */
+export const resolveNativeAddon = (appRoot) => {
+    const appRequire = createRequire(join(appRoot, "package.json"));
+    const nativePackageJson = appRequire.resolve("@gtkx/native/package.json");
+    // .../node_modules/@gtkx/native/package.json -> .../node_modules/@gtkx
+    const scopeDir = dirname(dirname(nativePackageJson));
+    const candidates = readdirSync(scopeDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith("native-"))
+        .flatMap((entry) => {
+        const dir = join(scopeDir, entry.name);
+        return readdirSync(dir)
+            .filter((file) => file.endsWith(".node"))
+            .map((file) => join(dir, file));
+    });
+    const [first, ...rest] = candidates;
+    if (!first || rest.length > 0) {
+        throw new Error(`expected exactly one @gtkx/native-*/*.node under ${scopeDir}, found ` +
+            `${candidates.length} (${candidates.join(", ") || "none"}) — ` +
+            "reinstall targeting a single platform.");
+    }
+    return { path: first, key: NATIVE_ASSET_KEY };
+};
+/**
+ * Builds the synthetic SEA entry source: every HOST_MODULE_EXTERNALS name
+ * loaded through a dynamic `import()` (mirroring runner/host.ts's own
+ * `load()`, which does the same against a real node_modules at runtime),
+ * assembled into globalThis.__hostModules, then the jsbundle text executed
+ * the same way host.ts does.
+ *
+ * Dynamic import, not static, throughout: a Node SEA's main script is
+ * CommonJS only — confirmed empirically, Node 24 executes the embedded
+ * main as CJS regardless of a "type": "module" field in sea-config.json
+ * or an .mjs extension — and top-level await is a hard error under a "cjs"
+ * output format REGARDLESS of whether the module is reached via a static
+ * or dynamic import (the restriction is format-wide, not per-module —
+ * verified: switching yoga-layout's static import to a dynamic one alone
+ * did not clear the error). yoga-layout's own entry point has exactly this
+ * top-level await (it loads its WASM binary asynchronously — see
+ * node_modules/yoga-layout/dist/src/index.js: `const Yoga =
+ * wrapAssembly(await loadYoga())` at module scope). The actual fix: import
+ * "yoga-layout/load" instead, which exports the same `await`, just inside
+ * an async FUNCTION (`export async function loadYoga()`), not at the
+ * file's top level — bundleable, and awaited here like everything else.
+ */
+export const buildEntrySource = (jsbundlePath) => {
+    const jsbundleSource = readFileSync(jsbundlePath, "utf8");
+    const loadLines = HOST_MODULE_EXTERNALS.map((name) => {
+        if (name === "yoga-layout") {
+            return [
+                `  {`,
+                `    const { loadYoga, ...rest } = await import("yoga-layout/load");`,
+                `    hostModules["yoga-layout"] = __interopHostModule({ ...rest, default: await loadYoga() });`,
+                `  }`,
+            ].join("\n");
+        }
+        return `  hostModules[${JSON.stringify(name)}] = __interopHostModule(await import(${JSON.stringify(name)}));`;
+    });
+    return [
+        `async function __gtkxSeaMain() {`,
+        // Mirrors runner/host.ts's `load()` interop: import() handles both ESM
+        // and CJS, merge a `default` for Babel's default-import interop when
+        // the module has none of its own.
+        `  const __interopHostModule = (ns) => {`,
+        `    const merged = Object.assign({ __esModule: true }, ns);`,
+        `    if (!("default" in ns)) merged.default = ns;`,
+        `    return merged;`,
+        `  };`,
+        `  const hostModules = {};`,
+        ...loadLines,
+        `  globalThis.__hostModules = hostModules;`,
+        // Node builtin proxies resolve lazily through the host's own require —
+        // real here, no createRequire indirection needed (see host.ts for why
+        // it needs one: this file's import.meta.url is never used for
+        // anything relative, only require() of bare/builtin specifiers).
+        `  globalThis.__hostRequire = require;`,
+        `  require("node:vm").runInThisContext(${JSON.stringify(jsbundleSource)}, { filename: ${JSON.stringify(jsbundlePath)} });`,
+        `}`,
+        `__gtkxSeaMain().catch((error) => { console.error(error); process.exitCode = 1; });`,
+    ].join("\n");
+};
+/**
+ * Produces `outFile`, a single CJS file with the jsbundle, its
+ * HOST_MODULE_EXTERNALS and gtkx.config.ts's resolved values all inlined,
+ * and the native addon import redirected to the SEA-asset extraction
+ * shim. Returns the native addon that must be embedded as a SEA asset
+ * under {@link NativeAddonAsset.key} for the result to run.
+ */
+export const bundleMetroSea = async (options) => {
+    const { appRoot, jsbundlePath, outFile } = options;
+    const nativeAddonSource = options.nativeAddonSource ?? "sea-asset";
+    const configModuleSource = await buildGtkxConfigModule(appRoot);
+    const nativeAddon = resolveNativeAddon(appRoot);
+    const entrySource = buildEntrySource(jsbundlePath);
+    mkdirSync(dirname(outFile), { recursive: true });
+    // The entry is given a path inside appRoot that does not exist on disk,
+    // rather than a `\0`-prefixed virtual id: every bare specifier it
+    // imports (react, @gtkx/*, yoga-layout) must resolve from the app's own
+    // node_modules, and a real directory is what makes that happen.
+    const entryId = join(appRoot, "__gtkx-sea-entry.js");
+    const bundle = await rolldown({
+        input: entryId,
+        cwd: appRoot,
+        platform: "node",
+        plugins: [
+            {
+                name: "gtkx-sea-entry",
+                resolveId: (source) => (source === entryId ? entryId : null),
+                load: (id) => (id === entryId ? entrySource : null),
+            },
+            reactAnchorPlugin(appRoot),
+            nativeAddonShimPlugin({
+                specifier: "@gtkx/native",
+                appRoot,
+                source: nativeAddonSource,
+                assetKey: nativeAddon.key,
+                addonBytes: nativeAddonSource === "inline"
+                    ? readFileSync(nativeAddon.path)
+                    : undefined,
+            }),
+            virtualConfigModulePlugin(configModuleSource, appRoot),
+        ],
+    });
+    try {
+        await bundle.write({
+            file: outFile,
+            format: "cjs",
+            minify: true,
+            // Every HOST_MODULE_EXTERNALS name is reached through a dynamic
+            // import; without this each one becomes its own chunk and the
+            // "single file" the whole build exists to produce is a directory.
+            codeSplitting: false,
+        });
+    }
+    finally {
+        await bundle.close();
+    }
+    return nativeAddon;
+};
+//# sourceMappingURL=bundle.js.map

package/dist/sea/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","sourceRoot":"","sources":["../../src/sea/bundle.ts"],"names":[],"mappings":"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","sourcesContent":["// Bundles a Metro-built react-native-gtkx app (main.jsbundle) into a\n// single CJS file suitable for Node's --experimental-sea-config, undoing\n// exactly the externalization HOST_MODULE_EXTERNALS performs at Metro\n// build time.\n//\n// Design, and where this follows/diverges from gtkx's own tutorial\n// (gtkx-org/gtkx examples/tutorial/scripts/bundle.ts and\n// bundle-postject.ts — read before any of this was written):\n//\n// - Bundling mechanics (bundle → single minified CJS file) and the\n//   SEA/postject pipeline itself (./assemble.ts) follow the tutorial\n//   closely. The bundler is rolldown rather than the tutorial's esbuild —\n//   NOT a preference: rolldown is vite's own engine (vite 8 depends on it\n//   outright, esbuild is only an optional peer there), and vite is a hard\n//   dependency of @gtkx/cli, which is a hard dependency of this package.\n//   So rolldown is already installed for every consumer, and esbuild would\n//   have been the one genuinely new bundler in the tree.\n// - Native addon: the tutorial's shim assumes the addon file sits BESIDE\n//   the built executable (require resolved from\n//   dirname(process.execPath)). That is two files, not one — the actual\n//   central design decision this epic exists to make — so this diverges:\n//   the addon is embedded IN the artifact (as a SEA asset, or as a base64\n//   literal for the --standalone .cjs) and extracted to a per-user cache\n//   directory on first run. See ./native-shim.ts's header for the full\n//   reasoning.\n// - Metro's externals: the tutorial has no equivalent problem, its source\n//   is already a single vite/rollup bundle. Metro deliberately\n//   externalizes @gtkx/*, react and yoga-layout (../metro/index.ts,\n//   HOST_MODULE_EXTERNALS) so main.jsbundle expects\n//   globalThis.__hostModules/__hostRequire to exist before it runs (see\n//   ../runner/host.ts). This module is a third host implementation\n//   (host.ts and host-dev.ts are the other two — see host-dev.ts's header\n//   for why they don't share code) that builds those globals from real,\n//   STATICALLY imported modules — every name in HOST_MODULE_EXTERNALS\n//   becomes a literal `import * as` statement in the generated entry — so\n//   the bundler can inline them instead of the app needing a runtime\n//   node_modules to dynamically load them from. gtkx.config.ts is also\n//   resolved once here, at bundle time (see ./gtkx-config-module.ts).\n//\n// Not attempted here: the vite path. Investigated, not a drop-in of this\n// same technique — see docs/getting-started.md's \"Shipping an app\"\n// section for the concrete blocker found empirically while building this:\n// the vite bundle loads the native addon through a DYNAMICALLY obtained\n// require (`createRequire(import.meta.url)(\"./gtkx.node\")`), which a\n// bundler does not intercept the way it intercepts a static import\n// (verified: the resolve hook never fires for it), and which is unlikely\n// to resolve at all once running from inside a real SEA blob, where\n// import.meta.url no longer points at a file with real siblings on disk.\nimport { mkdirSync, readdirSync, readFileSync } from \"node:fs\"\nimport { createRequire } from \"node:module\"\nimport { dirname, join } from \"node:path\"\nimport { rolldown } from \"rolldown\"\nimport { HOST_MODULE_EXTERNALS } from \"../metro/index.js\"\nimport {\n  buildGtkxConfigModule,\n  virtualConfigModulePlugin,\n} from \"./gtkx-config-module.js\"\nimport {\n  NATIVE_ASSET_KEY,\n  nativeAddonShimPlugin,\n  type NativeAddonSource,\n} from \"./native-shim.js\"\nimport { reactAnchorPlugin } from \"./react-anchor-plugin.js\"\n\nexport type MetroSeaBundleOptions = {\n  /** The app root — where gtkx.config.ts lives and package.json resolves\n   * HOST_MODULE_EXTERNALS' bare specifiers (react, @gtkx/*, ...) from. */\n  appRoot: string\n  /** Path to the release jsbundle produced by `build-linux`. */\n  jsbundlePath: string\n  /** Where to write the bundled CJS entry (e.g. dist/bundle.cjs). */\n  outFile: string\n  /** Where the native addon's bytes come from at runtime — \"sea-asset\"\n   * for a real single executable, \"inline\" for a self-contained .cjs run\n   * by a system Node (default: \"sea-asset\"). */\n  nativeAddonSource?: NativeAddonSource\n}\n\nexport type NativeAddonAsset = {\n  /** Absolute path to the platform's @gtkx/native-<platform>-<libc>.node\n   * that npm installed for this machine. */\n  path: string\n  /** The SEA asset key it must be embedded under. */\n  key: string\n}\n\n/**\n * Locates the ONE native addon file npm installed for this machine.\n * @gtkx/native picks exactly one optionalDependency per platform/libc at\n * install time (see @gtkx/native/index.js's NAPI-RS-generated loader) —\n * failing loudly on anything other than exactly one match matters here:\n * silently picking the wrong one would embed an addon for the wrong\n * architecture with no error until the app actually launches.\n */\nexport const resolveNativeAddon = (appRoot: string): NativeAddonAsset => {\n  const appRequire = createRequire(join(appRoot, \"package.json\"))\n  const nativePackageJson = appRequire.resolve(\"@gtkx/native/package.json\")\n  // .../node_modules/@gtkx/native/package.json -> .../node_modules/@gtkx\n  const scopeDir = dirname(dirname(nativePackageJson))\n  const candidates = readdirSync(scopeDir, { withFileTypes: true })\n    .filter((entry) => entry.isDirectory() && entry.name.startsWith(\"native-\"))\n    .flatMap((entry) => {\n      const dir = join(scopeDir, entry.name)\n      return readdirSync(dir)\n        .filter((file) => file.endsWith(\".node\"))\n        .map((file) => join(dir, file))\n    })\n  const [first, ...rest] = candidates\n  if (!first || rest.length > 0) {\n    throw new Error(\n      `expected exactly one @gtkx/native-*/*.node under ${scopeDir}, found ` +\n        `${candidates.length} (${candidates.join(\", \") || \"none\"}) — ` +\n        \"reinstall targeting a single platform.\",\n    )\n  }\n  return { path: first, key: NATIVE_ASSET_KEY }\n}\n\n/**\n * Builds the synthetic SEA entry source: every HOST_MODULE_EXTERNALS name\n * loaded through a dynamic `import()` (mirroring runner/host.ts's own\n * `load()`, which does the same against a real node_modules at runtime),\n * assembled into globalThis.__hostModules, then the jsbundle text executed\n * the same way host.ts does.\n *\n * Dynamic import, not static, throughout: a Node SEA's main script is\n * CommonJS only — confirmed empirically, Node 24 executes the embedded\n * main as CJS regardless of a \"type\": \"module\" field in sea-config.json\n * or an .mjs extension — and top-level await is a hard error under a \"cjs\"\n * output format REGARDLESS of whether the module is reached via a static\n * or dynamic import (the restriction is format-wide, not per-module —\n * verified: switching yoga-layout's static import to a dynamic one alone\n * did not clear the error). yoga-layout's own entry point has exactly this\n * top-level await (it loads its WASM binary asynchronously — see\n * node_modules/yoga-layout/dist/src/index.js: `const Yoga =\n * wrapAssembly(await loadYoga())` at module scope). The actual fix: import\n * \"yoga-layout/load\" instead, which exports the same `await`, just inside\n * an async FUNCTION (`export async function loadYoga()`), not at the\n * file's top level — bundleable, and awaited here like everything else.\n */\nexport const buildEntrySource = (jsbundlePath: string): string => {\n  const jsbundleSource = readFileSync(jsbundlePath, \"utf8\")\n  const loadLines = HOST_MODULE_EXTERNALS.map((name) => {\n    if (name === \"yoga-layout\") {\n      return [\n        `  {`,\n        `    const { loadYoga, ...rest } = await import(\"yoga-layout/load\");`,\n        `    hostModules[\"yoga-layout\"] = __interopHostModule({ ...rest, default: await loadYoga() });`,\n        `  }`,\n      ].join(\"\\n\")\n    }\n    return `  hostModules[${JSON.stringify(name)}] = __interopHostModule(await import(${JSON.stringify(name)}));`\n  })\n  return [\n    `async function __gtkxSeaMain() {`,\n    // Mirrors runner/host.ts's `load()` interop: import() handles both ESM\n    // and CJS, merge a `default` for Babel's default-import interop when\n    // the module has none of its own.\n    `  const __interopHostModule = (ns) => {`,\n    `    const merged = Object.assign({ __esModule: true }, ns);`,\n    `    if (!(\"default\" in ns)) merged.default = ns;`,\n    `    return merged;`,\n    `  };`,\n    `  const hostModules = {};`,\n    ...loadLines,\n    `  globalThis.__hostModules = hostModules;`,\n    // Node builtin proxies resolve lazily through the host's own require —\n    // real here, no createRequire indirection needed (see host.ts for why\n    // it needs one: this file's import.meta.url is never used for\n    // anything relative, only require() of bare/builtin specifiers).\n    `  globalThis.__hostRequire = require;`,\n    `  require(\"node:vm\").runInThisContext(${JSON.stringify(jsbundleSource)}, { filename: ${JSON.stringify(jsbundlePath)} });`,\n    `}`,\n    `__gtkxSeaMain().catch((error) => { console.error(error); process.exitCode = 1; });`,\n  ].join(\"\\n\")\n}\n\n/**\n * Produces `outFile`, a single CJS file with the jsbundle, its\n * HOST_MODULE_EXTERNALS and gtkx.config.ts's resolved values all inlined,\n * and the native addon import redirected to the SEA-asset extraction\n * shim. Returns the native addon that must be embedded as a SEA asset\n * under {@link NativeAddonAsset.key} for the result to run.\n */\nexport const bundleMetroSea = async (\n  options: MetroSeaBundleOptions,\n): Promise<NativeAddonAsset> => {\n  const { appRoot, jsbundlePath, outFile } = options\n  const nativeAddonSource = options.nativeAddonSource ?? \"sea-asset\"\n  const configModuleSource = await buildGtkxConfigModule(appRoot)\n  const nativeAddon = resolveNativeAddon(appRoot)\n  const entrySource = buildEntrySource(jsbundlePath)\n\n  mkdirSync(dirname(outFile), { recursive: true })\n\n  // The entry is given a path inside appRoot that does not exist on disk,\n  // rather than a `\\0`-prefixed virtual id: every bare specifier it\n  // imports (react, @gtkx/*, yoga-layout) must resolve from the app's own\n  // node_modules, and a real directory is what makes that happen.\n  const entryId = join(appRoot, \"__gtkx-sea-entry.js\")\n\n  const bundle = await rolldown({\n    input: entryId,\n    cwd: appRoot,\n    platform: \"node\",\n    plugins: [\n      {\n        name: \"gtkx-sea-entry\",\n        resolveId: (source) => (source === entryId ? entryId : null),\n        load: (id) => (id === entryId ? entrySource : null),\n      },\n      reactAnchorPlugin(appRoot),\n      nativeAddonShimPlugin({\n        specifier: \"@gtkx/native\",\n        appRoot,\n        source: nativeAddonSource,\n        assetKey: nativeAddon.key,\n        addonBytes:\n          nativeAddonSource === \"inline\"\n            ? readFileSync(nativeAddon.path)\n            : undefined,\n      }),\n      virtualConfigModulePlugin(configModuleSource, appRoot),\n    ],\n  })\n  try {\n    await bundle.write({\n      file: outFile,\n      format: \"cjs\",\n      minify: true,\n      // Every HOST_MODULE_EXTERNALS name is reached through a dynamic\n      // import; without this each one becomes its own chunk and the\n      // \"single file\" the whole build exists to produce is a directory.\n      codeSplitting: false,\n    })\n  } finally {\n    await bundle.close()\n  }\n\n  return nativeAddon\n}\n"]}

package/dist/sea/gtkx-config-module.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "rolldown";
+export declare const CONFIG_REQUIRED: string;
+/**
+ * Loads and validates the app's gtkx.config.ts, returning the source of a
+ * virtual:gtkx-config module with the resolved values baked in as literals.
+ */
+export declare const buildGtkxConfigModule: (appRoot: string) => Promise<string>;
+/**
+ * Resolves the bare "virtual:gtkx-config" specifier @gtkx/react imports to
+ * the module source built by {@link buildGtkxConfigModule}, so the bundler
+ * can inline it like any other static import — no runtime loader hook
+ * needed.
+ *
+ * The module is given an id inside `appRoot` rather than a `\0`-prefixed
+ * virtual one because it re-exports "@gtkx/jsx/metadata": that bare
+ * specifier needs a real directory to resolve from.
+ */
+export declare const virtualConfigModulePlugin: (moduleSource: string, appRoot: string) => Plugin;

package/dist/sea/gtkx-config-module.js

@@ -0,0 +1,67 @@
+// @gtkx/react imports the bare specifier "virtual:gtkx-config" for JSX
+// metadata plus the app's applicationId/userEventSignals/lazy elements.
+// runner/host.ts resolves it at every process start through a loader hook
+// (registerHooks), reading gtkx.config.ts from the current working
+// directory. A SEA has no "app root" to read a config file from at
+// runtime — there is no cwd convention once the app is a single file
+// copied anywhere — so this bakes the same values in at BUILD time
+// instead, the same way the vite path already does (its CLI plugin serves
+// virtual:gtkx-config from the build-time config, never a runtime read).
+//
+// Deliberately duplicated validation logic rather than shared with
+// host.ts: see host-dev.ts's header comment for why the hosts in this
+// package are self-contained twins rather than sharing relative imports —
+// this is a third twin, for the same reason (host.ts must keep resolving
+// its config at runtime for ordinary `run-linux`/installed-app use; this
+// one resolves it once, at bundle time, for the SEA artifact only).
+import { join } from "node:path";
+import { createConfigLoader } from "@gtkx/config/internal";
+export const CONFIG_REQUIRED = "gtkx.config.ts with an applicationId is required in the app root " +
+    '(export default defineConfig({ applicationId: "...", libraries: [...] })).';
+/**
+ * Loads and validates the app's gtkx.config.ts, returning the source of a
+ * virtual:gtkx-config module with the resolved values baked in as literals.
+ */
+export const buildGtkxConfigModule = async (appRoot) => {
+    const loader = createConfigLoader();
+    const config = await loader(appRoot).catch((error) => {
+        throw new Error(`${CONFIG_REQUIRED}\n${String(error)}`);
+    });
+    if (!config.applicationId) {
+        throw new Error(CONFIG_REQUIRED);
+    }
+    // A behaviors module would have to be bundled and merged through
+    // @gtkx/react/config; the react-native surface owns element behaviors,
+    // so no app declares one — refuse rather than silently drop it (mirrors
+    // host.ts's runtime check).
+    if (config.elements !== null) {
+        throw new Error("gtkx.config.ts `elements.behaviors` is not supported on the linux " +
+            "platform — react-native-gtkx owns element behaviors.");
+    }
+    const lazyElements = Object.fromEntries(config.lazyElements.map((type) => [type, { lazy: true }]));
+    return [
+        `export * from "@gtkx/jsx/metadata";`,
+        `export const applicationId = ${JSON.stringify(config.applicationId)};`,
+        `export const userEventSignals = ${JSON.stringify(config.userEventSignals)};`,
+        `export const elements = ${JSON.stringify(lazyElements)};`,
+    ].join("\n");
+};
+/**
+ * Resolves the bare "virtual:gtkx-config" specifier @gtkx/react imports to
+ * the module source built by {@link buildGtkxConfigModule}, so the bundler
+ * can inline it like any other static import — no runtime loader hook
+ * needed.
+ *
+ * The module is given an id inside `appRoot` rather than a `\0`-prefixed
+ * virtual one because it re-exports "@gtkx/jsx/metadata": that bare
+ * specifier needs a real directory to resolve from.
+ */
+export const virtualConfigModulePlugin = (moduleSource, appRoot) => {
+    const configId = join(appRoot, "__gtkx-sea-config.js");
+    return {
+        name: "gtkx-virtual-config",
+        resolveId: (source) => (source === "virtual:gtkx-config" ? configId : null),
+        load: (id) => (id === configId ? moduleSource : null),
+    };
+};
+//# sourceMappingURL=gtkx-config-module.js.map

package/dist/sea/gtkx-config-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gtkx-config-module.js","sourceRoot":"","sources":["../../src/sea/gtkx-config-module.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,wEAAwE;AACxE,0EAA0E;AAC1E,mEAAmE;AACnE,mEAAmE;AACnE,qEAAqE;AACrE,mEAAmE;AACnE,0EAA0E;AAC1E,yEAAyE;AACzE,EAAE;AACF,mEAAmE;AACnE,sEAAsE;AACtE,0EAA0E;AAC1E,yEAAyE;AACzE,yEAAyE;AACzE,oEAAoE;AACpE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAG1D,MAAM,CAAC,MAAM,eAAe,GAC1B,mEAAmE;IACnE,4EAA4E,CAAA;AAE9E;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,KAAK,EACxC,OAAe,EACE,EAAE;IACnB,MAAM,MAAM,GAAG,kBAAkB,EAAE,CAAA;IACnC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;QAC5D,MAAM,IAAI,KAAK,CAAC,GAAG,eAAe,KAAK,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IACzD,CAAC,CAAC,CAAA;IACF,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAA;IAClC,CAAC;IACD,iEAAiE;IACjE,uEAAuE;IACvE,wEAAwE;IACxE,4BAA4B;IAC5B,IAAI,MAAM,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,oEAAoE;YAClE,sDAAsD,CACzD,CAAA;IACH,CAAC;IACD,MAAM,YAAY,GAAG,MAAM,CAAC,WAAW,CACrC,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAC1D,CAAA;IACD,OAAO;QACL,qCAAqC;QACrC,gCAAgC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG;QACvE,mCAAmC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG;QAC7E,2BAA2B,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,GAAG;KAC3D,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACd,CAAC,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACvC,YAAoB,EACpB,OAAe,EACP,EAAE;IACV,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,EAAE,sBAAsB,CAAC,CAAA;IACtD,OAAO;QACL,IAAI,EAAE,qBAAqB;QAC3B,SAAS,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,KAAK,qBAAqB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;QAC3E,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC;KACtD,CAAA;AACH,CAAC,CAAA","sourcesContent":["// @gtkx/react imports the bare specifier \"virtual:gtkx-config\" for JSX\n// metadata plus the app's applicationId/userEventSignals/lazy elements.\n// runner/host.ts resolves it at every process start through a loader hook\n// (registerHooks), reading gtkx.config.ts from the current working\n// directory. A SEA has no \"app root\" to read a config file from at\n// runtime — there is no cwd convention once the app is a single file\n// copied anywhere — so this bakes the same values in at BUILD time\n// instead, the same way the vite path already does (its CLI plugin serves\n// virtual:gtkx-config from the build-time config, never a runtime read).\n//\n// Deliberately duplicated validation logic rather than shared with\n// host.ts: see host-dev.ts's header comment for why the hosts in this\n// package are self-contained twins rather than sharing relative imports —\n// this is a third twin, for the same reason (host.ts must keep resolving\n// its config at runtime for ordinary `run-linux`/installed-app use; this\n// one resolves it once, at bundle time, for the SEA artifact only).\nimport { join } from \"node:path\"\nimport { createConfigLoader } from \"@gtkx/config/internal\"\nimport type { Plugin } from \"rolldown\"\n\nexport const CONFIG_REQUIRED =\n  \"gtkx.config.ts with an applicationId is required in the app root \" +\n  '(export default defineConfig({ applicationId: \"...\", libraries: [...] })).'\n\n/**\n * Loads and validates the app's gtkx.config.ts, returning the source of a\n * virtual:gtkx-config module with the resolved values baked in as literals.\n */\nexport const buildGtkxConfigModule = async (\n  appRoot: string,\n): Promise<string> => {\n  const loader = createConfigLoader()\n  const config = await loader(appRoot).catch((error: unknown) => {\n    throw new Error(`${CONFIG_REQUIRED}\\n${String(error)}`)\n  })\n  if (!config.applicationId) {\n    throw new Error(CONFIG_REQUIRED)\n  }\n  // A behaviors module would have to be bundled and merged through\n  // @gtkx/react/config; the react-native surface owns element behaviors,\n  // so no app declares one — refuse rather than silently drop it (mirrors\n  // host.ts's runtime check).\n  if (config.elements !== null) {\n    throw new Error(\n      \"gtkx.config.ts `elements.behaviors` is not supported on the linux \" +\n        \"platform — react-native-gtkx owns element behaviors.\",\n    )\n  }\n  const lazyElements = Object.fromEntries(\n    config.lazyElements.map((type) => [type, { lazy: true }]),\n  )\n  return [\n    `export * from \"@gtkx/jsx/metadata\";`,\n    `export const applicationId = ${JSON.stringify(config.applicationId)};`,\n    `export const userEventSignals = ${JSON.stringify(config.userEventSignals)};`,\n    `export const elements = ${JSON.stringify(lazyElements)};`,\n  ].join(\"\\n\")\n}\n\n/**\n * Resolves the bare \"virtual:gtkx-config\" specifier @gtkx/react imports to\n * the module source built by {@link buildGtkxConfigModule}, so the bundler\n * can inline it like any other static import — no runtime loader hook\n * needed.\n *\n * The module is given an id inside `appRoot` rather than a `\\0`-prefixed\n * virtual one because it re-exports \"@gtkx/jsx/metadata\": that bare\n * specifier needs a real directory to resolve from.\n */\nexport const virtualConfigModulePlugin = (\n  moduleSource: string,\n  appRoot: string,\n): Plugin => {\n  const configId = join(appRoot, \"__gtkx-sea-config.js\")\n  return {\n    name: \"gtkx-virtual-config\",\n    resolveId: (source) => (source === \"virtual:gtkx-config\" ? configId : null),\n    load: (id) => (id === configId ? moduleSource : null),\n  }\n}\n"]}

package/dist/sea/native-shim.d.ts

@@ -0,0 +1,40 @@
+import type { Plugin } from "rolldown";
+export declare const NATIVE_ASSET_KEY = "gtkx-native.node";
+/**
+ * Where the shim gets the addon's bytes from — the only difference between
+ * the two single-file artifacts:
+ *
+ * - `"sea-asset"`: from the SEA blob, via node:sea. Only works inside a
+ *   real single executable.
+ * - `"inline"`: from a base64 literal in the bundle itself, so the CJS
+ *   file is self-contained under a plain `node app.cjs` — the same
+ *   artifact minus the embedded Node runtime. Costs ~4/3 of the addon's
+ *   size in source text (the addon is ~1.6 MB) and is parsed once at
+ *   startup; the extraction and dlopen below are shared.
+ */
+export type NativeAddonSource = "sea-asset" | "inline";
+export type NativeAddonShimOptions = {
+    /** The bare specifier to replace, in practice "@gtkx/native". */
+    specifier: string;
+    /** The app root — the shim's id lives here, see above. */
+    appRoot: string;
+    /** Where the addon's bytes come from at runtime. */
+    source: NativeAddonSource;
+    /** SEA asset key; unused when `source` is "inline". */
+    assetKey?: string;
+    /** The addon's bytes; required when `source` is "inline". */
+    addonBytes?: Buffer;
+};
+/**
+ * Intercepts every import/require of `specifier` (an exact bare module
+ * specifier, e.g. "@gtkx/native") and replaces it with the extraction shim
+ * above. The real module never reaches the bundle graph — only its
+ * re-exported surface, loaded from the extracted file at runtime.
+ *
+ * The shim is given an id inside `appRoot` with a `.cjs` extension rather
+ * than a `\0`-prefixed virtual one: the shim IS CommonJS (it assigns
+ * `module.exports` so consumers' NAMED imports of the addon still resolve
+ * through the bundler's interop), and a real directory is what lets any
+ * specifier inside it resolve normally.
+ */
+export declare const nativeAddonShimPlugin: (options: NativeAddonShimOptions) => Plugin;

package/dist/sea/native-shim.js

@@ -0,0 +1,121 @@
+// The gtkx native addon (@gtkx/native-<platform>-<libc>, a Rust/NAPI addon
+// loaded through dlopen — see docs/getting-started.md's "Shipping an app"
+// section for the full design reasoning) cannot be embedded as bundled JS:
+// a Node SEA is a V8 code cache blob, and dlopen needs a real file on a
+// real filesystem, not bytes inside the executable.
+//
+// So it has to be carried as bytes and written back to disk before use.
+// This plugin swaps every import of a given specifier (in practice,
+// "@gtkx/native" — see ../sea/bundle.ts) for a shim that does exactly
+// that: extract to a per-user cache directory (content-hash-keyed, so
+// repeat launches reuse the file instead of re-extracting ~1.6 MB every
+// start) and dlopen it from there. Where the bytes come from is the one
+// difference between the two single-file artifacts — Node's SEA "assets"
+// mechanism for the executable, a base64 literal for the standalone .cjs;
+// see {@link NativeAddonSource}.
+//
+// Cache location: XDG_CACHE_HOME (or ~/.cache) first, os.tmpdir() as a
+// fallback for a read-only $HOME. Deliberately NOT the SEA executable's
+// own directory — that may be read-only (a mounted image, a root-owned
+// install under /opt) or simply a different place than where the addon
+// was extracted the first time, if the binary moved. This is the same
+// question gtkx's own tutorial answers by placing the addon BESIDE the
+// executable (dist/gtkx.node next to dist/app) — a real divergence, not an
+// oversight: that keeps two files, which is exactly what this epic set
+// out to stop doing.
+import { join } from "node:path";
+export const NATIVE_ASSET_KEY = "gtkx-native.node";
+const bytesExpression = (source, assetKey) => source === "sea-asset"
+    ? `Buffer.from(require("node:sea").getAsset(${JSON.stringify(assetKey)}))`
+    : `Buffer.from(__gtkxNativeBase64, "base64")`;
+const shimSource = (source, assetKey, base64) => `
+const { createHash } = require("node:crypto");
+const { mkdirSync, existsSync, writeFileSync, renameSync } = require("node:fs");
+const { join } = require("node:path");
+const os = require("node:os");
+${source === "inline" ? `const __gtkxNativeBase64 = ${JSON.stringify(base64)};` : ""}
+
+const bytes = ${bytesExpression(source, assetKey)};
+const hash = createHash("sha256").update(bytes).digest("hex").slice(0, 16);
+const fileName = "native-" + hash + ".node";
+
+const candidateDirs = [
+  join(process.env.XDG_CACHE_HOME || join(os.homedir(), ".cache"), "react-native-gtkx-sea"),
+  join(os.tmpdir(), "react-native-gtkx-sea"),
+];
+
+let target;
+let lastError;
+for (const dir of candidateDirs) {
+  try {
+    mkdirSync(dir, { recursive: true });
+    const candidate = join(dir, fileName);
+    if (!existsSync(candidate)) {
+      const tmp = candidate + "." + process.pid + ".tmp";
+      writeFileSync(tmp, bytes, { mode: 0o755 });
+      renameSync(tmp, candidate);
+    }
+    target = candidate;
+    break;
+  } catch (error) {
+    lastError = error;
+  }
+}
+if (!target) {
+  throw new Error(
+    "react-native-gtkx: could not extract the native addon to a writable " +
+      "cache directory (tried " + candidateDirs.join(", ") + "): " + String(lastError),
+  );
+}
+
+// Not require(target): the require() available to a SEA's main script is
+// restricted to built-ins and embedded assets (verified — requiring an
+// arbitrary absolute path from here throws ERR_UNKNOWN_BUILTIN_MODULE, the
+// same error Node throws for an unrecognized built-in specifier). That
+// restriction doesn't apply to process.dlopen(), the lower-level
+// primitive require() itself uses for ".node" files (Module._extensions
+// [".node"]) — it works on any real path, which is exactly what makes
+// this shim work at all. The "inline" build could use a plain require()
+// here, but shares dlopen() rather than branching: one code path that is
+// proven by both artifacts beats two, one of which is rarely exercised.
+const nativeModule = { exports: {} };
+process.dlopen(nativeModule, target);
+// The vite path's own build (dist/bundle.js, gtkx's CLI plugin) calls
+// this immediately after loading the addon, before anything else touches
+// it; @gtkx/runtime's compiled JS never calls it itself (confirmed by
+// inspecting its dist — it only re-exports a handful of low-level
+// functions), so ordinary require() of the addon through Node's own
+// napi module registration must be relying on something dlopen() alone
+// does not trigger. Without this call the addon has no thread registered
+// as "the Node environment's owner" and the first GTK-driven callback
+// into JS panics: "the Node environment was accessed from a thread it is
+// not installed on" (reproduced and fixed by adding this line).
+nativeModule.exports.init();
+module.exports = nativeModule.exports;
+`;
+/**
+ * Intercepts every import/require of `specifier` (an exact bare module
+ * specifier, e.g. "@gtkx/native") and replaces it with the extraction shim
+ * above. The real module never reaches the bundle graph — only its
+ * re-exported surface, loaded from the extracted file at runtime.
+ *
+ * The shim is given an id inside `appRoot` with a `.cjs` extension rather
+ * than a `\0`-prefixed virtual one: the shim IS CommonJS (it assigns
+ * `module.exports` so consumers' NAMED imports of the addon still resolve
+ * through the bundler's interop), and a real directory is what lets any
+ * specifier inside it resolve normally.
+ */
+export const nativeAddonShimPlugin = (options) => {
+    const { specifier, appRoot, source } = options;
+    if (source === "inline" && !options.addonBytes) {
+        throw new Error('the "inline" native addon source needs addonBytes');
+    }
+    const shimId = join(appRoot, "__gtkx-sea-native-shim.cjs");
+    const contents = shimSource(source, options.assetKey ?? NATIVE_ASSET_KEY, options.addonBytes?.toString("base64") ?? "");
+    return {
+        name: "gtkx-native-addon-shim",
+        resolveId: (id) => (id === specifier ? shimId : null),
+        load: (id) => (id === shimId ? contents : null),
+    };
+};
+//# sourceMappingURL=native-shim.js.map

package/dist/sea/native-shim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-shim.js","sourceRoot":"","sources":["../../src/sea/native-shim.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,0EAA0E;AAC1E,2EAA2E;AAC3E,wEAAwE;AACxE,oDAAoD;AACpD,EAAE;AACF,wEAAwE;AACxE,oEAAoE;AACpE,sEAAsE;AACtE,sEAAsE;AACtE,wEAAwE;AACxE,wEAAwE;AACxE,yEAAyE;AACzE,0EAA0E;AAC1E,iCAAiC;AACjC,EAAE;AACF,uEAAuE;AACvE,wEAAwE;AACxE,uEAAuE;AACvE,uEAAuE;AACvE,sEAAsE;AACtE,uEAAuE;AACvE,2EAA2E;AAC3E,uEAAuE;AACvE,qBAAqB;AACrB,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAGhC,MAAM,CAAC,MAAM,gBAAgB,GAAG,kBAAkB,CAAA;AAgBlD,MAAM,eAAe,GAAG,CACtB,MAAyB,EACzB,QAAgB,EACR,EAAE,CACV,MAAM,KAAK,WAAW;IACpB,CAAC,CAAC,4CAA4C,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI;IAC1E,CAAC,CAAC,2CAA2C,CAAA;AAEjD,MAAM,UAAU,GAAG,CACjB,MAAyB,EACzB,QAAgB,EAChB,MAAc,EACN,EAAE,CAAC;;;;;EAKX,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,8BAA8B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;;gBAEpE,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDhD,CAAA;AAeD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,OAA+B,EACvB,EAAE;IACV,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAA;IAC9C,IAAI,MAAM,KAAK,QAAQ,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;QAC/C,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAA;IACtE,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,4BAA4B,CAAC,CAAA;IAC1D,MAAM,QAAQ,GAAG,UAAU,CACzB,MAAM,EACN,OAAO,CAAC,QAAQ,IAAI,gBAAgB,EACpC,OAAO,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,CAC7C,CAAA;IACD,OAAO;QACL,IAAI,EAAE,wBAAwB;QAC9B,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;QACrD,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;KAChD,CAAA;AACH,CAAC,CAAA","sourcesContent":["// The gtkx native addon (@gtkx/native-<platform>-<libc>, a Rust/NAPI addon\n// loaded through dlopen — see docs/getting-started.md's \"Shipping an app\"\n// section for the full design reasoning) cannot be embedded as bundled JS:\n// a Node SEA is a V8 code cache blob, and dlopen needs a real file on a\n// real filesystem, not bytes inside the executable.\n//\n// So it has to be carried as bytes and written back to disk before use.\n// This plugin swaps every import of a given specifier (in practice,\n// \"@gtkx/native\" — see ../sea/bundle.ts) for a shim that does exactly\n// that: extract to a per-user cache directory (content-hash-keyed, so\n// repeat launches reuse the file instead of re-extracting ~1.6 MB every\n// start) and dlopen it from there. Where the bytes come from is the one\n// difference between the two single-file artifacts — Node's SEA \"assets\"\n// mechanism for the executable, a base64 literal for the standalone .cjs;\n// see {@link NativeAddonSource}.\n//\n// Cache location: XDG_CACHE_HOME (or ~/.cache) first, os.tmpdir() as a\n// fallback for a read-only $HOME. Deliberately NOT the SEA executable's\n// own directory — that may be read-only (a mounted image, a root-owned\n// install under /opt) or simply a different place than where the addon\n// was extracted the first time, if the binary moved. This is the same\n// question gtkx's own tutorial answers by placing the addon BESIDE the\n// executable (dist/gtkx.node next to dist/app) — a real divergence, not an\n// oversight: that keeps two files, which is exactly what this epic set\n// out to stop doing.\nimport { join } from \"node:path\"\nimport type { Plugin } from \"rolldown\"\n\nexport const NATIVE_ASSET_KEY = \"gtkx-native.node\"\n\n/**\n * Where the shim gets the addon's bytes from — the only difference between\n * the two single-file artifacts:\n *\n * - `\"sea-asset\"`: from the SEA blob, via node:sea. Only works inside a\n *   real single executable.\n * - `\"inline\"`: from a base64 literal in the bundle itself, so the CJS\n *   file is self-contained under a plain `node app.cjs` — the same\n *   artifact minus the embedded Node runtime. Costs ~4/3 of the addon's\n *   size in source text (the addon is ~1.6 MB) and is parsed once at\n *   startup; the extraction and dlopen below are shared.\n */\nexport type NativeAddonSource = \"sea-asset\" | \"inline\"\n\nconst bytesExpression = (\n  source: NativeAddonSource,\n  assetKey: string,\n): string =>\n  source === \"sea-asset\"\n    ? `Buffer.from(require(\"node:sea\").getAsset(${JSON.stringify(assetKey)}))`\n    : `Buffer.from(__gtkxNativeBase64, \"base64\")`\n\nconst shimSource = (\n  source: NativeAddonSource,\n  assetKey: string,\n  base64: string,\n): string => `\nconst { createHash } = require(\"node:crypto\");\nconst { mkdirSync, existsSync, writeFileSync, renameSync } = require(\"node:fs\");\nconst { join } = require(\"node:path\");\nconst os = require(\"node:os\");\n${source === \"inline\" ? `const __gtkxNativeBase64 = ${JSON.stringify(base64)};` : \"\"}\n\nconst bytes = ${bytesExpression(source, assetKey)};\nconst hash = createHash(\"sha256\").update(bytes).digest(\"hex\").slice(0, 16);\nconst fileName = \"native-\" + hash + \".node\";\n\nconst candidateDirs = [\n  join(process.env.XDG_CACHE_HOME || join(os.homedir(), \".cache\"), \"react-native-gtkx-sea\"),\n  join(os.tmpdir(), \"react-native-gtkx-sea\"),\n];\n\nlet target;\nlet lastError;\nfor (const dir of candidateDirs) {\n  try {\n    mkdirSync(dir, { recursive: true });\n    const candidate = join(dir, fileName);\n    if (!existsSync(candidate)) {\n      const tmp = candidate + \".\" + process.pid + \".tmp\";\n      writeFileSync(tmp, bytes, { mode: 0o755 });\n      renameSync(tmp, candidate);\n    }\n    target = candidate;\n    break;\n  } catch (error) {\n    lastError = error;\n  }\n}\nif (!target) {\n  throw new Error(\n    \"react-native-gtkx: could not extract the native addon to a writable \" +\n      \"cache directory (tried \" + candidateDirs.join(\", \") + \"): \" + String(lastError),\n  );\n}\n\n// Not require(target): the require() available to a SEA's main script is\n// restricted to built-ins and embedded assets (verified — requiring an\n// arbitrary absolute path from here throws ERR_UNKNOWN_BUILTIN_MODULE, the\n// same error Node throws for an unrecognized built-in specifier). That\n// restriction doesn't apply to process.dlopen(), the lower-level\n// primitive require() itself uses for \".node\" files (Module._extensions\n// [\".node\"]) — it works on any real path, which is exactly what makes\n// this shim work at all. The \"inline\" build could use a plain require()\n// here, but shares dlopen() rather than branching: one code path that is\n// proven by both artifacts beats two, one of which is rarely exercised.\nconst nativeModule = { exports: {} };\nprocess.dlopen(nativeModule, target);\n// The vite path's own build (dist/bundle.js, gtkx's CLI plugin) calls\n// this immediately after loading the addon, before anything else touches\n// it; @gtkx/runtime's compiled JS never calls it itself (confirmed by\n// inspecting its dist — it only re-exports a handful of low-level\n// functions), so ordinary require() of the addon through Node's own\n// napi module registration must be relying on something dlopen() alone\n// does not trigger. Without this call the addon has no thread registered\n// as \"the Node environment's owner\" and the first GTK-driven callback\n// into JS panics: \"the Node environment was accessed from a thread it is\n// not installed on\" (reproduced and fixed by adding this line).\nnativeModule.exports.init();\nmodule.exports = nativeModule.exports;\n`\n\nexport type NativeAddonShimOptions = {\n  /** The bare specifier to replace, in practice \"@gtkx/native\". */\n  specifier: string\n  /** The app root — the shim's id lives here, see above. */\n  appRoot: string\n  /** Where the addon's bytes come from at runtime. */\n  source: NativeAddonSource\n  /** SEA asset key; unused when `source` is \"inline\". */\n  assetKey?: string\n  /** The addon's bytes; required when `source` is \"inline\". */\n  addonBytes?: Buffer\n}\n\n/**\n * Intercepts every import/require of `specifier` (an exact bare module\n * specifier, e.g. \"@gtkx/native\") and replaces it with the extraction shim\n * above. The real module never reaches the bundle graph — only its\n * re-exported surface, loaded from the extracted file at runtime.\n *\n * The shim is given an id inside `appRoot` with a `.cjs` extension rather\n * than a `\\0`-prefixed virtual one: the shim IS CommonJS (it assigns\n * `module.exports` so consumers' NAMED imports of the addon still resolve\n * through the bundler's interop), and a real directory is what lets any\n * specifier inside it resolve normally.\n */\nexport const nativeAddonShimPlugin = (\n  options: NativeAddonShimOptions,\n): Plugin => {\n  const { specifier, appRoot, source } = options\n  if (source === \"inline\" && !options.addonBytes) {\n    throw new Error('the \"inline\" native addon source needs addonBytes')\n  }\n  const shimId = join(appRoot, \"__gtkx-sea-native-shim.cjs\")\n  const contents = shimSource(\n    source,\n    options.assetKey ?? NATIVE_ASSET_KEY,\n    options.addonBytes?.toString(\"base64\") ?? \"\",\n  )\n  return {\n    name: \"gtkx-native-addon-shim\",\n    resolveId: (id) => (id === specifier ? shimId : null),\n    load: (id) => (id === shimId ? contents : null),\n  }\n}\n"]}

package/dist/sea/react-anchor-plugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "rolldown";
+export declare const reactAnchorPlugin: (appRoot: string) => Plugin;

package/dist/sea/react-anchor-plugin.js

@@ -0,0 +1,30 @@
+// react (and its jsx runtimes) must resolve to the exact same instance
+// @gtkx/react's reconciler uses — the reconciler and the app share one
+// React, and anchoring resolution at the app's own node_modules can pick
+// up a second copy (npm's peer-dependency auto-install, or a differently
+// hoisted layout). runner/host.ts hits the identical problem and solves it
+// the same way: resolve "react"/"react/jsx-runtime"/"react/jsx-dev-runtime"
+// from @gtkx/react's own location, not the app's.
+//
+// Confirmed necessary empirically, not just by analogy with host.ts:
+// without this plugin the built SEA threw React's "Invalid hook call"
+// (two React module instances in the bundle graph) — the bundler had
+// resolved the entry's top-level `import("react")` from the app root and
+// @gtkx/react's own internal `import "react"` from @gtkx/react's
+// directory, landing on two different files were the two roots not
+// deduplicated to the same node_modules/react.
+import { createRequire } from "node:module";
+const REACT_SPECIFIERS = new Set([
+    "react",
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime",
+]);
+export const reactAnchorPlugin = (appRoot) => {
+    const appRequire = createRequire(`${appRoot}/package.json`);
+    const fromGtkxReact = createRequire(appRequire.resolve("@gtkx/react"));
+    return {
+        name: "gtkx-react-anchor",
+        resolveId: (source) => REACT_SPECIFIERS.has(source) ? fromGtkxReact.resolve(source) : null,
+    };
+};
+//# sourceMappingURL=react-anchor-plugin.js.map

package/dist/sea/react-anchor-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-anchor-plugin.js","sourceRoot":"","sources":["../../src/sea/react-anchor-plugin.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,uEAAuE;AACvE,yEAAyE;AACzE,yEAAyE;AACzE,2EAA2E;AAC3E,4EAA4E;AAC5E,kDAAkD;AAClD,EAAE;AACF,qEAAqE;AACrE,sEAAsE;AACtE,qEAAqE;AACrE,yEAAyE;AACzE,iEAAiE;AACjE,mEAAmE;AACnE,+CAA+C;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAG3C,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC;IAC/B,OAAO;IACP,mBAAmB;IACnB,uBAAuB;CACxB,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,OAAe,EAAU,EAAE;IAC3D,MAAM,UAAU,GAAG,aAAa,CAAC,GAAG,OAAO,eAAe,CAAC,CAAA;IAC3D,MAAM,aAAa,GAAG,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAA;IACtE,OAAO;QACL,IAAI,EAAE,mBAAmB;QACzB,SAAS,EAAE,CAAC,MAAM,EAAE,EAAE,CACpB,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI;KACtE,CAAA;AACH,CAAC,CAAA","sourcesContent":["// react (and its jsx runtimes) must resolve to the exact same instance\n// @gtkx/react's reconciler uses — the reconciler and the app share one\n// React, and anchoring resolution at the app's own node_modules can pick\n// up a second copy (npm's peer-dependency auto-install, or a differently\n// hoisted layout). runner/host.ts hits the identical problem and solves it\n// the same way: resolve \"react\"/\"react/jsx-runtime\"/\"react/jsx-dev-runtime\"\n// from @gtkx/react's own location, not the app's.\n//\n// Confirmed necessary empirically, not just by analogy with host.ts:\n// without this plugin the built SEA threw React's \"Invalid hook call\"\n// (two React module instances in the bundle graph) — the bundler had\n// resolved the entry's top-level `import(\"react\")` from the app root and\n// @gtkx/react's own internal `import \"react\"` from @gtkx/react's\n// directory, landing on two different files were the two roots not\n// deduplicated to the same node_modules/react.\nimport { createRequire } from \"node:module\"\nimport type { Plugin } from \"rolldown\"\n\nconst REACT_SPECIFIERS = new Set([\n  \"react\",\n  \"react/jsx-runtime\",\n  \"react/jsx-dev-runtime\",\n])\n\nexport const reactAnchorPlugin = (appRoot: string): Plugin => {\n  const appRequire = createRequire(`${appRoot}/package.json`)\n  const fromGtkxReact = createRequire(appRequire.resolve(\"@gtkx/react\"))\n  return {\n    name: \"gtkx-react-anchor\",\n    resolveId: (source) =>\n      REACT_SPECIFIERS.has(source) ? fromGtkxReact.resolve(source) : null,\n  }\n}\n"]}

package/dist/style/index.d.ts

@@ -4,4 +4,5 @@ export { createCssRegistry, type CssFn, type CssRegistry } from "./registry";
 export { splitStyle } from "./split-style";
 export { absoluteFill, absoluteFillObject, compose, create, flatten, hairlineWidth, StyleSheet, } from "./style-sheet";
 export { textAlignToLabelProps, type LabelAlignProps, type TextAlign, } from "./text-align";
+export { composeTransform, IDENTITY_TRANSFORM, isIdentityTransform, isTranslationOnly, parseAngle, } from "./transform";
 export { visualStyleToCss } from "./visual-css";

package/dist/style/index.js

@@ -10,5 +10,6 @@ export { createCssRegistry } from "./registry";
 export { splitStyle } from "./split-style";
 export { absoluteFill, absoluteFillObject, compose, create, flatten, hairlineWidth, StyleSheet, } from "./style-sheet";
 export { textAlignToLabelProps, } from "./text-align";
+export { composeTransform, IDENTITY_TRANSFORM, isIdentityTransform, isTranslationOnly, parseAngle, } from "./transform";
 export { visualStyleToCss } from "./visual-css";
 //# sourceMappingURL=index.js.map

package/dist/style/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/style/index.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,8CAA8C;AAC9C,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,oEAAoE;AAEpE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,iBAAiB,EAAgC,MAAM,YAAY,CAAA;AAC5E,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,OAAO,EACP,MAAM,EACN,OAAO,EACP,aAAa,EACb,UAAU,GACX,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,qBAAqB,GAGtB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA","sourcesContent":["// Style pipeline: StyleSheet → flatten → splitStyle →\n// visualStyleToCss → memoized class registry.\n//\n// Everything exported here is pure (no bridge imports) and unit-testable on\n// any OS. The production registry that talks to the gtkx `css` helper lives\n// in ./registry.gtkx.ts and is imported directly by the components.\n\nexport { parseColor, PlatformColor } from \"./colors\"\nexport { resetDevWarnings } from \"./dev-warning\"\nexport { createCssRegistry, type CssFn, type CssRegistry } from \"./registry\"\nexport { splitStyle } from \"./split-style\"\nexport {\n  absoluteFill,\n  absoluteFillObject,\n  compose,\n  create,\n  flatten,\n  hairlineWidth,\n  StyleSheet,\n} from \"./style-sheet\"\nexport {\n  textAlignToLabelProps,\n  type LabelAlignProps,\n  type TextAlign,\n} from \"./text-align\"\nexport { visualStyleToCss } from \"./visual-css\"\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/style/index.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,8CAA8C;AAC9C,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,oEAAoE;AAEpE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,iBAAiB,EAAgC,MAAM,YAAY,CAAA;AAC5E,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,OAAO,EACP,MAAM,EACN,OAAO,EACP,aAAa,EACb,UAAU,GACX,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,qBAAqB,GAGtB,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,UAAU,GACX,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA","sourcesContent":["// Style pipeline: StyleSheet → flatten → splitStyle →\n// visualStyleToCss → memoized class registry.\n//\n// Everything exported here is pure (no bridge imports) and unit-testable on\n// any OS. The production registry that talks to the gtkx `css` helper lives\n// in ./registry.gtkx.ts and is imported directly by the components.\n\nexport { parseColor, PlatformColor } from \"./colors\"\nexport { resetDevWarnings } from \"./dev-warning\"\nexport { createCssRegistry, type CssFn, type CssRegistry } from \"./registry\"\nexport { splitStyle } from \"./split-style\"\nexport {\n  absoluteFill,\n  absoluteFillObject,\n  compose,\n  create,\n  flatten,\n  hairlineWidth,\n  StyleSheet,\n} from \"./style-sheet\"\nexport {\n  textAlignToLabelProps,\n  type LabelAlignProps,\n  type TextAlign,\n} from \"./text-align\"\nexport {\n  composeTransform,\n  IDENTITY_TRANSFORM,\n  isIdentityTransform,\n  isTranslationOnly,\n  parseAngle,\n} from \"./transform\"\nexport { visualStyleToCss } from \"./visual-css\"\n"]}

package/dist/style/split-style.js

@@ -47,8 +47,8 @@ const LAYOUT_KEYS = {
     top: true,
     width: true,
 };
-// Note: `transform` is visual by contract — it is applied by the layout
-// engine through Fixed.Child matrices, not through CSS, and is passed
+// Note: `transform` is visual by contract — it is applied as the
+// GskTransform of the child's allocation, not through CSS, and is passed
 // through here untouched.
 const VISUAL_KEYS = {
     backgroundColor: true,