@gjsify/cli 0.64.21 → 0.64.23

package/lib/types/config-data.d.ts

@@ -762,8 +762,10 @@ export interface ConfigDataShip extends AppMetadata {
      *
      * `Contents/PlugIns` is Apple's own nested-code location (`codesign(1)`'s
      * bundle format, beside `Frameworks`/`Helpers`/`XPCServices`); no other
-     * layout has an equivalent slot, so this is refused outside
-     * `gjsify ship darwin`.
+     * layout has an equivalent slot, so this is IGNORED (not refused) outside
+     * `gjsify ship darwin` — one notice on stderr, exit 0 (ADR 0024 amendment,
+     * 2026-11-06 addendum, beifahrer#203). The shape is still validated on
+     * every layout.
      */
     nestedBundles?: ShipNestedBundleOptions[];
     /**

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

@@ -51,15 +51,51 @@ export interface RunOxcOptions {
     cwd?: string;
     verbose?: boolean;
 }
+export interface OxfmtEngineInputs {
+    isGjs: boolean;
+    /** The `@gjsify/oxfmt-native` bridge loaded and its library opened. */
+    nativeLoadable: boolean;
+    /** The oxfmt release the bridge embeds; `undefined` when the bridge does not say. */
+    embeddedVersion?: string;
+    /** Version of the oxfmt npm package the project resolves; `undefined` when it has none. */
+    projectVersion?: string;
+    /** `GJSIFY_OXFMT`. */
+    override?: string;
+}
+export interface OxfmtEngineDecision {
+    engine: 'native' | 'npm';
+    /** The forced `native` engine runs a different oxfmt than the project's lock. */
+    warning?: string;
+    /** The forced `native` engine cannot be loaded. */
+    error?: string;
+}
+/**
+ * The engine pick as a pure function. Two engines that are not the same build of
+ * oxfmt format some inputs differently (`for (…; cond;) {` vs `for (…; cond; ) {`
+ * between 0.61 and 0.56), so a project that pins its own `oxfmt` must get THAT
+ * build, or `format:check` is green under GJS locally and red under Node in CI.
+ *
+ *   - `npm` override → npm launcher.
+ *   - `native` override → the bridge, an error when it is not loadable, a warning
+ *     when it differs from the project's pinned version.
+ *   - Not GJS, or bridge not loadable → npm launcher.
+ *   - Project resolves no `oxfmt`, or either version is unknown → native (the
+ *     Node-free default; there is nothing to disagree with).
+ *   - Both known → native only when equal, else the project's npm `oxfmt` wins.
+ */
+export declare function decideOxfmtEngine(input: OxfmtEngineInputs): OxfmtEngineDecision;
+/**
+ * Version of the `oxfmt` npm package the project resolves (same walk as
+ * {@link findOxcLauncher}), or `undefined` when there is none.
+ */
+export declare function findProjectOxfmtVersion(cwd?: string): string | undefined;
 /**
- * Engine pick for oxfmt — mirrors `bundler-pick.ts`'s `shouldUseNative()`:
- *   - `GJSIFY_OXFMT=npm` forces the Node launcher.
- *   - `GJSIFY_OXFMT=native` forces the GI bridge and throws when it is not
- *     loadable (instead of silently switching engines).
- *   - Default: native under GJS when loadable (the Node launcher cannot run
- *     without a Node host), npm launcher on Node.
+ * Engine pick for oxfmt — see {@link decideOxfmtEngine} for the rule. This wrapper
+ * gathers the inputs (bridge probe, project version) and applies the outcome:
+ * a forced `native` that cannot load throws, a forced `native` on another version
+ * than the project's warns once per process.
  */
-export declare function shouldUseNativeOxfmt(): Promise<boolean>;
+export declare function shouldUseNativeOxfmt(cwd?: string): Promise<boolean>;
 /**
  * Run an oxc tool (oxlint / oxfmt).
  *

package/lib/utils/oxc-resolve.js

@@ -47,7 +47,7 @@
 // Rust rule subset. Lint stays Node-spawned until that trade-off is decided
 // (tracked in status/open-todos/README.md).
 import { existsSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { hostLibc } from './platform-check.js';
@@ -297,38 +297,93 @@ async function tryLoadNativeOxfmt() {
     })();
     return _nativeOxfmtProbe;
 }
+const normalizeVersion = (v) => v.trim().replace(/^v/, '');
 /**
- * Engine pick for oxfmt — mirrors `bundler-pick.ts`'s `shouldUseNative()`:
- *   - `GJSIFY_OXFMT=npm` forces the Node launcher.
- *   - `GJSIFY_OXFMT=native` forces the GI bridge and throws when it is not
- *     loadable (instead of silently switching engines).
- *   - Default: native under GJS when loadable (the Node launcher cannot run
- *     without a Node host), npm launcher on Node.
+ * The engine pick as a pure function. Two engines that are not the same build of
+ * oxfmt format some inputs differently (`for (…; cond;) {` vs `for (…; cond; ) {`
+ * between 0.61 and 0.56), so a project that pins its own `oxfmt` must get THAT
+ * build, or `format:check` is green under GJS locally and red under Node in CI.
+ *
+ *   - `npm` override → npm launcher.
+ *   - `native` override → the bridge, an error when it is not loadable, a warning
+ *     when it differs from the project's pinned version.
+ *   - Not GJS, or bridge not loadable → npm launcher.
+ *   - Project resolves no `oxfmt`, or either version is unknown → native (the
+ *     Node-free default; there is nothing to disagree with).
+ *   - Both known → native only when equal, else the project's npm `oxfmt` wins.
  */
-export async function shouldUseNativeOxfmt() {
-    const env = globalThis.process?.env ?? {};
-    const choice = env.GJSIFY_OXFMT;
-    if (choice === 'npm')
-        return false;
-    if (choice === 'native') {
-        const native = await tryLoadNativeOxfmt();
-        if (!native) {
-            throw new Error('GJSIFY_OXFMT=native but @gjsify/oxfmt-native is not loadable (no prebuild for this architecture, or not running under GJS).' +
-                (_nativeOxfmtLoadError ? `\n${_nativeOxfmtLoadError.message}` : ''));
+export function decideOxfmtEngine(input) {
+    const { isGjs: gjs, nativeLoadable, embeddedVersion, projectVersion, override } = input;
+    const known = embeddedVersion !== undefined && projectVersion !== undefined;
+    const differs = known && normalizeVersion(embeddedVersion) !== normalizeVersion(projectVersion);
+    if (override === 'npm')
+        return { engine: 'npm' };
+    if (override === 'native') {
+        if (!nativeLoadable) {
+            return {
+                engine: 'native',
+                error: 'GJSIFY_OXFMT=native but @gjsify/oxfmt-native is not loadable (no prebuild for this architecture, or not running under GJS).',
+            };
         }
-        return true;
+        return differs
+            ? {
+                engine: 'native',
+                warning: `GJSIFY_OXFMT=native: @gjsify/oxfmt-native embeds oxfmt ${embeddedVersion} but this project ` +
+                    `pins oxfmt ${projectVersion}; output can differ from the project's own oxfmt (and from CI).`,
+            }
+            : { engine: 'native' };
     }
-    if (!isGjs())
+    if (!gjs || !nativeLoadable)
+        return { engine: 'npm' };
+    return { engine: differs ? 'npm' : 'native' };
+}
+/**
+ * Version of the `oxfmt` npm package the project resolves (same walk as
+ * {@link findOxcLauncher}), or `undefined` when there is none.
+ */
+export function findProjectOxfmtVersion(cwd = process.cwd()) {
+    try {
+        const launcher = findOxcLauncher('oxfmt', cwd);
+        const pkg = JSON.parse(readFileSync(join(dirname(launcher), '..', 'package.json'), 'utf-8'));
+        return typeof pkg?.version === 'string' ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+let _engineWarned = false;
+/**
+ * Engine pick for oxfmt — see {@link decideOxfmtEngine} for the rule. This wrapper
+ * gathers the inputs (bridge probe, project version) and applies the outcome:
+ * a forced `native` that cannot load throws, a forced `native` on another version
+ * than the project's warns once per process.
+ */
+export async function shouldUseNativeOxfmt(cwd = process.cwd()) {
+    const env = globalThis.process?.env ?? {};
+    const override = env.GJSIFY_OXFMT;
+    // Nothing to probe when npm is forced or there is no GJS host (and no native override).
+    if (override === 'npm' || (!isGjs() && override !== 'native'))
         return false;
-    const native = (await tryLoadNativeOxfmt()) !== null;
+    const native = await tryLoadNativeOxfmt();
+    const decision = decideOxfmtEngine({
+        isGjs: isGjs(),
+        nativeLoadable: native !== null,
+        embeddedVersion: native?.EMBEDDED_OXFMT_VERSION,
+        projectVersion: findProjectOxfmtVersion(cwd),
+        override,
+    });
+    if (decision.error)
+        throw new Error(decision.error + (_nativeOxfmtLoadError ? `\n${_nativeOxfmtLoadError.message}` : ''));
+    if (decision.warning && !_engineWarned) {
+        _engineWarned = true;
+        console.warn(`[gjsify oxc] ${decision.warning}`);
+    }
     // Falling back to the npm launcher is not an error, so the default path is
     // quiet — but a MEASURED reason why the native bridge would not load is the
     // only place the user hears it, and it is the whole point of measuring.
-    // `GJSIFY_OXFMT=native` above throws with this text; the default earns the
-    // same answer for free.
-    if (!native && _nativeOxfmtLoadError)
+    if (!native && _nativeOxfmtLoadError && decision.engine === 'npm')
         console.debug(_nativeOxfmtLoadError.message);
-    return native;
+    return decision.engine === 'native';
 }
 /**
  * Run an oxc tool (oxlint / oxfmt).

package/lib/utils/ship/layout.d.ts

@@ -151,9 +151,11 @@ export interface LayoutDirs {
      * `Helpers`, `XPCServices`). `''` on linux and windows, where neither a
      * prefix nor a program directory has an equivalent: a Flatpak sandbox has no
      * App Extension model and a Windows program directory has nothing Apple's
-     * extension points name. `gjsify.ship.nestedBundles` is refused outright on
-     * any layout where this is `''` (ADR 0024 amendment, "nested bundles and
-     * helper executables"; the beifahrer ADR this answers: 0026 § 6).
+     * extension points name. `gjsify.ship.nestedBundles` is IGNORED (not
+     * refused) on any layout where this is `''` — `resolveShipNestedBundles`
+     * resolves it to `[]` before `stageSubordinates` ever sees it (ADR 0024
+     * amendment, "nested bundles and helper executables", 2026-11-06 addendum;
+     * the beifahrer ADR this answers: 0026 § 6).
      */
     plugins: string;
 }

package/lib/utils/ship/nested-bundles.js

@@ -36,8 +36,8 @@ export function stageSubordinates(input) {
         if (dirs.plugins === '') {
             throw new Error(`gjsify ship: the ${input.layout.name} layout has no \`Contents/PlugIns\` equivalent, so ` +
                 `the nested bundle "${bundle.name}" has nowhere to go. ` +
-                '`gjsify.ship.nestedBundles` is darwin-only; `resolveShipSettings` should have refused ' +
-                'this already — report this as a gjsify bug if it did not.');
+                '`gjsify.ship.nestedBundles` is darwin-only; `resolveShipNestedBundles` should have ' +
+                'resolved this to `[]` already — report this as a gjsify bug if it did not.');
         }
         const bundleRoot = posix.join(dirs.plugins, bundle.name);
         for (const rel of listFilesRecursive(bundle.source)) {
@@ -54,8 +54,8 @@ export function stageSubordinates(input) {
         if (dirs.helpers === '') {
             throw new Error(`gjsify ship: the ${input.layout.name} layout has no \`Contents/Helpers\` equivalent, so ` +
                 `the helper executable "${helper.name}" has nowhere to go. ` +
-                '`gjsify.ship.helperExecutables` is darwin-only; `resolveShipSettings` should have refused ' +
-                'this already — report this as a gjsify bug if it did not.');
+                '`gjsify.ship.helperExecutables` is darwin-only; `resolveShipHelperExecutables` should have ' +
+                'resolved this to `[]` already — report this as a gjsify bug if it did not.');
         }
         const path = posix.join(dirs.helpers, helper.name);
         files.push({ path, mode: 0o755, source: { kind: 'file', path: helper.source } });

package/lib/utils/ship/settings.d.ts

@@ -181,10 +181,15 @@ export declare function resolveShipExecutables(input: {
  * `gjsify.ship.nestedBundles` → the further bundles the darwin container embeds
  * under `Contents/PlugIns/` — e.g. a Safari Web Extension `.appex`.
  *
- * Darwin-only by construction: `layoutOs !== 'darwin'` refuses a non-empty list
- * rather than silently dropping it, because `Contents/PlugIns` has no
- * equivalent on the other two layouts (ADR 0024 amendment, "nested bundles and
- * helper executables"; the beifahrer ADR this answers: 0026 § 6).
+ * Darwin-only in EFFECT, not in form (ADR 0024 amendment, 2026-11-06,
+ * beifahrer#203): the declaration describes what the darwin `.app` carries and
+ * is not an error on another layout, so a non-empty list on `linux`/`windows`
+ * resolves to `[]` rather than throwing — a project with a Mac extension must
+ * still ship for Linux and Windows. The SHAPE check (schema, leaf names, `..`,
+ * duplicates, unknown keys) still runs on every layout, so a typo is caught on
+ * a Linux build too; only the SOURCE's existence is darwin-only, because a
+ * Linux runner never built the `.appex` to check. The caller
+ * ({@link resolveShipSettings}) prints the one-line notice this silence needs.
  */
 export declare function resolveShipNestedBundles(input: {
     declared: unknown;
@@ -194,7 +199,8 @@ export declare function resolveShipNestedBundles(input: {
 /**
  * `gjsify.ship.helperExecutables` → prebuilt executables staged into
  * `Contents/Helpers/` beside the carried interpreter — e.g. a small Swift
- * helper with no GI binding. Darwin-only, for the same reason as
+ * helper with no GI binding. Darwin-only in EFFECT, not in form — same reason
+ * and same split (shape always, source existence darwin-only) as
  * {@link resolveShipNestedBundles}.
  */
 export declare function resolveShipHelperExecutables(input: {

package/lib/utils/ship/settings.js

@@ -192,6 +192,26 @@ export function resolveShipSettings(input) {
     // finish-args default depends on `kind`, which is a project fact.
     const flatpakSettings = resolveShipFlatpakSettings({ ship, flatpak, kind });
     warnings.push(...flatpakSettings.warnings);
+    // `gjsify.ship.nestedBundles`/`helperExecutables` describe what the DARWIN
+    // `.app` carries — on any other layout they are IGNORED, with one combined
+    // notice (ADR 0024 amendment, 2026-11-06, beifahrer#203), never refused: a
+    // project with a Mac extension must still be able to ship for Linux and
+    // Windows. Shape is still validated on every layout inside each resolver.
+    const nestedBundlesResolved = resolveShipNestedBundles({
+        declared: ship.nestedBundles,
+        projectDir: input.projectDir,
+        layoutOs: input.cli.layoutOs,
+    });
+    const helperExecutablesResolved = resolveShipHelperExecutables({
+        declared: ship.helperExecutables,
+        projectDir: input.projectDir,
+        layoutOs: input.cli.layoutOs,
+    });
+    if (input.cli.layoutOs !== 'darwin' &&
+        ((Array.isArray(ship.nestedBundles) && ship.nestedBundles.length > 0) ||
+            (Array.isArray(ship.helperExecutables) && ship.helperExecutables.length > 0))) {
+        warnings.push(`gjsify ship: nestedBundles/helperExecutables apply to darwin only — not staged for ${input.cli.layoutOs}`);
+    }
     const settings = {
         projectDir: input.projectDir,
         appId,
@@ -228,16 +248,8 @@ export function resolveShipSettings(input) {
             projectDir: input.projectDir,
             bundleDir: discovered.bundleDir,
         }),
-        nestedBundles: resolveShipNestedBundles({
-            declared: ship.nestedBundles,
-            projectDir: input.projectDir,
-            layoutOs: input.cli.layoutOs,
-        }),
-        helperExecutables: resolveShipHelperExecutables({
-            declared: ship.helperExecutables,
-            projectDir: input.projectDir,
-            layoutOs: input.cli.layoutOs,
-        }),
+        nestedBundles: nestedBundlesResolved,
+        helperExecutables: helperExecutablesResolved,
         outDir: input.cli.outDir ?? ship.outDir ?? 'ship',
         arch: input.cli.arch ?? process.arch,
         app,
@@ -320,10 +332,15 @@ function assertUsableBundleLeaf(name, at, under) {
  * `gjsify.ship.nestedBundles` → the further bundles the darwin container embeds
  * under `Contents/PlugIns/` — e.g. a Safari Web Extension `.appex`.
  *
- * Darwin-only by construction: `layoutOs !== 'darwin'` refuses a non-empty list
- * rather than silently dropping it, because `Contents/PlugIns` has no
- * equivalent on the other two layouts (ADR 0024 amendment, "nested bundles and
- * helper executables"; the beifahrer ADR this answers: 0026 § 6).
+ * Darwin-only in EFFECT, not in form (ADR 0024 amendment, 2026-11-06,
+ * beifahrer#203): the declaration describes what the darwin `.app` carries and
+ * is not an error on another layout, so a non-empty list on `linux`/`windows`
+ * resolves to `[]` rather than throwing — a project with a Mac extension must
+ * still ship for Linux and Windows. The SHAPE check (schema, leaf names, `..`,
+ * duplicates, unknown keys) still runs on every layout, so a typo is caught on
+ * a Linux build too; only the SOURCE's existence is darwin-only, because a
+ * Linux runner never built the `.appex` to check. The caller
+ * ({@link resolveShipSettings}) prints the one-line notice this silence needs.
  */
 export function resolveShipNestedBundles(input) {
     const { declared } = input;
@@ -333,14 +350,8 @@ export function resolveShipNestedBundles(input) {
         throw new Error('gjsify ship: `gjsify.ship.nestedBundles` must be a list of `{ "source", "name", "entitlements"? }` ' +
             'objects.');
     }
-    if (declared.length > 0 && input.layoutOs !== 'darwin') {
-        throw new Error(`gjsify ship: \`gjsify.ship.nestedBundles\` is set and this run assembles the ${input.layoutOs} ` +
-            'layout, which has no `Contents/PlugIns` or equivalent — a Flatpak sandbox has no App ' +
-            "Extension model and a Windows program directory has nothing Apple's extension points name. " +
-            'Nested bundles are staged only for `gjsify ship darwin`.');
-    }
     const seen = new Set();
-    return declared.map((row, index) => {
+    const resolved = declared.map((row, index) => {
         const at = `gjsify.ship.nestedBundles[${index}]`;
         if (typeof row !== 'object' || row === null || Array.isArray(row)) {
             throw new Error(`gjsify ship: \`${at}\` must be an object with \`source\` and \`name\`.`);
@@ -362,7 +373,10 @@ export function resolveShipNestedBundles(input) {
         }
         seen.add(name);
         const abs = isAbsolute(source) ? source : resolve(input.projectDir, source);
-        if (!existsSync(abs)) {
+        // Existence is checked for darwin alone: on linux/windows this bundle is
+        // ignored outright (see below), and a CI runner assembling those layouts
+        // never built the `.appex` in the first place.
+        if (input.layoutOs === 'darwin' && !existsSync(abs)) {
             throw new Error(`gjsify ship: \`${at}.source\` ${source} does not exist.`);
         }
         if (entitlements !== undefined && !Array.isArray(entitlements)) {
@@ -379,11 +393,13 @@ export function resolveShipNestedBundles(input) {
             }),
         };
     });
+    return input.layoutOs === 'darwin' ? resolved : [];
 }
 /**
  * `gjsify.ship.helperExecutables` → prebuilt executables staged into
  * `Contents/Helpers/` beside the carried interpreter — e.g. a small Swift
- * helper with no GI binding. Darwin-only, for the same reason as
+ * helper with no GI binding. Darwin-only in EFFECT, not in form — same reason
+ * and same split (shape always, source existence darwin-only) as
  * {@link resolveShipNestedBundles}.
  */
 export function resolveShipHelperExecutables(input) {
@@ -394,13 +410,8 @@ export function resolveShipHelperExecutables(input) {
         throw new Error('gjsify ship: `gjsify.ship.helperExecutables` must be a list of `{ "source", "name", ' +
             '"entitlements"? }` objects.');
     }
-    if (declared.length > 0 && input.layoutOs !== 'darwin') {
-        throw new Error(`gjsify ship: \`gjsify.ship.helperExecutables\` is set and this run assembles the ` +
-            `${input.layoutOs} layout, which has no \`Contents/Helpers\` or equivalent. Helper ` +
-            'executables are staged only for `gjsify ship darwin`.');
-    }
     const seen = new Set();
-    return declared.map((row, index) => {
+    const resolved = declared.map((row, index) => {
         const at = `gjsify.ship.helperExecutables[${index}]`;
         if (typeof row !== 'object' || row === null || Array.isArray(row)) {
             throw new Error(`gjsify ship: \`${at}\` must be an object with \`source\` and \`name\`.`);
@@ -422,7 +433,10 @@ export function resolveShipHelperExecutables(input) {
         }
         seen.add(name);
         const abs = isAbsolute(source) ? source : resolve(input.projectDir, source);
-        if (!existsSync(abs)) {
+        // Existence is checked for darwin alone — on linux/windows this helper is
+        // ignored outright (see below), and a CI runner assembling those layouts
+        // never built it in the first place.
+        if (input.layoutOs === 'darwin' && !existsSync(abs)) {
             throw new Error(`gjsify ship: \`${at}.source\` ${source} does not exist.`);
         }
         if (entitlements !== undefined && !Array.isArray(entitlements)) {
@@ -439,6 +453,7 @@ export function resolveShipHelperExecutables(input) {
             }),
         };
     });
+    return input.layoutOs === 'darwin' ? resolved : [];
 }
 /**
  * The ONE place a ship target's ENTRY is decided — {@link resolveShipApp}'s twin.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.64.21",
+    "version": "0.64.23",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -142,22 +142,22 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/blueprint": "^0.64.21",
-        "@gjsify/buffer": "^0.64.21",
-        "@gjsify/create-app": "^0.64.21",
-        "@gjsify/node-globals": "^0.64.21",
-        "@gjsify/node-polyfills": "^0.64.21",
-        "@gjsify/npm-registry": "^0.64.21",
-        "@gjsify/resolve-npm": "^0.64.21",
-        "@gjsify/rolldown-plugin-gjsify": "^0.64.21",
-        "@gjsify/vite-plugin-blueprint": "^0.64.21",
-        "@gjsify/rolldown-plugin-pnp": "^0.64.21",
-        "@gjsify/semver": "^0.64.21",
-        "@gjsify/tar": "^0.64.21",
-        "@gjsify/tsc": "^0.64.21",
-        "@gjsify/utils": "^0.64.21",
-        "@gjsify/web-polyfills": "^0.64.21",
-        "@gjsify/workspace": "^0.64.21",
+        "@gjsify/blueprint": "^0.64.23",
+        "@gjsify/buffer": "^0.64.23",
+        "@gjsify/create-app": "^0.64.23",
+        "@gjsify/node-globals": "^0.64.23",
+        "@gjsify/node-polyfills": "^0.64.23",
+        "@gjsify/npm-registry": "^0.64.23",
+        "@gjsify/resolve-npm": "^0.64.23",
+        "@gjsify/rolldown-plugin-gjsify": "^0.64.23",
+        "@gjsify/vite-plugin-blueprint": "^0.64.23",
+        "@gjsify/rolldown-plugin-pnp": "^0.64.23",
+        "@gjsify/semver": "^0.64.23",
+        "@gjsify/tar": "^0.64.23",
+        "@gjsify/tsc": "^0.64.23",
+        "@gjsify/utils": "^0.64.23",
+        "@gjsify/web-polyfills": "^0.64.23",
+        "@gjsify/workspace": "^0.64.23",
         "acorn": "^8.17.0",
         "cosmiconfig": "^9.0.2",
         "get-tsconfig": "^4.14.0",
@@ -166,13 +166,13 @@
         "yargs": "^18.0.0"
     },
     "devDependencies": {
-        "@gjsify/unit": "^0.64.21",
+        "@gjsify/unit": "^0.64.23",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/oxfmt-native": "^0.64.21",
-        "@gjsify/rolldown-native": "^0.64.21"
+        "@gjsify/oxfmt-native": "^0.64.23",
+        "@gjsify/rolldown-native": "^0.64.23"
     },
     "peerDependenciesMeta": {
         "@gjsify/oxfmt-native": {