@gjsify/cli 0.64.18 → 0.64.20

package/lib/commands/flatpak/check.d.ts

@@ -8,8 +8,11 @@ interface FlatpakCheckOptions {
     strict?: boolean;
     json?: boolean;
     qualityNetwork?: boolean;
+    appstreamNetwork?: boolean;
     builderLint?: boolean;
     verbose?: boolean;
 }
+/** argv for `appstreamcli`; offline unless the caller opts in to URL reachability checks. */
+export declare function appstreamValidateArgs(metainfoAbs: string, network?: boolean): string[];
 export declare const flatpakCheckCommand: Command<unknown, FlatpakCheckOptions>;
 export {};

package/lib/commands/flatpak/check.js

@@ -1,8 +1,9 @@
 // `gjsify flatpak check` — run Flathub's pre-submission linters locally.
 //
 // Wraps two tools:
-//   - `appstreamcli validate --strict <metainfo>` — MetaInfo XML
-//     correctness check
+//   - `appstreamcli validate --strict --no-net <metainfo>` — MetaInfo XML
+//     correctness check; offline unless `--appstream-network` (a URL that
+//     is merely unreachable from the runner must not fail the gate)
 //   - `flatpak-builder-lint manifest <manifest.json>` — manifest
 //     correctness check (and optionally `repo` for built artefacts)
 //
@@ -15,6 +16,10 @@ import { spawnToCompletion } from '../../utils/spawn.js';
 import { readPackageJson, looksLikeAppId } from './utils.js';
 import { Config } from '../../config.js';
 import { formatFinding, lintMetainfo, readImageInfo, summarizeFindings, } from '../../utils/metainfo-quality.js';
+/** argv for `appstreamcli`; offline unless the caller opts in to URL reachability checks. */
+export function appstreamValidateArgs(metainfoAbs, network = false) {
+    return ['validate', '--strict', ...(network ? [] : ['--no-net']), metainfoAbs];
+}
 export const flatpakCheckCommand = {
     command: 'check [manifest]',
     description: 'Run Flathub pre-submission linters: appstreamcli validate + flatpak-builder-lint.',
@@ -36,7 +41,7 @@ export const flatpakCheckCommand = {
             normalize: true,
         })
             .option('appstream', {
-            description: 'Run `appstreamcli validate --strict` (default: true).',
+            description: 'Run `appstreamcli validate --strict --no-net` (default: true).',
             type: 'boolean',
             default: true,
         })
@@ -59,6 +64,11 @@ export const flatpakCheckCommand = {
             description: 'Let the quality check fetch http(s) screenshot/icon URLs to measure their size.',
             type: 'boolean',
             default: false,
+        })
+            .option('appstream-network', {
+            description: 'Let `appstreamcli` fetch the MetaInfo URLs to check they are reachable.',
+            type: 'boolean',
+            default: false,
         })
             .option('builder-lint', {
             description: 'Run `flatpak-builder-lint manifest` (default: true).',
@@ -86,7 +96,7 @@ export const flatpakCheckCommand = {
                 console.warn(`[gjsify flatpak check] skipping appstreamcli — ${metainfoAbs} not found`);
             }
             else {
-                const ok = await runLinter('appstreamcli', ['validate', '--strict', metainfoAbs], args.verbose ?? false);
+                const ok = await runLinter('appstreamcli', appstreamValidateArgs(metainfoAbs, args.appstreamNetwork === true), args.verbose ?? false);
                 if (!ok)
                     failures++;
             }

package/lib/commands/site.js

@@ -21,55 +21,8 @@
 // The resolved install directory is passed to the child as `--package-dir`. A
 // bundle's `import.meta.url` is the OUTFILE, so the library cannot find its own
 // `po/` and `lib/client/` on its own — only the caller still knows.
-import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { hostRuntime } from '@gjsify/rolldown-plugin-gjsify/runtime';
-import { resolveNodeGi } from '../utils/run-node.js';
-/** The `@gjsify/site` install reachable from `cwd`, walking the node_modules chain upwards. */
-function resolveSitePackage(cwd) {
-    let dir = resolve(cwd);
-    for (;;) {
-        const candidate = join(dir, 'node_modules', '@gjsify', 'site');
-        if (existsSync(join(candidate, 'package.json')))
-            return candidate;
-        const parent = dirname(dir);
-        if (parent === dir)
-            return undefined;
-        dir = parent;
-    }
-}
-function gjsOnPath() {
-    return spawnSync('gjs', ['--version'], { stdio: 'ignore' }).status === 0;
-}
-/**
- * The runtime the page is built for. An explicit `--runtime` wins. Otherwise the host runtime —
- * except that a non-gjs host without `@gjsify/node-gi` in the project cannot run the `--app node`
- * bundle (GdkPixbuf is reached through it), so a consumer that only ran
- * `npm i -D @gjsify/site` falls back to gjs when the system has one.
- */
-function pickRuntime(requested, cwd) {
-    if (requested)
-        return requested;
-    const host = hostRuntime();
-    if (host === 'gjs' || resolveNodeGi(cwd))
-        return host;
-    return gjsOnPath() ? 'gjs' : host;
-}
-/**
- * The generated entry. Arguments arrive as ARGV rather than baked in, so the cached bundle serves
- * every invocation — flags change far more often than this does.
- *
- * The exit is spelled per runtime on purpose. Under GJS `process.exit` does not halt and loses its
- * code (the `gjsify storybook` measurement), so the gjs entry uses `system.exit`; both read the
- * user arguments from where their own runtime puts them.
- */
-function generateEntry(app) {
-    const header = `// Auto-generated by \`gjsify site\` — do not edit by hand.\nimport { runSiteCli } from '@gjsify/site';\n`;
-    return app === 'gjs'
-        ? `${header}import system from 'system';\n\nsystem.exit(await runSiteCli(system.programArgs));\n`
-        : `${header}\nprocess.exit(await runSiteCli(process.argv.slice(2)));\n`;
-}
+import { resolve } from 'node:path';
+import { dispatchSite } from '../utils/site-dispatch.js';
 export const siteCommand = {
     command: 'site <operation>',
     description: "Render this project's static landing page from its AppStream metainfo (downloads, screenshots, " +
@@ -123,45 +76,7 @@ export const siteCommand = {
         .option('globals', { description: 'Value for `gjsify build --globals` (default: auto)', type: 'string' }),
     handler: async (args) => {
         const cwd = process.cwd();
-        const packageDir = resolveSitePackage(cwd);
-        if (!packageDir) {
-            console.error('gjsify site: @gjsify/site is not installed in this project.\n\n' +
-                '  The generator ships as its own package so a project only pays for it when it\n' +
-                '  publishes a page. Add it, then run this again:\n\n' +
-                '      npm install --save-dev @gjsify/site');
-            return process.exit(1);
-        }
-        if (!existsSync(join(packageDir, 'lib', 'client', 'site.js'))) {
-            console.error(`gjsify site: ${packageDir} has no built client bundle (lib/client/site.js).\n` +
-                '  In a source checkout, build the package first: `gjsify workspace site build`.');
-            return process.exit(1);
-        }
-        const runtime = pickRuntime(args.runtime, cwd);
-        const app = runtime === 'gjs' ? 'gjs' : 'node';
-        const cacheDir = join(cwd, 'node_modules', '.cache', 'gjsify-site');
-        mkdirSync(cacheDir, { recursive: true });
-        const entryPath = join(cacheDir, `entry.${app}.ts`);
-        const outPath = join(cacheDir, `site.${app}.mjs`);
-        writeFileSync(entryPath, generateEntry(app));
-        const globals = args.globals ?? 'auto';
-        if (app === 'gjs') {
-            // The consumer installed `@gjsify/site`, not the polyfills `--globals auto` injects
-            // (URL, DOMException, streams, …), so those resolve from beside the running CLI.
-            const { BuildAction } = await import('../actions/build.js');
-            await BuildAction.bundleFileForGjs(entryPath, outPath, {
-                globals,
-                preserveDefaultExport: false,
-                toolchainAnchor: BuildAction.runningCliFile(),
-                logLevel: 'silent',
-            });
-        }
-        else {
-            const { runCli } = await import('../cli-app.js');
-            await runCli(['build', entryPath, '--app', app, '--globals', globals, '--outfile', outPath]);
-        }
-        // RESOLVED values, not the raw argv: the child parses its own flags and
-        // cannot know where this CLI found the package.
-        const forwarded = [args.operation, '--package-dir', packageDir];
+        const forwarded = [args.operation];
         if (args.root)
             forwarded.push('--root', resolve(cwd, args.root));
         if (args.out)
@@ -178,17 +93,12 @@ export const siteCommand = {
             forwarded.push('--check');
         if (args.package)
             forwarded.push('--package');
-        if (runtime === 'gjs') {
-            const { runGjsBundle } = await import('../utils/run-gjs.js');
-            await runGjsBundle(outPath, forwarded, { completion: 'exit', exitOnSuccess: true });
-            return;
-        }
-        if (runtime === 'node') {
-            const { runNodeBundle } = await import('../utils/run-node.js');
-            await runNodeBundle(outPath, forwarded, { completion: 'exit', exitOnSuccess: true });
-            return;
-        }
-        const { runRuntimeBundle } = await import('../utils/run-node.js');
-        await runRuntimeBundle(runtime, outPath, forwarded, { completion: 'exit', exitOnSuccess: true });
+        await dispatchSite({
+            invokedAs: 'gjsify site',
+            argv: forwarded,
+            runtime: args.runtime,
+            globals: args.globals,
+            needsClient: args.operation === 'build',
+        });
     },
 };

package/lib/commands/webext/index.js

@@ -1,8 +1,8 @@
 // `gjsify webext` — yargs subcommand-group dispatcher (ADR 0077).
 //
-// Wires {build, zip, dev}; each is a self-contained `Command<>` in `subcommands.ts`,
+// Wires {build, zip, dev, listing}; each is a self-contained `Command<>` in `subcommands.ts`,
 // the same composition `flatpak/index.ts` uses.
-import { webextBuildCommand, webextDevCommand, webextZipCommand } from './subcommands.js';
+import { webextBuildCommand, webextDevCommand, webextListingCommand, webextZipCommand } from './subcommands.js';
 export const webextCommand = {
     command: 'webext <subcommand>',
     description: 'Browser extensions: build, zip and develop one WebExtension for Chrome, Edge, Firefox, Opera and Safari.',
@@ -10,6 +10,7 @@ export const webextCommand = {
         .command(webextBuildCommand.command, webextBuildCommand.description, webextBuildCommand.builder, webextBuildCommand.handler)
         .command(webextZipCommand.command, webextZipCommand.description, webextZipCommand.builder, webextZipCommand.handler)
         .command(webextDevCommand.command, webextDevCommand.description, webextDevCommand.builder, webextDevCommand.handler)
+        .command(webextListingCommand.command, webextListingCommand.description, webextListingCommand.builder, webextListingCommand.handler)
         .demandCommand(1)
         .strict(),
 };

package/lib/commands/webext/subcommands.d.ts

@@ -13,4 +13,17 @@ interface WebextArgs {
 export declare const webextBuildCommand: Command<unknown, WebextArgs>;
 export declare const webextZipCommand: Command<unknown, WebextArgs>;
 export declare const webextDevCommand: Command<unknown, WebextArgs>;
+interface ListingArgs {
+    store: string;
+    out?: string;
+    check: boolean;
+    metainfo?: string;
+    config?: string;
+    pot?: string;
+    root?: string;
+    offline: boolean;
+    runtime?: string;
+    globals?: string;
+}
+export declare const webextListingCommand: Command<unknown, ListingArgs>;
 export {};

package/lib/commands/webext/subcommands.js

@@ -5,6 +5,7 @@
 // runs, re-entered in-process like `gjsify dev` does.
 import { existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve, sep } from 'node:path';
+import { dispatchSite } from '../../utils/site-dispatch.js';
 import { buildWebext } from '../../utils/webext/build.js';
 import { resolveWebextConfig, selectTargets } from '../../utils/webext/config.js';
 import { defaultDevProfile, resolveWebExt, WEB_EXT_MISSING, webExtRunArgs, } from '../../utils/webext/launch.js';
@@ -202,3 +203,67 @@ export const webextDevCommand = {
         });
     },
 };
+export const webextListingCommand = {
+    command: 'listing',
+    description: 'Derive the store listings (Chrome Web Store, Edge Add-ons, Firefox AMO) from the AppStream metainfo, ' +
+        'the gettext catalogues and the screenshots: texts, permission justifications and exact-size images.',
+    builder: (yargs) => yargs
+        .option('store', {
+        description: 'Which store to write (default: all).',
+        type: 'string',
+        choices: ['cws', 'edge', 'amo', 'all'],
+        default: 'all',
+    })
+        .option('out', { description: 'Output directory, emptied first (default: dist/listing).', type: 'string' })
+        .option('check', {
+        description: 'Validate against the store limits; write nothing.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('metainfo', {
+        description: 'AppStream metainfo (default: gjsify.webext.listing.metainfo, else gjsify.site.metainfo).',
+        type: 'string',
+    })
+        .option('config', {
+        description: 'JSON file that overrides the gjsify.webext.listing block of package.json.',
+        type: 'string',
+    })
+        .option('pot', { description: 'Also write the config strings as a gettext template.', type: 'string' })
+        .option('root', { description: 'Project root (default: the working directory).', type: 'string' })
+        .option('offline', {
+        description: 'Skip downloading screenshots hosted elsewhere.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('runtime', {
+        description: 'Runtime to run on: gjs | node | bun | deno (default: the host runtime).',
+        type: 'string',
+        choices: ['gjs', 'node', 'bun', 'deno'],
+    })
+        .option('globals', { description: 'Value for `gjsify build --globals` (default: auto).', type: 'string' }),
+    handler: async (args) => {
+        const cwd = process.cwd();
+        const forwarded = ['listing', '--store', args.store];
+        if (args.root)
+            forwarded.push('--root', resolve(cwd, args.root));
+        if (args.out)
+            forwarded.push('--out', resolve(cwd, args.out));
+        if (args.check)
+            forwarded.push('--check');
+        if (args.metainfo)
+            forwarded.push('--metainfo', args.metainfo);
+        if (args.config)
+            forwarded.push('--config', resolve(cwd, args.config));
+        if (args.pot)
+            forwarded.push('--pot', resolve(cwd, args.pot));
+        if (args.offline)
+            forwarded.push('--offline');
+        await dispatchSite({
+            invokedAs: 'gjsify webext listing',
+            argv: forwarded,
+            runtime: args.runtime,
+            globals: args.globals,
+            needsClient: false,
+        });
+    },
+};

package/lib/utils/site-dispatch.d.ts

@@ -0,0 +1,33 @@
+/** `gjs` builds `--app gjs`; `node`/`bun`/`deno` build the same `--app node` bundle. */
+export type SiteRuntime = 'gjs' | 'node' | 'bun' | 'deno';
+/** The `@gjsify/site` install reachable from `cwd`, walking the node_modules chain upwards. */
+export declare function resolveSitePackage(cwd: string): string | undefined;
+export declare function gjsOnPath(): boolean;
+/**
+ * The runtime the page is built for. An explicit `--runtime` wins. Otherwise the host runtime —
+ * except that a non-gjs host without `@gjsify/node-gi` in the project cannot run the `--app node`
+ * bundle (GdkPixbuf is reached through it), so a consumer that only ran
+ * `npm i -D @gjsify/site` falls back to gjs when the system has one.
+ */
+export declare function pickRuntime(requested: string | undefined, cwd: string): SiteRuntime;
+/**
+ * The generated entry. Arguments arrive as ARGV rather than baked in, so the cached bundle serves
+ * every invocation — flags change far more often than this does.
+ *
+ * The exit is spelled per runtime on purpose. Under GJS `process.exit` does not halt and loses its
+ * code (the `gjsify storybook` measurement), so the gjs entry uses `system.exit`; both read the
+ * user arguments from where their own runtime puts them.
+ */
+export declare function generateEntry(app: 'gjs' | 'node', command?: string): string;
+export interface SiteDispatch {
+    /** What the generated entry's header names as its author. */
+    invokedAs: string;
+    /** Forwarded to `runSiteCli` after `--package-dir`. */
+    argv: string[];
+    runtime?: string;
+    globals?: string;
+    /** Whether `lib/client/site.js` must exist (only the page build ships it to the browser). */
+    needsClient: boolean;
+}
+/** Resolves `@gjsify/site`, bundles the entry for the chosen runtime, and runs it; exits the process. */
+export declare function dispatchSite(options: SiteDispatch): Promise<void>;

package/lib/utils/site-dispatch.js

@@ -0,0 +1,104 @@
+// Shared by `gjsify site` and `gjsify webext listing`: both run `runSiteCli` from the CONSUMER's
+// `@gjsify/site`, bundled for the runtime the CLI itself is on (see `commands/site.ts` for why).
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { hostRuntime } from '@gjsify/rolldown-plugin-gjsify/runtime';
+import { resolveNodeGi } from './run-node.js';
+/** The `@gjsify/site` install reachable from `cwd`, walking the node_modules chain upwards. */
+export function resolveSitePackage(cwd) {
+    let dir = resolve(cwd);
+    for (;;) {
+        const candidate = join(dir, 'node_modules', '@gjsify', 'site');
+        if (existsSync(join(candidate, 'package.json')))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+export function gjsOnPath() {
+    return spawnSync('gjs', ['--version'], { stdio: 'ignore' }).status === 0;
+}
+/**
+ * The runtime the page is built for. An explicit `--runtime` wins. Otherwise the host runtime —
+ * except that a non-gjs host without `@gjsify/node-gi` in the project cannot run the `--app node`
+ * bundle (GdkPixbuf is reached through it), so a consumer that only ran
+ * `npm i -D @gjsify/site` falls back to gjs when the system has one.
+ */
+export function pickRuntime(requested, cwd) {
+    if (requested)
+        return requested;
+    const host = hostRuntime();
+    if (host === 'gjs' || resolveNodeGi(cwd))
+        return host;
+    return gjsOnPath() ? 'gjs' : host;
+}
+/**
+ * The generated entry. Arguments arrive as ARGV rather than baked in, so the cached bundle serves
+ * every invocation — flags change far more often than this does.
+ *
+ * The exit is spelled per runtime on purpose. Under GJS `process.exit` does not halt and loses its
+ * code (the `gjsify storybook` measurement), so the gjs entry uses `system.exit`; both read the
+ * user arguments from where their own runtime puts them.
+ */
+export function generateEntry(app, command = 'gjsify site') {
+    const header = `// Auto-generated by \`${command}\` — do not edit by hand.\nimport { runSiteCli } from '@gjsify/site';\n`;
+    return app === 'gjs'
+        ? `${header}import system from 'system';\n\nsystem.exit(await runSiteCli(system.programArgs));\n`
+        : `${header}\nprocess.exit(await runSiteCli(process.argv.slice(2)));\n`;
+}
+/** Resolves `@gjsify/site`, bundles the entry for the chosen runtime, and runs it; exits the process. */
+export async function dispatchSite(options) {
+    const cwd = process.cwd();
+    const packageDir = resolveSitePackage(cwd);
+    if (!packageDir) {
+        console.error(`${options.invokedAs}: @gjsify/site is not installed in this project.\n\n` +
+            '  The generator ships as its own package so a project only pays for it when it\n' +
+            '  publishes a page or a store listing. Add it, then run this again:\n\n' +
+            '      npm install --save-dev @gjsify/site');
+        return process.exit(1);
+    }
+    if (options.needsClient && !existsSync(join(packageDir, 'lib', 'client', 'site.js'))) {
+        console.error(`${options.invokedAs}: ${packageDir} has no built client bundle (lib/client/site.js).\n` +
+            '  In a source checkout, build the package first: `gjsify workspace site build`.');
+        return process.exit(1);
+    }
+    const runtime = pickRuntime(options.runtime, cwd);
+    const app = runtime === 'gjs' ? 'gjs' : 'node';
+    const cacheDir = join(cwd, 'node_modules', '.cache', 'gjsify-site');
+    mkdirSync(cacheDir, { recursive: true });
+    const entryPath = join(cacheDir, `entry.${app}.ts`);
+    const outPath = join(cacheDir, `site.${app}.mjs`);
+    writeFileSync(entryPath, generateEntry(app, options.invokedAs));
+    const globals = options.globals ?? 'auto';
+    if (app === 'gjs') {
+        // The consumer installed `@gjsify/site`, not the polyfills `--globals auto` injects
+        // (URL, DOMException, streams, …), so those resolve from beside the running CLI.
+        const { BuildAction } = await import('../actions/build.js');
+        await BuildAction.bundleFileForGjs(entryPath, outPath, {
+            globals,
+            preserveDefaultExport: false,
+            toolchainAnchor: BuildAction.runningCliFile(),
+            logLevel: 'silent',
+        });
+    }
+    else {
+        const { runCli } = await import('../cli-app.js');
+        await runCli(['build', entryPath, '--app', app, '--globals', globals, '--outfile', outPath]);
+    }
+    const forwarded = [...options.argv.slice(0, 1), '--package-dir', packageDir, ...options.argv.slice(1)];
+    if (runtime === 'gjs') {
+        const { runGjsBundle } = await import('./run-gjs.js');
+        await runGjsBundle(outPath, forwarded, { completion: 'exit', exitOnSuccess: true });
+        return;
+    }
+    if (runtime === 'node') {
+        const { runNodeBundle } = await import('./run-node.js');
+        await runNodeBundle(outPath, forwarded, { completion: 'exit', exitOnSuccess: true });
+        return;
+    }
+    const { runRuntimeBundle } = await import('./run-node.js');
+    await runRuntimeBundle(runtime, outPath, forwarded, { completion: 'exit', exitOnSuccess: true });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.64.18",
+    "version": "0.64.20",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -142,22 +142,22 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/blueprint": "^0.64.18",
-        "@gjsify/buffer": "^0.64.18",
-        "@gjsify/create-app": "^0.64.18",
-        "@gjsify/node-globals": "^0.64.18",
-        "@gjsify/node-polyfills": "^0.64.18",
-        "@gjsify/npm-registry": "^0.64.18",
-        "@gjsify/resolve-npm": "^0.64.18",
-        "@gjsify/rolldown-plugin-gjsify": "^0.64.18",
-        "@gjsify/vite-plugin-blueprint": "^0.64.18",
-        "@gjsify/rolldown-plugin-pnp": "^0.64.18",
-        "@gjsify/semver": "^0.64.18",
-        "@gjsify/tar": "^0.64.18",
-        "@gjsify/tsc": "^0.64.18",
-        "@gjsify/utils": "^0.64.18",
-        "@gjsify/web-polyfills": "^0.64.18",
-        "@gjsify/workspace": "^0.64.18",
+        "@gjsify/blueprint": "^0.64.20",
+        "@gjsify/buffer": "^0.64.20",
+        "@gjsify/create-app": "^0.64.20",
+        "@gjsify/node-globals": "^0.64.20",
+        "@gjsify/node-polyfills": "^0.64.20",
+        "@gjsify/npm-registry": "^0.64.20",
+        "@gjsify/resolve-npm": "^0.64.20",
+        "@gjsify/rolldown-plugin-gjsify": "^0.64.20",
+        "@gjsify/vite-plugin-blueprint": "^0.64.20",
+        "@gjsify/rolldown-plugin-pnp": "^0.64.20",
+        "@gjsify/semver": "^0.64.20",
+        "@gjsify/tar": "^0.64.20",
+        "@gjsify/tsc": "^0.64.20",
+        "@gjsify/utils": "^0.64.20",
+        "@gjsify/web-polyfills": "^0.64.20",
+        "@gjsify/workspace": "^0.64.20",
         "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.18",
+        "@gjsify/unit": "^0.64.20",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/oxfmt-native": "^0.64.18",
-        "@gjsify/rolldown-native": "^0.64.18"
+        "@gjsify/oxfmt-native": "^0.64.20",
+        "@gjsify/rolldown-native": "^0.64.20"
     },
     "peerDependenciesMeta": {
         "@gjsify/oxfmt-native": {