@gjsify/cli 0.7.5 → 0.8.0

package/lib/cli-app.js

@@ -19,7 +19,7 @@ import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import yargs from 'yargs';
-import { buildCommand as build, testCommand as test, runCommand as run, infoCommand as info, systemCheckCommand as systemCheck, checkCommand as check, showcaseCommand as showcase, createCommand as create, gresourceCommand as gresource, gettextCommand as gettext, gsettingsCommand as gsettings, flatpakCommand as flatpak, dlxCommand as dlx, installCommand as install, foreachCommand as foreach, workspaceCommand as workspace, packCommand as pack, publishCommand as publish, whoamiCommand as whoami, loginCommand as login, logoutCommand as logout, trustCommand as trust, selfUpdateCommand as selfUpdate, generateInstallerCommand as generateInstaller, uninstallCommand as uninstall, formatCommand as format, lintCommand as lint, fixCommand as fix, upgradeCommand as upgrade, barrelsCommand as barrels, tscCommand as tsc, affectedCommand as affected, } from './commands/index.js';
+import { buildCommand as build, testCommand as test, runCommand as run, infoCommand as info, systemCheckCommand as systemCheck, checkCommand as check, showcaseCommand as showcase, createCommand as create, gresourceCommand as gresource, gettextCommand as gettext, gsettingsCommand as gsettings, flatpakCommand as flatpak, dlxCommand as dlx, installCommand as install, foreachCommand as foreach, workspaceCommand as workspace, packCommand as pack, publishCommand as publish, whoamiCommand as whoami, loginCommand as login, logoutCommand as logout, trustCommand as trust, selfUpdateCommand as selfUpdate, generateInstallerCommand as generateInstaller, uninstallCommand as uninstall, formatCommand as format, lintCommand as lint, fixCommand as fix, upgradeCommand as upgrade, barrelsCommand as barrels, tscCommand as tsc, affectedCommand as affected, storybookCommand as storybook, } from './commands/index.js';
 import { APP_NAME } from './constants.js';
 // Detect which runtime is executing the CLI (GJS or Node.js).
 // GJS MUST be checked first because @gjsify/process sets
@@ -106,6 +106,7 @@ export async function runCli(argv) {
         .command(barrels.command, barrels.description, barrels.builder, barrels.handler)
         .command(tsc.command, tsc.description, tsc.builder, tsc.handler)
         .command(affected.command, affected.description, affected.builder, affected.handler)
+        .command(storybook.command, storybook.description, storybook.builder, storybook.handler)
         .demandCommand(1)
         .epilogue(`Running on ${runtimeLabel()}`)
         .help()

package/lib/commands/index.d.ts

@@ -30,3 +30,4 @@ export * from './upgrade.js';
 export * from './barrels.js';
 export * from './tsc.js';
 export * from './affected.js';
+export * from './storybook.js';

package/lib/commands/index.js

@@ -30,3 +30,4 @@ export * from './upgrade.js';
 export * from './barrels.js';
 export * from './tsc.js';
 export * from './affected.js';
+export * from './storybook.js';

package/lib/commands/login.js

@@ -21,7 +21,7 @@
 import { DEFAULT_REGISTRY, registryFor, whoami } from '@gjsify/npm-registry';
 import { loadNpmrc } from '../utils/load-npmrc.js';
 import { writeAuthToken } from '../utils/auth-npmrc.js';
-import { promptLine, promptHidden } from '../utils/prompt.js';
+import { promptCredentials, promptLine } from '../utils/prompt.js';
 export const loginCommand = {
     command: 'login',
     description: "Log in to an npm registry (Node-free `npm login`). Prompts for username + password (hidden) and writes the token to ~/.npmrc. Use --otp for 2FA. Web-OAuth flow is not supported — this is npm's legacy credentials flow.",
@@ -44,12 +44,15 @@ export const loginCommand = {
             (args.scope ? registryFor(args.scope.startsWith('@') ? `${args.scope}/_` : `@${args.scope}/_`, npmrc) : undefined) ??
             DEFAULT_REGISTRY;
         const registryClean = registry.endsWith('/') ? registry : `${registry}/`;
-        const username = args.username ?? (await promptLine(`Username: `));
+        // Read username (visible) + password (masked) in a single raw-mode TTY
+        // session — robust against cooked line-discipline state + the shared
+        // stdin resume/pause race that intermittently broke the old two-prompt
+        // sequence (Enter showing `^M`, or an empty username).
+        const { username, password } = await promptCredentials(args.username);
         if (!username) {
             console.error('gjsify login: a username is required.');
             process.exit(1);
         }
-        const password = await promptHidden(`Password: `);
         if (!password) {
             console.error('gjsify login: a password is required.');
             process.exit(1);

package/lib/commands/storybook.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../types/index.js';
+interface StorybookCliOptions {
+    stories?: string;
+    appId?: string;
+    title?: string;
+    globals?: string;
+    out?: string;
+    watch: boolean;
+    buildOnly: boolean;
+}
+export declare const storybookCommand: Command<unknown, StorybookCliOptions>;
+export {};

package/lib/commands/storybook.js

@@ -0,0 +1,172 @@
+// `gjsify storybook` — discover every *.story.ts in a project, generate a tiny
+// entry that registers them, then build (`--app gjs`) and launch the generic
+// @gjsify/storybook component browser. No per-project storybook app needed.
+//
+// Dispatch is IN-PROCESS (runCli + runGjsBundle), not a re-spawn of the CLI:
+// the showcase-style `spawn(process.execPath, [cliBin, …])` pattern assumes
+// Node, but under the committed GJS bundle `process.execPath` is `gjs` and the
+// `../index.js` path is not a runnable entry. In-process dispatch works
+// identically under Node and GJS. @gjsify/storybook is resolved from the
+// CONSUMER's node_modules by the generated entry, so it stays out of the CLI's
+// own dependencies.
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+function readPackage(cwd) {
+    try {
+        return JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** Derive a stable GApplication id from the package name when none is configured. */
+function deriveAppId(name) {
+    if (!name)
+        return 'org.gjsify.Storybook';
+    const slug = name
+        .replace(/^@/, '')
+        .replace(/[^a-zA-Z0-9]+/g, '.')
+        .replace(/^\.+|\.+$/g, '');
+    return `org.gjsify.storybook.${slug}`;
+}
+/** Recursively collect `*.story.{ts,js,mts,mjs}` files under a directory. */
+function findStoryFiles(dir) {
+    const out = [];
+    if (!existsSync(dir))
+        return out;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name === 'node_modules' || entry.name.startsWith('.'))
+            continue;
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...findStoryFiles(full));
+        }
+        else if (/\.story\.(ts|js|mts|mjs)$/.test(entry.name)) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+function generateEntry(files, applicationId, title) {
+    const imports = files.map((file, i) => `import * as m${i} from ${JSON.stringify(file)};`).join('\n');
+    const namespaces = files.map((_, i) => `m${i}`).join(', ');
+    const titleLine = title ? `\n    title: ${JSON.stringify(title)},` : '';
+    return `// Auto-generated by \`gjsify storybook\` — do not edit by hand.
+import { collectStoryModules, runStorybook } from '@gjsify/storybook';
+${imports}
+
+await runStorybook({
+    applicationId: ${JSON.stringify(applicationId)},${titleLine}
+    stories: collectStoryModules([${namespaces}]),
+});
+`;
+}
+export const storybookCommand = {
+    command: 'storybook',
+    description: 'Discover *.story.ts in this project and launch the GTK storybook browser.',
+    builder: (yargs) => yargs
+        .option('stories', {
+        description: 'Directory scanned recursively for *.story.ts (default: src, or gjsify.storybook.stories)',
+        type: 'string',
+    })
+        .option('app-id', {
+        description: 'GApplication id (default: gjsify.storybook.applicationId or derived from the package name)',
+        type: 'string',
+    })
+        .option('title', { description: 'Window title', type: 'string' })
+        .option('globals', {
+        description: 'Value for `gjsify build --globals` (default: auto; use auto,dom for canvas/DOM stories)',
+        type: 'string',
+    })
+        .option('out', {
+        description: 'Output bundle path (default: node_modules/.cache/gjsify-storybook)',
+        type: 'string',
+    })
+        .option('watch', {
+        description: 'Rebuild and relaunch when a story file changes',
+        type: 'boolean',
+        default: false,
+    })
+        .option('build-only', { description: 'Build the bundle but do not launch it', type: 'boolean', default: false }),
+    handler: async (args) => {
+        const cwd = process.cwd();
+        const pkg = readPackage(cwd);
+        const config = pkg.gjsify?.storybook ?? {};
+        const storiesDir = resolve(cwd, args.stories ?? config.stories ?? 'src');
+        const applicationId = args.appId ?? config.applicationId ?? deriveAppId(pkg.name);
+        const title = args.title ?? config.title;
+        const globals = args.globals ?? config.globals ?? 'auto';
+        const cacheDir = join(cwd, 'node_modules', '.cache', 'gjsify-storybook');
+        mkdirSync(cacheDir, { recursive: true });
+        const entryPath = join(cacheDir, 'entry.ts');
+        const outPath = args.out ? resolve(cwd, args.out) : join(cacheDir, 'storybook.gjs.mjs');
+        const writeEntry = () => {
+            const files = findStoryFiles(storiesDir).sort();
+            writeFileSync(entryPath, generateEntry(files, applicationId, title));
+            return files.length;
+        };
+        const initialCount = writeEntry();
+        if (initialCount === 0) {
+            console.error(`No *.story.ts files found under ${relative(cwd, storiesDir) || storiesDir}`);
+            process.exit(1);
+        }
+        console.log(`Found ${initialCount} story file(s) under ${relative(cwd, storiesDir) || '.'}`);
+        // In-process build — runtime-agnostic (Node uses npm rolldown, GJS uses
+        // the @gjsify/rolldown-native facade), no re-spawn of the CLI binary.
+        const { runCli } = await import('../cli-app.js');
+        const buildBundle = () => runCli(['build', entryPath, '--app', 'gjs', '--globals', globals, '--outfile', outPath]);
+        if (!args.watch) {
+            await buildBundle();
+            if (args.buildOnly)
+                return;
+            const { runGjsBundle } = await import('../utils/run-gjs.js');
+            await runGjsBundle(outPath, [], { exitOnSuccess: true });
+            return;
+        }
+        // Watch mode: rebuild + relaunch on any change under the stories dir.
+        // The storybook bundle only needs system Gtk/Adw typelibs at runtime
+        // (no @gjsify native bridges), so a plain `gjs -m` child is enough and
+        // stays killable for relaunch.
+        const { watch } = await import('node:fs');
+        let child = null;
+        let rebuilding = false;
+        let pending = false;
+        const rebuild = async () => {
+            if (rebuilding) {
+                pending = true;
+                return;
+            }
+            rebuilding = true;
+            try {
+                writeEntry();
+                if (child) {
+                    child.kill();
+                    child = null;
+                }
+                await buildBundle();
+                if (!args.buildOnly) {
+                    child = spawn('gjs', ['-m', outPath], { stdio: 'inherit' });
+                }
+            }
+            catch (err) {
+                console.error(`[storybook] rebuild failed: ${err.message}`);
+            }
+            finally {
+                rebuilding = false;
+                if (pending) {
+                    pending = false;
+                    void rebuild();
+                }
+            }
+        };
+        await rebuild();
+        let debounce = null;
+        watch(storiesDir, { recursive: true }, () => {
+            if (debounce)
+                clearTimeout(debounce);
+            debounce = setTimeout(() => void rebuild(), 200);
+        });
+        console.log(`[storybook] watching ${relative(cwd, storiesDir) || '.'} — press Ctrl+C to stop`);
+    },
+};

package/lib/utils/prompt.d.ts

@@ -1,8 +1,34 @@
-/** Print a question and read one line from stdin (visible). */
-export declare function promptLine(question: string): Promise<string>;
+/** Credentials read from the terminal. */
+export interface PromptedCredentials {
+    username: string;
+    password: string;
+}
+/** Result of feeding one keystroke to the raw-mode line editor. */
+export interface KeyOutcome {
+    /** The line buffer after this key. */
+    buf: string;
+    /** Text to echo to the terminal for this key (`''` = nothing). */
+    echo: string;
+    /** The line is complete (Enter). */
+    done: boolean;
+    /** Ctrl-C was pressed (caller should restore + exit). */
+    interrupt: boolean;
+}
 /**
- * Print a question and read one line WITHOUT echoing it (passwords). Uses raw
- * mode + manual key handling on a TTY; falls back to a plain line read when
- * stdin is not a TTY (piped). Ctrl-C aborts the process.
+ * Pure key handler for the raw-mode line editor — the single source of truth
+ * for how a keystroke updates the buffer + echo. Kept pure (no I/O) so it is
+ * unit-testable: this is what makes Enter (`\r` OR `\n`) reliably submit, masks
+ * passwords, and treats Ctrl-C as an interrupt rather than text.
  */
+export declare function applyKey(buf: string, ch: string, mask: boolean): KeyOutcome;
+/** Print a question and read one visible line. */
+export declare function promptLine(question: string): Promise<string>;
+/** Print a question and read one line WITHOUT echoing it (passwords). */
 export declare function promptHidden(question: string): Promise<string>;
+/**
+ * Read npm credentials. On a TTY both the visible username and the masked
+ * password are read in ONE raw session (no cooked-line dependency, no
+ * inter-prompt resume/pause race). `providedUsername` (from `--username`) skips
+ * the username prompt.
+ */
+export declare function promptCredentials(providedUsername?: string): Promise<PromptedCredentials>;

package/lib/utils/prompt.js

@@ -1,81 +1,118 @@
-// Minimal interactive prompts for `gjsify login` — a visible line prompt and a
-// hidden (no-echo) password prompt. Cross-runtime: `process.stdin.setRawMode`
-// is provided by Node and by `@gjsify/process` (terminal-native) under GJS.
+// Interactive prompts for `gjsify login` / `gjsify trust`.
 //
-// Non-TTY stdin (piped input, CI) is supported: both helpers read a single line
-// without raw-mode masking, so `printf 'user\npass\n' | gjsify login` works for
-// automation.
-const CTRL_C = String.fromCharCode(3); // ETX (Ctrl-C)
-const DEL = String.fromCharCode(127); // DEL (Backspace on most terminals)
-const BACKSPACE = String.fromCharCode(8); // BS
-/** Print a question and read one line from stdin (visible). */
-export async function promptLine(question) {
-    process.stdout.write(question);
-    return readLine();
+// On a TTY every prompt runs inside a single RAW-mode session (`runRawSession`)
+// that reads key-by-key with manual echo and a guaranteed cooked-mode restore
+// (try/finally). This deliberately does NOT rely on the terminal's cooked
+// line-discipline nor on the shared `process.stdin` resume/pause cycle:
+//   - The old visible prompt read a cooked line via `process.stdin` 'data'
+//     events. With the line discipline in an unexpected state (e.g. ICRNL off
+//     after a prior raw prompt) Enter arrived as a bare `\r` that never
+//     terminated the cooked line — the prompt hung showing `name^M`. The
+//     resume/pause churn on the shared stdin singleton between two sequential
+//     prompts also intermittently dropped the line or resolved it empty.
+//   - Reading raw + handling `\r`/`\n` ourselves removes both failure modes.
+//
+// Raw mode (via @gjsify/process → terminal-native) now also clears ISIG, so
+// Ctrl-C is delivered as a `\x03` keystroke we handle (restore + exit) instead
+// of a SIGINT that would kill the process leaving the terminal in raw mode.
+//
+// Non-TTY stdin (piped input, CI) keeps a plain line read so
+// `printf 'user\npass\n' | gjsify login` still works.
+const CTRL_C = '\x03'; // ETX (Ctrl-C)
+const DEL = '\x7f'; // DEL (Backspace on most terminals)
+const BACKSPACE = '\x08'; // BS
+function isTtyStdin() {
+    const stdin = process.stdin;
+    return Boolean(stdin.isTTY) && typeof stdin.setRawMode === 'function';
 }
 /**
- * Print a question and read one line WITHOUT echoing it (passwords). Uses raw
- * mode + manual key handling on a TTY; falls back to a plain line read when
- * stdin is not a TTY (piped). Ctrl-C aborts the process.
+ * Pure key handler for the raw-mode line editor — the single source of truth
+ * for how a keystroke updates the buffer + echo. Kept pure (no I/O) so it is
+ * unit-testable: this is what makes Enter (`\r` OR `\n`) reliably submit, masks
+ * passwords, and treats Ctrl-C as an interrupt rather than text.
  */
-export async function promptHidden(question) {
-    process.stdout.write(question);
-    const stdin = process.stdin;
-    if (!stdin.isTTY || typeof stdin.setRawMode !== 'function') {
-        // Non-interactive: read a line as-is (no masking possible/needed).
-        return readLine();
+export function applyKey(buf, ch, mask) {
+    if (ch === '\r' || ch === '\n') {
+        return { buf, echo: '\n', done: true, interrupt: false };
     }
-    return new Promise((resolve) => {
-        let buf = '';
-        stdin.setRawMode(true);
-        stdin.resume();
-        // setEncoding makes 'data' emit decoded STRINGS — including under GJS,
-        // where @gjsify/process honours it via StringDecoder (was a no-op stub;
-        // bytes broke `ch === '\r'` so Enter never submitted). So we can iterate
-        // characters directly here; do NOT reintroduce a byte-normalising shim.
-        stdin.setEncoding('utf-8');
-        const onData = (chunk) => {
-            for (const ch of chunk) {
-                if (ch === '\r' || ch === '\n') {
-                    cleanup();
-                    process.stdout.write('\n');
-                    resolve(buf);
-                    return;
-                }
-                else if (ch === CTRL_C) {
-                    cleanup();
-                    process.stdout.write('\n');
-                    process.exit(130);
-                }
-                else if (ch === DEL || ch === BACKSPACE) {
-                    if (buf.length > 0) {
-                        buf = buf.slice(0, -1);
-                        process.stdout.write('\b \b');
-                    }
-                }
-                else if (ch >= ' ') {
-                    buf += ch;
-                    process.stdout.write('*');
-                }
-            }
-        };
-        const cleanup = () => {
+    if (ch === CTRL_C) {
+        return { buf, echo: '\n', done: false, interrupt: true };
+    }
+    if (ch === DEL || ch === BACKSPACE) {
+        if (buf.length > 0) {
+            return { buf: buf.slice(0, -1), echo: '\b \b', done: false, interrupt: false };
+        }
+        return { buf, echo: '', done: false, interrupt: false };
+    }
+    if (ch >= ' ') {
+        return { buf: buf + ch, echo: mask ? '*' : ch, done: false, interrupt: false };
+    }
+    // Other control characters (arrows, tabs, escapes) are ignored.
+    return { buf, echo: '', done: false, interrupt: false };
+}
+/**
+ * Open ONE raw-mode stdin session, run `fn` (which may read several lines via
+ * the supplied reader), and always restore cooked mode afterwards. Keeping a
+ * single session for the whole credential exchange avoids per-prompt
+ * resume/pause races on the shared stdin singleton.
+ */
+async function runRawSession(fn) {
+    const stdin = process.stdin;
+    const out = process.stdout;
+    let pending = null;
+    const cleanup = () => {
+        stdin.removeListener('data', onData);
+        try {
             stdin.setRawMode(false);
-            stdin.removeListener('data', onData);
+        }
+        catch {
+            /* not a TTY any more */
+        }
+        if (typeof stdin.pause === 'function')
             stdin.pause();
-        };
-        stdin.on('data', onData);
+    };
+    const onData = (chunk) => {
+        const text = typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
+        for (const ch of text) {
+            if (!pending)
+                continue; // ignore type-ahead between prompts
+            const r = applyKey(pending.buf, ch, pending.mask);
+            pending.buf = r.buf;
+            if (r.echo)
+                out.write(r.echo);
+            if (r.interrupt) {
+                cleanup();
+                process.exit(130);
+            }
+            if (r.done) {
+                const { resolve } = pending;
+                pending = null;
+                resolve(r.buf);
+            }
+        }
+    };
+    stdin.setRawMode(true);
+    if (typeof stdin.resume === 'function')
+        stdin.resume();
+    stdin.setEncoding('utf-8');
+    stdin.on('data', onData);
+    const read = (question, mask) => new Promise((resolve) => {
+        out.write(question);
+        pending = { mask, buf: '', resolve };
     });
+    try {
+        return await fn(read);
+    }
+    finally {
+        cleanup();
+    }
 }
-/** Read a single line from stdin (shared by both prompts on non-TTY). */
+/** Read a single line from non-TTY stdin (piped). Accepts CR, LF, or CRLF. */
 function readLine() {
     return new Promise((resolve) => {
         let buf = '';
         const onData = (chunk) => {
             buf += typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
-            // Accept CR, LF, or CRLF as the line terminator. A bare CR (`\r`)
-            // is what some terminals / the GJS terminal-native stdin deliver on
-            // Enter — keying only on `\n` made the prompt hang forever there.
             const m = buf.search(/[\r\n]/);
             if (m >= 0) {
                 cleanup();
@@ -97,3 +134,42 @@ function readLine() {
         process.stdin.once('end', onEnd);
     });
 }
+/** Print a question and read one visible line. */
+export async function promptLine(question) {
+    if (!isTtyStdin()) {
+        process.stdout.write(question);
+        return readLine();
+    }
+    return runRawSession((read) => read(question, false));
+}
+/** Print a question and read one line WITHOUT echoing it (passwords). */
+export async function promptHidden(question) {
+    if (!isTtyStdin()) {
+        process.stdout.write(question);
+        return readLine();
+    }
+    return runRawSession((read) => read(question, true));
+}
+/**
+ * Read npm credentials. On a TTY both the visible username and the masked
+ * password are read in ONE raw session (no cooked-line dependency, no
+ * inter-prompt resume/pause race). `providedUsername` (from `--username`) skips
+ * the username prompt.
+ */
+export async function promptCredentials(providedUsername) {
+    if (!isTtyStdin()) {
+        let username = providedUsername;
+        if (!username) {
+            process.stdout.write('Username: ');
+            username = await readLine();
+        }
+        process.stdout.write('Password: ');
+        const password = await readLine();
+        return { username, password };
+    }
+    return runRawSession(async (read) => {
+        const username = providedUsername ?? (await read('Username: ', false));
+        const password = await read('Password: ', true);
+        return { username, password };
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.7.5",
+    "version": "0.8.0",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -120,19 +120,19 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/buffer": "^0.7.5",
-        "@gjsify/create-app": "^0.7.5",
-        "@gjsify/node-globals": "^0.7.5",
-        "@gjsify/node-polyfills": "^0.7.5",
-        "@gjsify/npm-registry": "^0.7.5",
-        "@gjsify/resolve-npm": "^0.7.5",
-        "@gjsify/rolldown-plugin-gjsify": "^0.7.5",
-        "@gjsify/rolldown-plugin-pnp": "^0.7.5",
-        "@gjsify/semver": "^0.7.5",
-        "@gjsify/tar": "^0.7.5",
-        "@gjsify/tsc": "^0.7.5",
-        "@gjsify/web-polyfills": "^0.7.5",
-        "@gjsify/workspace": "^0.7.5",
+        "@gjsify/buffer": "^0.8.0",
+        "@gjsify/create-app": "^0.8.0",
+        "@gjsify/node-globals": "^0.8.0",
+        "@gjsify/node-polyfills": "^0.8.0",
+        "@gjsify/npm-registry": "^0.8.0",
+        "@gjsify/resolve-npm": "^0.8.0",
+        "@gjsify/rolldown-plugin-gjsify": "^0.8.0",
+        "@gjsify/rolldown-plugin-pnp": "^0.8.0",
+        "@gjsify/semver": "^0.8.0",
+        "@gjsify/tar": "^0.8.0",
+        "@gjsify/tsc": "^0.8.0",
+        "@gjsify/web-polyfills": "^0.8.0",
+        "@gjsify/workspace": "^0.8.0",
         "cosmiconfig": "^9.0.2",
         "get-tsconfig": "^4.14.0",
         "pkg-types": "^2.3.1",
@@ -140,13 +140,13 @@
         "yargs": "^18.0.0"
     },
     "devDependencies": {
-        "@gjsify/unit": "^0.7.5",
+        "@gjsify/unit": "^0.8.0",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/oxfmt-native": "^0.7.5",
-        "@gjsify/rolldown-native": "^0.7.5"
+        "@gjsify/oxfmt-native": "^0.8.0",
+        "@gjsify/rolldown-native": "^0.8.0"
     },
     "peerDependenciesMeta": {
         "@gjsify/oxfmt-native": {