@gjsify/cli 0.4.27 → 0.4.29

package/lib/utils/normalize-bundler-options.js

@@ -2,10 +2,46 @@
 // field on `.gjsifyrc.js` / `package.json#gjsify` into the equivalent
 // `bundler?: RolldownOptions` shape. Logs a single warning per build.
 //
-// Drop in 0.5.0.
+// Also handles the top-level `bundler.define` alias: Rolldown reads
+// `transform.define`, not a top-level `define`. A user who flat-renames
+// `esbuild: { define: {...} }` → `bundler: { define: {...} }` puts `define`
+// at the top level where Rolldown silently ignores it, causing
+// `ReferenceError: <TOKEN> is not defined` at GJS load time. We auto-map
+// top-level `bundler.define` into `bundler.transform.define` and emit a
+// one-time warning so the user can correct their config.
+//
+// Drop `esbuild` shim in 0.5.0; the `bundler.define` alias is permanent.
 let warnedOnce = false;
+let warnedDefineOnce = false;
 export function normalizeBundlerOptions(configData) {
-    const fromBundler = (configData.bundler ?? {});
+    const raw = (configData.bundler ?? {});
+    // --- Top-level bundler.define alias ------------------------------------------
+    // Rolldown only reads `transform.define`; a top-level `define` key is silently
+    // ignored. Detect it, warn once, and move it into `transform.define` so the
+    // user's flat esbuild→bundler rename of `define` Just Works.
+    let fromBundler = raw;
+    if (typeof raw['define'] === 'object' &&
+        raw['define'] !== null) {
+        if (!warnedDefineOnce) {
+            warnedDefineOnce = true;
+            // eslint-disable-next-line no-console
+            console.warn("[gjsify] WARNING: 'bundler.define' is not a valid Rolldown option and would be " +
+                "silently ignored — it has been auto-mapped to 'bundler.transform.define'. " +
+                "Move 'define' under 'bundler.transform.define' in your config to suppress " +
+                'this warning and avoid a ReferenceError at GJS load time.');
+        }
+        const { define: topLevelDefine, ...rest } = raw;
+        fromBundler = {
+            ...rest,
+            transform: {
+                ...rest.transform,
+                define: {
+                    ...topLevelDefine,
+                    ...rest.transform?.define,
+                },
+            },
+        };
+    }
     if (!configData.esbuild)
         return fromBundler;
     if (!warnedOnce) {
@@ -22,19 +58,19 @@ export function normalizeBundlerOptions(configData) {
     // user-provided config and `input` must survive the merge.
     const out = { ...fromEsbuild, ...fromBundler };
     if (fromEsbuild.output || fromBundler.output) {
-        out.output = { ...(fromEsbuild.output ?? {}), ...(fromBundler.output ?? {}) };
+        out.output = { ...fromEsbuild.output, ...fromBundler.output };
     }
     if (fromEsbuild.transform || fromBundler.transform) {
-        out.transform = { ...(fromEsbuild.transform ?? {}), ...(fromBundler.transform ?? {}) };
+        out.transform = { ...fromEsbuild.transform, ...fromBundler.transform };
         if (fromEsbuild.transform?.define || fromBundler.transform?.define) {
             out.transform.define = {
-                ...(fromEsbuild.transform?.define ?? {}),
-                ...(fromBundler.transform?.define ?? {}),
+                ...fromEsbuild.transform?.define,
+                ...fromBundler.transform?.define,
             };
         }
     }
     if (fromEsbuild.resolve || fromBundler.resolve) {
-        out.resolve = { ...(fromEsbuild.resolve ?? {}), ...(fromBundler.resolve ?? {}) };
+        out.resolve = { ...fromEsbuild.resolve, ...fromBundler.resolve };
     }
     return out;
 }
@@ -54,10 +90,7 @@ function legacyEsbuildToRolldown(esb) {
         output.minify = esb.minify;
     if (esb.sourcemap !== undefined) {
         // esbuild has 'external' / 'both' which Rolldown doesn't — coerce to boolean.
-        output.sourcemap =
-            esb.sourcemap === 'inline'
-                ? 'inline'
-                : Boolean(esb.sourcemap);
+        output.sourcemap = esb.sourcemap === 'inline' ? 'inline' : Boolean(esb.sourcemap);
     }
     if (esb.banner?.js !== undefined)
         output.banner = esb.banner.js;
@@ -80,10 +113,12 @@ function legacyEsbuildToRolldown(esb) {
         out.transform = transform;
     if (Object.keys(resolve).length > 0)
         out.resolve = resolve;
-    // Discarded silently:
+    // Discarded (handled elsewhere):
     //   esb.inject  — esbuild's array-of-side-effect-files; surfaced at the
     //                 CLI layer instead, via input expansion.
-    //   esb.loader  — Rolldown infers module types from extensions natively.
+    //   esb.loader  — replaced by top-level `gjsify.loaders` (see ConfigData);
+    //                 migration: `esbuild.loader: { '.png': 'dataurl', '.glsl': 'text' }`
+    //                 → `loaders: { '.png': 'dataurl', '.glsl': 'text' }`.
     return out;
 }
 /**
@@ -108,16 +143,16 @@ export function mergeBundlerOptions(base, overrides) {
     const { input: _ignoredInput, external: _ignoredExternal, ...overridesRest } = overrides;
     const out = { ...base, ...overridesRest };
     if (base.output || overrides.output) {
-        out.output = { ...(base.output ?? {}), ...(overrides.output ?? {}) };
+        out.output = { ...base.output, ...overrides.output };
     }
     if (base.transform || overrides.transform) {
-        out.transform = { ...(base.transform ?? {}), ...(overrides.transform ?? {}) };
+        out.transform = { ...base.transform, ...overrides.transform };
         if (base.transform?.define || overrides.transform?.define) {
-            out.transform.define = { ...(base.transform?.define ?? {}), ...(overrides.transform?.define ?? {}) };
+            out.transform.define = { ...base.transform?.define, ...overrides.transform?.define };
         }
     }
     if (base.resolve || overrides.resolve) {
-        out.resolve = { ...(base.resolve ?? {}), ...(overrides.resolve ?? {}) };
+        out.resolve = { ...base.resolve, ...overrides.resolve };
     }
     return out;
 }

package/lib/utils/oxc-resolve.d.ts

@@ -0,0 +1,63 @@
+export type OxcTool = 'oxlint' | 'oxfmt';
+/**
+ * Resolve the absolute path to a tool's Node ESM launcher
+ * (`node_modules/<tool>/bin/<tool>`). Walks cwd → workspace-root → parents.
+ *
+ * Throws {@link OxcNotFoundError} with a clear install hint when not found.
+ */
+export declare function findOxcLauncher(tool: OxcTool, cwd?: string): string;
+export declare class OxcNotFoundError extends Error {
+    tool: OxcTool;
+    cwd: string;
+    constructor(tool: OxcTool, cwd: string);
+}
+/**
+ * Walk up from a starting directory to find the nearest oxlint config
+ * (`.oxlintrc.json`). Returns absolute path or null.
+ */
+export declare function findOxlintConfig(cwd?: string): string | null;
+/**
+ * Walk up from a starting directory to find the nearest oxfmt config
+ * (`.oxfmtrc` / `.oxfmtrc.json`). Returns absolute path or null.
+ */
+export declare function findOxfmtConfig(cwd?: string): string | null;
+export interface RunOxcOptions {
+    cwd?: string;
+    verbose?: boolean;
+}
+/**
+ * Spawn an oxc tool (oxlint / oxfmt) via its Node ESM launcher. Inherits
+ * stdio so the tool's own output (diagnostics, reformatted files, summary
+ * lines) reaches the user.
+ *
+ * The launcher is run with the current Node executable (`process.execPath`)
+ * so the JS plugin host is available — required for oxlint's `jsPlugins`.
+ *
+ * Returns the exit code; never throws on non-zero exit (callers check it).
+ */
+export declare function runOxc(tool: OxcTool, args: string[], opts?: RunOxcOptions): Promise<number>;
+/** Convenience wrappers. */
+export declare function runOxlint(args: string[], opts?: RunOxcOptions): Promise<number>;
+export declare function runOxfmt(args: string[], opts?: RunOxcOptions): Promise<number>;
+/**
+ * Lazy-load the embedded `.oxlintrc.json` scaffold template. The
+ * static-read-inliner matches this `readFileSync(new URL(<lit>,
+ * import.meta.url), 'utf-8')` shape at build time and inlines the file into
+ * the GJS bundle, so the template is available without runtime file I/O
+ * against the install dir. (Same mechanism the old `loadBiomeTemplate()`
+ * relied on — the shape must stay exactly this for the inliner to fire.)
+ */
+export declare function loadOxlintTemplate(): string;
+/** Lazy-load the embedded `.oxfmtrc` scaffold template (same inliner shape). */
+export declare function loadOxfmtTemplate(): string;
+/** Helper for callers to surface the install hint to the user cleanly. */
+export declare function printOxcNotFound(err: OxcNotFoundError): void;
+/**
+ * Has the given oxc tool's npm package (or its companion) been declared in the
+ * project's dependencies? Useful as a cheap pre-flight check — `gjsify flatpak
+ * init`'s post-format hook uses this to decide whether to auto-format outputs.
+ *
+ * Checks for `oxfmt` by default (the formatter), since that is what the
+ * post-format hook would invoke.
+ */
+export declare function hasOxcDevDep(cwd?: string, tool?: OxcTool): boolean;

package/lib/utils/oxc-resolve.js

@@ -0,0 +1,264 @@
+// oxc (oxlint + oxfmt) resolution + spawn helpers.
+//
+// Replaces the former `biome-resolve.ts`. oxc ships its tools differently
+// from Biome:
+//
+//   - The user-facing npm packages `oxlint` and `oxfmt` are thin Node ESM
+//     launchers (`bin/oxlint` → `dist/cli.js`, `bin/oxfmt` → `dist/cli.js`).
+//   - The actual native code lives in per-platform NAPI binding packages
+//     (`@oxlint/binding-<target>`, `@oxfmt/binding-<target>`, e.g.
+//     `@oxlint/binding-linux-x64-gnu`), declared as optionalDependencies of
+//     the launcher package and loaded via napi-rs's `requireNative()`.
+//
+// Unlike Biome — whose per-platform package was a single self-contained Rust
+// binary we could spawn directly, skipping its Node launcher — oxlint's JS
+// plugin API (used by the internal `oxlint-plugin-gjsify` rule) lives in the
+// JS launcher (`dist/cli.js`). The plugin host loads `.ts`/`.js` plugin files
+// at runtime, so a configured plugin REQUIRES spawning oxlint through its Node
+// launcher rather than calling a bare binary. We therefore resolve and spawn
+// the package launcher with `node` for both tools — uniform and correct for
+// the plugin case.
+//
+// Resolution order (workspace-aware) for each launcher:
+//   1. Project's local node_modules (cwd)
+//   2. Workspace root's node_modules (walk up via findWorkspaceRoot)
+//   3. Parent dirs as a last resort
+//   4. ENOENT → install hint
+//
+// We still reuse Biome's platform/arch/musl detection — it's used to name the
+// expected NAPI binding package in the not-found install hint, so the user
+// knows exactly which optionalDependency npm failed to place.
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { findWorkspaceRoot } from './workspace-root.js';
+/**
+ * Map Node.js `process.platform` + `arch` (+ musl on Linux) to the
+ * napi-rs binding-package suffix oxc uses, e.g. `linux-x64-gnu`,
+ * `linux-x64-musl`, `darwin-arm64`, `win32-x64-msvc`.
+ *
+ * Mirrors biome-resolve's platform detection (same musl probe), adapted to
+ * oxc's napi-rs target naming (gnu/musl libc suffix on Linux, -msvc on
+ * Windows).
+ */
+function oxcBindingSuffix() {
+    const platform = process.platform;
+    const arch = process.arch;
+    let plat;
+    if (platform === 'linux')
+        plat = 'linux';
+    else if (platform === 'darwin')
+        plat = 'darwin';
+    else if (platform === 'win32')
+        plat = 'win32';
+    else
+        throw new Error(`[gjsify oxc] Unsupported platform: ${platform}`);
+    let a;
+    if (arch === 'x64')
+        a = 'x64';
+    else if (arch === 'arm64')
+        a = 'arm64';
+    else
+        throw new Error(`[gjsify oxc] Unsupported arch on ${plat}: ${arch}`);
+    if (plat === 'linux') {
+        // musl detection on Linux — oxc ships separate musl/gnu bindings.
+        // Same approach as biome's launcher: probe for the musl loader.
+        // glibc systems have `/lib/ld-linux-*`, musl has `/lib/ld-musl-*`.
+        let libc = 'gnu';
+        try {
+            const { readdirSync } = require('node:fs');
+            const libEntries = readdirSync('/lib');
+            if (libEntries.some((e) => e.startsWith('ld-musl-'))) {
+                libc = 'musl';
+            }
+        }
+        catch {
+            // /lib unreadable — fall through, glibc is the safer default
+        }
+        return `${plat}-${a}-${libc}`;
+    }
+    if (plat === 'win32')
+        return `${plat}-${a}-msvc`;
+    // darwin
+    return `${plat}-${a}`;
+}
+/** NAPI binding scope per tool: `@oxlint/binding-*` / `@oxfmt/binding-*`. */
+function bindingPackageName(tool) {
+    const scope = tool === 'oxlint' ? '@oxlint' : '@oxfmt';
+    return `${scope}/binding-${oxcBindingSuffix()}`;
+}
+/**
+ * Search a starting directory's `node_modules/<pkg>/<relPath>` and return the
+ * absolute path if it exists, else null.
+ */
+function probeNodeModules(dir, pkg, relPath) {
+    const candidate = join(dir, 'node_modules', pkg, relPath);
+    return existsSync(candidate) ? candidate : null;
+}
+/**
+ * Resolve the absolute path to a tool's Node ESM launcher
+ * (`node_modules/<tool>/bin/<tool>`). Walks cwd → workspace-root → parents.
+ *
+ * Throws {@link OxcNotFoundError} with a clear install hint when not found.
+ */
+export function findOxcLauncher(tool, cwd = process.cwd()) {
+    const relPath = join('bin', tool);
+    // 1. Local node_modules
+    const local = probeNodeModules(cwd, tool, relPath);
+    if (local)
+        return local;
+    // 2. Walk up to workspace root, probe its node_modules
+    const wsRoot = findWorkspaceRoot(cwd);
+    if (wsRoot && wsRoot !== cwd) {
+        const fromRoot = probeNodeModules(wsRoot, tool, relPath);
+        if (fromRoot)
+            return fromRoot;
+    }
+    // 3. Walk parent dirs as a last resort (nested-without-workspace setups)
+    let dir = resolve(cwd, '..');
+    for (let i = 0; i < 6; i++) {
+        const found = probeNodeModules(dir, tool, relPath);
+        if (found)
+            return found;
+        const parent = resolve(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new OxcNotFoundError(tool, cwd);
+}
+export class OxcNotFoundError extends Error {
+    tool;
+    cwd;
+    constructor(tool, cwd) {
+        const binding = (() => {
+            try {
+                return bindingPackageName(tool);
+            }
+            catch {
+                return `@${tool === 'oxlint' ? 'oxlint' : 'oxfmt'}/binding-<platform>`;
+            }
+        })();
+        super(`[gjsify oxc] ${tool} not found.\n` +
+            `  Expected: ${tool}/bin/${tool} in node_modules of ${cwd} or any workspace root above it.\n` +
+            `  Install it via: gjsify install -D ${tool}\n` +
+            `  (this adds ${tool} to devDependencies; the matching ${binding} ` +
+            `napi binding lands automatically as an optionalDependency.)`);
+        this.tool = tool;
+        this.cwd = cwd;
+        this.name = 'OxcNotFoundError';
+    }
+}
+/**
+ * Walk up from a starting directory to find the nearest oxlint config
+ * (`.oxlintrc.json`). Returns absolute path or null.
+ */
+export function findOxlintConfig(cwd = process.cwd()) {
+    return findConfigFile(cwd, ['.oxlintrc.json']);
+}
+/**
+ * Walk up from a starting directory to find the nearest oxfmt config
+ * (`.oxfmtrc` / `.oxfmtrc.json`). Returns absolute path or null.
+ */
+export function findOxfmtConfig(cwd = process.cwd()) {
+    return findConfigFile(cwd, ['.oxfmtrc', '.oxfmtrc.json']);
+}
+function findConfigFile(cwd, names) {
+    let dir = cwd;
+    for (let i = 0; i < 12; i++) {
+        for (const name of names) {
+            const path = join(dir, name);
+            if (existsSync(path))
+                return path;
+        }
+        const parent = resolve(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Spawn an oxc tool (oxlint / oxfmt) via its Node ESM launcher. Inherits
+ * stdio so the tool's own output (diagnostics, reformatted files, summary
+ * lines) reaches the user.
+ *
+ * The launcher is run with the current Node executable (`process.execPath`)
+ * so the JS plugin host is available — required for oxlint's `jsPlugins`.
+ *
+ * Returns the exit code; never throws on non-zero exit (callers check it).
+ */
+export function runOxc(tool, args, opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const launcher = findOxcLauncher(tool, cwd);
+    const node = process.execPath || 'node';
+    if (opts.verbose) {
+        console.log(`[gjsify oxc] ${node} ${launcher} ${args.join(' ')}`);
+    }
+    return new Promise((res, rej) => {
+        const spawnOpts = { stdio: 'inherit', cwd };
+        const child = spawn(node, [launcher, ...args], spawnOpts);
+        child.on('error', (err) => {
+            if (err.code === 'ENOENT') {
+                rej(new OxcNotFoundError(tool, cwd));
+            }
+            else {
+                rej(err);
+            }
+        });
+        child.on('exit', (code, signal) => {
+            if (signal) {
+                console.error(`[gjsify oxc] ${tool} terminated by signal ${signal}`);
+                res(1);
+                return;
+            }
+            res(code ?? 0);
+        });
+    });
+}
+/** Convenience wrappers. */
+export function runOxlint(args, opts = {}) {
+    return runOxc('oxlint', args, opts);
+}
+export function runOxfmt(args, opts = {}) {
+    return runOxc('oxfmt', args, opts);
+}
+/**
+ * Lazy-load the embedded `.oxlintrc.json` scaffold template. The
+ * static-read-inliner matches this `readFileSync(new URL(<lit>,
+ * import.meta.url), 'utf-8')` shape at build time and inlines the file into
+ * the GJS bundle, so the template is available without runtime file I/O
+ * against the install dir. (Same mechanism the old `loadBiomeTemplate()`
+ * relied on — the shape must stay exactly this for the inliner to fire.)
+ */
+export function loadOxlintTemplate() {
+    return readFileSync(new URL('../templates/oxlintrc.json.tmpl', import.meta.url), 'utf-8');
+}
+/** Lazy-load the embedded `.oxfmtrc` scaffold template (same inliner shape). */
+export function loadOxfmtTemplate() {
+    return readFileSync(new URL('../templates/oxfmtrc.tmpl', import.meta.url), 'utf-8');
+}
+/** Helper for callers to surface the install hint to the user cleanly. */
+export function printOxcNotFound(err) {
+    console.error(err.message);
+}
+/**
+ * Has the given oxc tool's npm package (or its companion) been declared in the
+ * project's dependencies? Useful as a cheap pre-flight check — `gjsify flatpak
+ * init`'s post-format hook uses this to decide whether to auto-format outputs.
+ *
+ * Checks for `oxfmt` by default (the formatter), since that is what the
+ * post-format hook would invoke.
+ */
+export function hasOxcDevDep(cwd = process.cwd(), tool = 'oxfmt') {
+    const pkgPath = join(cwd, 'package.json');
+    if (!existsSync(pkgPath))
+        return false;
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return Boolean(pkg?.devDependencies?.[tool] || pkg?.dependencies?.[tool]);
+    }
+    catch {
+        return false;
+    }
+}

package/lib/utils/pkg-json-edit.js

@@ -93,12 +93,7 @@ export function defaultRangeFromVersion(version) {
 }
 function sortKnownDepFields(pkg) {
     const out = { ...pkg };
-    for (const kind of [
-        'dependencies',
-        'devDependencies',
-        'peerDependencies',
-        'optionalDependencies',
-    ]) {
+    for (const kind of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
         const block = out[kind];
         if (!block)
             continue;

package/lib/utils/run-gjs.js

@@ -30,10 +30,7 @@ export function computeNativeEnvForBundle(bundlePath, cwd = process.cwd()) {
     const cwdPackages = detectNativePackages(cwd);
     const bundlePackages = detectNativePackages(dirname(resolvedBundle));
     const seen = new Set(cwdPackages.map((p) => p.name));
-    const nativePackages = [
-        ...cwdPackages,
-        ...bundlePackages.filter((p) => !seen.has(p.name)),
-    ];
+    const nativePackages = [...cwdPackages, ...bundlePackages.filter((p) => !seen.has(p.name))];
     const env = buildNativeEnv(nativePackages);
     const envPrefix = Object.entries(env)
         .filter(([, value]) => value !== undefined && value !== '')

package/lib/utils/run-lifecycle-script.js

@@ -42,9 +42,7 @@ export async function runLifecycleScript(wsDir, pkg, name, opts = {}) {
     // tools like biome / esbuild / tsc lose ANSI color in piped contexts
     // (CI logs, redirected output) because `process.stdout.isTTY` is
     // false for the spawned child.
-    const colorEnv = process.env.FORCE_COLOR !== undefined || process.env.NO_COLOR !== undefined
-        ? {}
-        : { FORCE_COLOR: '1' };
+    const colorEnv = process.env.FORCE_COLOR !== undefined || process.env.NO_COLOR !== undefined ? {} : { FORCE_COLOR: '1' };
     const env = {
         ...process.env,
         ...colorEnv,
@@ -52,7 +50,7 @@ export async function runLifecycleScript(wsDir, pkg, name, opts = {}) {
         npm_lifecycle_event: name,
         npm_package_name: pkg.name ?? '',
         npm_package_version: pkg.version ?? '',
-        ...(opts.env ?? {}),
+        ...opts.env,
     };
     // `'inherit-stderr'` is our extension on top of node's stdio modes —
     // child stdin inherits, child stdout → parent's stderr (fd 2), child
@@ -60,9 +58,7 @@ export async function runLifecycleScript(wsDir, pkg, name, opts = {}) {
     // prepack's log lines don't get interleaved with the JSON we emit on
     // parent stdout. `spawn`'s `stdio` accepts numeric fds in array form
     // and routes the child's matching stream to that fd.
-    const stdioConfig = opts.stdio === 'inherit-stderr'
-        ? ['inherit', 2, 2]
-        : (opts.stdio ?? 'inherit');
+    const stdioConfig = opts.stdio === 'inherit-stderr' ? ['inherit', 2, 2] : (opts.stdio ?? 'inherit');
     await new Promise((resolveOk, reject) => {
         const child = spawn(literal, [], {
             cwd: wsDir,

package/lib/utils/workspace-root.js

@@ -34,7 +34,9 @@ export function findWorkspaceRoot(start) {
                     if (dir === start || ws.some((w) => w.location === start))
                         return dir;
                 }
-                catch { /* not a usable workspace root */ }
+                catch {
+                    /* not a usable workspace root */
+                }
             }
         }
         const parent = resolve(dir, '..');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.4.27",
+    "version": "0.4.29",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -55,7 +55,7 @@
                             "item": "`gjsify dlx <pkg>` — fetch and run any npm package's GJS bundle without persisting it"
                         },
                         {
-                            "item": "`gjsify lint` / `gjsify format` — Biome-powered linter + formatter"
+                            "item": "`gjsify lint` / `gjsify format` — oxc-powered linter (oxlint) + formatter (oxfmt)"
                         },
                         {
                             "item": "`gjsify flatpak {init,build,check,deps,ci}` — pack a GJS app or CLI into a Flatpak end-to-end"
@@ -106,7 +106,7 @@
         "clear": "rm -rf lib dist tsconfig.tsbuildinfo || exit 0",
         "check": "tsc --noEmit",
         "start": "node lib/index.js",
-        "build": "tsc && mkdir -p lib/templates/flatpak && cp -L src/templates/install.mjs.tmpl lib/templates/install.mjs.tmpl && cp src/templates/flatpak/*.tmpl lib/templates/flatpak/ && cp src/templates/biome.json.tmpl lib/templates/biome.json.tmpl && gjsify run chmod",
+        "build": "tsc && mkdir -p lib/templates/flatpak && cp -L src/templates/install.mjs.tmpl lib/templates/install.mjs.tmpl && cp src/templates/flatpak/*.tmpl lib/templates/flatpak/ && cp src/templates/oxlintrc.json.tmpl lib/templates/oxlintrc.json.tmpl && cp src/templates/oxfmtrc.tmpl lib/templates/oxfmtrc.tmpl && gjsify run chmod",
         "build:gjs-bundle": "node lib/index.js build src/index.ts --app gjs --outfile dist/cli.gjs.mjs --shebang",
         "chmod": "chmod +x ./lib/index.js",
         "build:test:node": "node lib/index.js build src/test.mts --app node --outfile dist/test.node.mjs",
@@ -120,18 +120,18 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/buffer": "^0.4.27",
-        "@gjsify/create-app": "^0.4.27",
-        "@gjsify/node-globals": "^0.4.27",
-        "@gjsify/node-polyfills": "^0.4.27",
-        "@gjsify/npm-registry": "^0.4.27",
-        "@gjsify/resolve-npm": "^0.4.27",
-        "@gjsify/rolldown-plugin-gjsify": "^0.4.27",
-        "@gjsify/rolldown-plugin-pnp": "^0.4.27",
-        "@gjsify/semver": "^0.4.27",
-        "@gjsify/tar": "^0.4.27",
-        "@gjsify/web-polyfills": "^0.4.27",
-        "@gjsify/workspace": "^0.4.27",
+        "@gjsify/buffer": "^0.4.29",
+        "@gjsify/create-app": "^0.4.29",
+        "@gjsify/node-globals": "^0.4.29",
+        "@gjsify/node-polyfills": "^0.4.29",
+        "@gjsify/npm-registry": "^0.4.29",
+        "@gjsify/resolve-npm": "^0.4.29",
+        "@gjsify/rolldown-plugin-gjsify": "^0.4.29",
+        "@gjsify/rolldown-plugin-pnp": "^0.4.29",
+        "@gjsify/semver": "^0.4.29",
+        "@gjsify/tar": "^0.4.29",
+        "@gjsify/web-polyfills": "^0.4.29",
+        "@gjsify/workspace": "^0.4.29",
         "cosmiconfig": "^9.0.1",
         "get-tsconfig": "^4.14.0",
         "pkg-types": "^2.3.1",
@@ -139,12 +139,12 @@
         "yargs": "^18.0.0"
     },
     "devDependencies": {
-        "@gjsify/unit": "^0.4.27",
+        "@gjsify/unit": "^0.4.29",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/rolldown-native": "^0.4.27"
+        "@gjsify/rolldown-native": "^0.4.29"
     },
     "peerDependenciesMeta": {
         "@gjsify/rolldown-native": {

package/lib/templates/biome.json.tmpl

@@ -1,79 +0,0 @@
-{
-    "$schema": "https://biomejs.dev/schemas/2.4.13/schema.json",
-    "formatter": {
-        "enabled": true,
-        "indentStyle": "space",
-        "indentWidth": 4,
-        "lineWidth": 120,
-        "lineEnding": "lf"
-    },
-    "linter": {
-        "enabled": true,
-        "rules": {
-            "recommended": true,
-            "style": {
-                "useImportType": "warn",
-                "useNodejsImportProtocol": "error",
-                "noNonNullAssertion": "off"
-            },
-            "suspicious": {
-                "noExplicitAny": "warn",
-                "noConsole": "off"
-            },
-            "correctness": {
-                "noUnusedImports": "warn"
-            }
-        }
-    },
-    "javascript": {
-        "formatter": {
-            "quoteStyle": "single",
-            "jsxQuoteStyle": "double",
-            "semicolons": "always",
-            "trailingCommas": "all",
-            "arrowParentheses": "always",
-            "bracketSpacing": true,
-            "bracketSameLine": false
-        }
-    },
-    "json": {
-        "formatter": {
-            "indentWidth": 2,
-            "trailingCommas": "none",
-            "lineWidth": 120
-        }
-    },
-    "css": {
-        "formatter": {
-            "indentWidth": 2,
-            "quoteStyle": "single"
-        }
-    },
-    "files": {
-        "includes": [
-            "**",
-            "!**/node_modules",
-            "!**/dist",
-            "!**/lib",
-            "!**/build",
-            "!**/build-dir",
-            "!**/builddir",
-            "!**/flatpak-build",
-            "!**/.flatpak-builder",
-            "!**/repo",
-            "!**/coverage",
-            "!**/refs",
-            "!**/@types",
-            "!**/templates",
-            "!**/prebuilds",
-            "!**/.yarn/cache",
-            "!**/.yarn/install-state.gz",
-            "!**/cli.gjs.mjs",
-            "!**/test.gjs.mjs",
-            "!**/test.node.mjs",
-            "!**/*.gresource",
-            "!**/*.compiled",
-            "!**/*.metainfo.xml"
-        ]
-    }
-}