@gtkx/cli 0.18.0 → 0.18.1

package/dist/builder.d.ts

@@ -5,6 +5,28 @@ import { type InlineConfig } from "vite";
 export type BuildOptions = {
     /** Path to the entry file (e.g., "src/index.tsx") */
     entry: string;
+    /**
+     * Base path for resolving asset imports at runtime, relative to the
+     * executable directory.
+     *
+     * When set, asset imports resolve to
+     * `path.join(path.dirname(process.execPath), assetBase, filename)`.
+     * This is useful for FHS-compliant packaging where assets live under
+     * a `share/` directory rather than next to the binary.
+     *
+     * When omitted, assets resolve relative to the bundle via
+     * `import.meta.url`, which works when assets are co-located with
+     * the executable (e.g., in `bin/assets/`).
+     *
+     * @example
+     * ```ts
+     * await build({
+     *     entry: "./src/index.tsx",
+     *     assetBase: "../share/my-app",
+     * });
+     * ```
+     */
+    assetBase?: string;
     /** Additional Vite configuration */
     vite?: InlineConfig;
 };
@@ -12,12 +34,9 @@ export type BuildOptions = {
  * Builds a GTKX application for production using Vite's SSR build mode.
  *
  * Produces a single minified ESM bundle at `dist/bundle.js` with all
- * dependencies bundled except the native module (`@gtkx/native`).
- *
- * The native module is externalized and its import path is resolved to
- * an absolute path at build time. This ensures the bundle works under
- * strict package managers (pnpm) where transitive dependencies are not
- * directly resolvable from the bundle location.
+ * dependencies inlined. The native `.node` binary is copied into the
+ * output directory as `gtkx.node`, making the bundle fully self-contained
+ * with no `node_modules` dependency at runtime.
  *
  * @param options - Build configuration including entry point and Vite options
  *

package/dist/builder.js

@@ -1,18 +1,14 @@
-import { createRequire } from "node:module";
-import { join } from "node:path";
 import { build as viteBuild } from "vite";
 import { gtkxAssets } from "./vite-plugin-gtkx-assets.js";
-const NATIVE_PACKAGE_RE = /^@gtkx\/native(-linux-(x64|arm64))?$/;
+import { gtkxBuiltUrl } from "./vite-plugin-gtkx-built-url.js";
+import { gtkxNative } from "./vite-plugin-gtkx-native.js";
 /**
  * Builds a GTKX application for production using Vite's SSR build mode.
  *
  * Produces a single minified ESM bundle at `dist/bundle.js` with all
- * dependencies bundled except the native module (`@gtkx/native`).
- *
- * The native module is externalized and its import path is resolved to
- * an absolute path at build time. This ensures the bundle works under
- * strict package managers (pnpm) where transitive dependencies are not
- * directly resolvable from the bundle location.
+ * dependencies inlined. The native `.node` binary is copied into the
+ * output directory as `gtkx.node`, making the bundle fully self-contained
+ * with no `node_modules` dependency at runtime.
  *
  * @param options - Build configuration including entry point and Vite options
  *
@@ -29,12 +25,11 @@ const NATIVE_PACKAGE_RE = /^@gtkx\/native(-linux-(x64|arm64))?$/;
  * @see {@link BuildOptions} for configuration options
  */
 export const build = async (options) => {
-    const { entry, vite: viteConfig } = options;
+    const { entry, assetBase, vite: viteConfig } = options;
     const root = viteConfig?.root ?? process.cwd();
-    const projectRequire = createRequire(join(root, "package.json"));
     await viteBuild({
         ...viteConfig,
-        plugins: [...(viteConfig?.plugins ?? []), gtkxAssets()],
+        plugins: [...(viteConfig?.plugins ?? []), gtkxAssets(), gtkxBuiltUrl(assetBase), gtkxNative(root)],
         build: {
             ...viteConfig?.build,
             ssr: entry,
@@ -47,17 +42,6 @@ export const build = async (options) => {
                 output: {
                     ...(viteConfig?.build?.rollupOptions?.output ?? {}),
                     entryFileNames: "bundle.js",
-                    paths: (id) => {
-                        if (NATIVE_PACKAGE_RE.test(id)) {
-                            try {
-                                return projectRequire.resolve(id);
-                            }
-                            catch {
-                                return id;
-                            }
-                        }
-                        return id;
-                    },
                 },
             },
         },
@@ -68,17 +52,9 @@ export const build = async (options) => {
         ssr: {
             ...viteConfig?.ssr,
             noExternal: true,
-            external: ["@gtkx/native", "@gtkx/native-linux-x64", "@gtkx/native-linux-arm64"],
         },
         experimental: {
             ...viteConfig?.experimental,
-            renderBuiltUrl(filename, { type }) {
-                if (type === "asset") {
-                    return {
-                        runtime: `new URL(${JSON.stringify(`./${filename}`)}, import.meta.url).pathname`,
-                    };
-                }
-            },
         },
     });
 };

package/dist/cli.js

@@ -61,12 +61,17 @@ const buildCmd = defineCommand({
             description: "Entry file (default: src/index.tsx)",
             required: false,
         },
+        "asset-base": {
+            type: "string",
+            description: "Asset base path relative to executable directory (e.g., ../share/my-app)",
+        },
     },
     async run({ args }) {
         const entry = resolve(process.cwd(), args.entry ?? "src/index.tsx");
         console.log(`[gtkx] Building ${entry}`);
         await build({
             entry,
+            assetBase: args["asset-base"],
             vite: {
                 root: process.cwd(),
             },

package/dist/vite-plugin-gtkx-built-url.d.ts

@@ -0,0 +1,17 @@
+import type { Plugin } from "vite";
+/**
+ * Vite plugin that configures `renderBuiltUrl` for resolving asset imports
+ * to filesystem paths at runtime.
+ *
+ * When `assetBase` is provided, assets resolve relative to the executable
+ * directory using `path.join(path.dirname(process.execPath), assetBase, filename)`.
+ * This supports FHS-compliant layouts where assets live in `../share/<app>/`.
+ *
+ * When `assetBase` is omitted, assets resolve relative to the bundle file
+ * via `import.meta.url`, which works when assets are co-located with the
+ * executable.
+ *
+ * Only applies when the user has not already configured
+ * `experimental.renderBuiltUrl` in their Vite config.
+ */
+export declare function gtkxBuiltUrl(assetBase?: string): Plugin;

package/dist/vite-plugin-gtkx-built-url.js

@@ -0,0 +1,42 @@
+/**
+ * Vite plugin that configures `renderBuiltUrl` for resolving asset imports
+ * to filesystem paths at runtime.
+ *
+ * When `assetBase` is provided, assets resolve relative to the executable
+ * directory using `path.join(path.dirname(process.execPath), assetBase, filename)`.
+ * This supports FHS-compliant layouts where assets live in `../share/<app>/`.
+ *
+ * When `assetBase` is omitted, assets resolve relative to the bundle file
+ * via `import.meta.url`, which works when assets are co-located with the
+ * executable.
+ *
+ * Only applies when the user has not already configured
+ * `experimental.renderBuiltUrl` in their Vite config.
+ */
+export function gtkxBuiltUrl(assetBase) {
+    return {
+        name: "gtkx:built-url",
+        config(userConfig) {
+            if (userConfig.experimental?.renderBuiltUrl) {
+                return;
+            }
+            return {
+                experimental: {
+                    renderBuiltUrl(filename, { type }) {
+                        if (type !== "asset") {
+                            return;
+                        }
+                        if (assetBase) {
+                            return {
+                                runtime: `require("path").join(require("path").dirname(process.execPath),${JSON.stringify(assetBase)},${JSON.stringify(filename)})`,
+                            };
+                        }
+                        return {
+                            runtime: `new URL(${JSON.stringify(`./${filename}`)}, import.meta.url).pathname`,
+                        };
+                    },
+                },
+            };
+        },
+    };
+}

package/dist/vite-plugin-gtkx-native.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from "vite";
+/**
+ * Vite plugin that embeds the native `.node` binary into the build output.
+ *
+ * During production builds, resolves the platform-specific `.node` binary,
+ * copies it into the output directory as `gtkx.node`, and transforms the
+ * `loadNativeBinding` function in `@gtkx/native` to load `./gtkx.node`
+ * directly. This makes the bundle self-contained with no `node_modules`
+ * dependency at runtime.
+ *
+ * @param root - Project root directory used to resolve native packages
+ */
+export declare function gtkxNative(root: string): Plugin;

package/dist/vite-plugin-gtkx-native.js

@@ -0,0 +1,52 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { arch, platform } from "node:os";
+import { join } from "node:path";
+const LOAD_NATIVE_BINDING_RE = /function loadNativeBinding\(\) \{[\s\S]*?\n\}/;
+const NODE_OS_IMPORT_RE = /import\s*\{[^}]*\}\s*from\s*["']node:os["'];?\n?/;
+/**
+ * Vite plugin that embeds the native `.node` binary into the build output.
+ *
+ * During production builds, resolves the platform-specific `.node` binary,
+ * copies it into the output directory as `gtkx.node`, and transforms the
+ * `loadNativeBinding` function in `@gtkx/native` to load `./gtkx.node`
+ * directly. This makes the bundle self-contained with no `node_modules`
+ * dependency at runtime.
+ *
+ * @param root - Project root directory used to resolve native packages
+ */
+export function gtkxNative(root) {
+    const projectRequire = createRequire(join(root, "package.json"));
+    let nativeIndexPath;
+    return {
+        name: "gtkx:native",
+        enforce: "pre",
+        buildStart() {
+            const currentPlatform = platform();
+            const currentArch = arch();
+            const packageName = `@gtkx/native-linux-${currentArch}`;
+            if (currentPlatform !== "linux") {
+                throw new Error(`Unsupported build platform: ${currentPlatform}. Only Linux is supported.`);
+            }
+            if (currentArch !== "x64" && currentArch !== "arm64") {
+                throw new Error(`Unsupported build architecture: ${currentArch}. Only x64 and arm64 are supported.`);
+            }
+            nativeIndexPath = projectRequire.resolve("@gtkx/native");
+            const nodePath = projectRequire.resolve(`${packageName}/index.node`);
+            const source = readFileSync(nodePath);
+            this.emitFile({
+                type: "asset",
+                fileName: "gtkx.node",
+                source,
+            });
+        },
+        transform(code, id) {
+            if (id !== nativeIndexPath) {
+                return;
+            }
+            return code
+                .replace(NODE_OS_IMPORT_RE, "")
+                .replace(LOAD_NATIVE_BINDING_RE, 'function loadNativeBinding() { return require("./gtkx.node"); }');
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/cli",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "description": "CLI for GTKX - create and develop GTK4 React applications",
   "keywords": [
     "gtkx",
@@ -62,19 +62,19 @@
     "ejs": "^4.0.1",
     "react-refresh": "^0.18.0",
     "vite": "^7.3.1",
-    "@gtkx/ffi": "0.18.0",
-    "@gtkx/mcp": "0.18.0",
-    "@gtkx/react": "0.18.0"
+    "@gtkx/ffi": "0.18.1",
+    "@gtkx/mcp": "0.18.1",
+    "@gtkx/react": "0.18.1"
   },
   "devDependencies": {
     "@types/ejs": "^3.1.5",
     "@types/react-refresh": "^0.14.7",
     "memfs": "^4.56.10",
-    "@gtkx/testing": "0.18.0"
+    "@gtkx/testing": "0.18.1"
   },
   "peerDependencies": {
     "react": "^19",
-    "@gtkx/testing": "0.18.0"
+    "@gtkx/testing": "0.18.1"
   },
   "peerDependenciesMeta": {
     "@gtkx/testing": {