berg-pages 0.1.0-alpha.6

package/dist/interfaces/cli/main.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { LocalDeployExecutionPorts } from "../../adapters/local-deploy-execution-ports.js";
+import { LocalEnvironmentProbe } from "../../adapters/local-environment-probe.js";
+import { LocalInitApplyPorts } from "../../adapters/local-init-apply-ports.js";
+import { LocalProjectInspector } from "../../adapters/local-project-inspector.js";
+import { applyDeployPlan } from "../../application/usecases/apply-deploy-plan.js";
+import { applyInitPlan } from "../../application/usecases/apply-init-plan.js";
+import { createProjectContext } from "../../application/usecases/create-project-context.js";
+import { buildDoctorPlan } from "../../application/usecases/build-doctor-plan.js";
+import { buildDeployPlan } from "../../application/usecases/build-deploy-plan.js";
+import { buildInitPlan } from "../../application/usecases/build-init-plan.js";
+import { GitPagesDeployModePlugin } from "../../features/deployment-modes/git-pages-deploy-mode-plugin.js";
+import { AstroFrameworkPlugin } from "../../features/frameworks/astro-framework-plugin.js";
+import { StaticHtmlFrameworkPlugin } from "../../features/frameworks/static-html-framework-plugin.js";
+import { ViteFrameworkPlugin } from "../../features/frameworks/vite-framework-plugin.js";
+import { renderCommandPlan } from "./render-command-plan.js";
+async function main(argv) {
+    const command = argv[0];
+    const args = argv.slice(1);
+    if (!command || command === "--help" || command === "help") {
+        printUsage();
+        return 0;
+    }
+    const projectRootArgument = args.find((arg) => !arg.startsWith("--"));
+    const projectRoot = resolve(projectRootArgument ?? process.cwd());
+    const inspector = new LocalProjectInspector();
+    const environmentProbe = new LocalEnvironmentProbe();
+    const frameworkPlugins = [
+        new ViteFrameworkPlugin(),
+        new StaticHtmlFrameworkPlugin(),
+        new AstroFrameworkPlugin()
+    ];
+    const gitPagesPlugin = new GitPagesDeployModePlugin();
+    const deployModePlugins = [gitPagesPlugin];
+    const [inspection, environment] = await Promise.all([
+        inspector.inspect(projectRoot),
+        environmentProbe.probe(projectRoot)
+    ]);
+    const context = createProjectContext({
+        inspection,
+        environment
+    });
+    if (command === "doctor") {
+        const plan = buildDoctorPlan({
+            context,
+            frameworkPlugins,
+            deployModePlugins
+        });
+        console.log(renderCommandPlan(plan));
+        return 0;
+    }
+    if (command === "init") {
+        const shouldDryRun = args.includes("--dry-run");
+        const shouldApply = args.includes("--apply");
+        if (!shouldDryRun && !shouldApply) {
+            console.error("Use `berg-pages init --dry-run` or `berg-pages init --apply`.");
+            return 1;
+        }
+        if (shouldDryRun && shouldApply) {
+            console.error("Choose either `--dry-run` or `--apply`, not both.");
+            return 1;
+        }
+        const frameworkPlugin = frameworkPlugins.find((plugin) => plugin.id === context.project.framework?.id);
+        const deployModePlugin = context.project.pages.deployMode?.id === gitPagesPlugin.id && context.project.pages.target
+            ? gitPagesPlugin
+            : undefined;
+        const plan = buildInitPlan({
+            context,
+            ...(frameworkPlugin ? { frameworkPlugin } : {}),
+            ...(deployModePlugin ? { deployModePlugin } : {})
+        });
+        console.log(renderCommandPlan(plan));
+        if (shouldApply) {
+            const result = await applyInitPlan(plan, new LocalInitApplyPorts(projectRoot));
+            if (result.diagnostics.length > 0) {
+                console.error("");
+                console.error("Apply failed:");
+                for (const diagnostic of result.diagnostics) {
+                    console.error(`- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.summary}`);
+                }
+                return 1;
+            }
+            console.log("");
+            console.log(`Applied ${result.appliedStepIds.length} local init steps.`);
+        }
+        return 0;
+    }
+    if (command === "deploy") {
+        const shouldDryRun = args.includes("--dry-run");
+        const shouldApply = args.includes("--apply");
+        const confirmedPush = args.includes("--confirm-push");
+        if (!shouldDryRun && !shouldApply) {
+            console.error("Use `berg-pages deploy --dry-run` or `berg-pages deploy --apply --confirm-push`.");
+            return 1;
+        }
+        if (shouldDryRun && shouldApply) {
+            console.error("Choose either `--dry-run` or `--apply`, not both.");
+            return 1;
+        }
+        if (shouldDryRun && confirmedPush) {
+            console.error("Use `--confirm-push` only with `deploy --apply`.");
+            return 1;
+        }
+        if (shouldApply && !confirmedPush) {
+            console.error("Refusing deploy apply without `--confirm-push`.");
+            return 1;
+        }
+        const frameworkPlugin = frameworkPlugins.find((plugin) => plugin.id === context.project.framework?.id);
+        const deployModePlugin = context.project.pages.deployMode?.id === gitPagesPlugin.id && context.project.pages.target
+            ? gitPagesPlugin
+            : undefined;
+        const plan = buildDeployPlan({
+            context,
+            ...(frameworkPlugin ? { frameworkPlugin } : {}),
+            ...(deployModePlugin ? { deployModePlugin } : {})
+        });
+        console.log(renderCommandPlan(plan));
+        if (shouldApply) {
+            const result = await applyDeployPlan(plan, new LocalDeployExecutionPorts(projectRoot));
+            if (result.diagnostics.length > 0) {
+                console.error("");
+                console.error("Deploy apply failed:");
+                for (const diagnostic of result.diagnostics) {
+                    console.error(`- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.summary}`);
+                    if (diagnostic.detail) {
+                        console.error(`  ${diagnostic.detail}`);
+                    }
+                }
+                return 1;
+            }
+            console.log("");
+            console.log(`Applied ${result.appliedStepIds.length} deploy publish steps.`);
+        }
+        return 0;
+    }
+    console.error(`Unknown command: ${command}`);
+    printUsage();
+    return 1;
+}
+function printUsage() {
+    console.log("Usage:");
+    console.log("  npm run berg -- doctor [project-root]");
+    console.log("  npm run berg -- init --dry-run [project-root]");
+    console.log("  npm run berg -- init --apply [project-root]");
+    console.log("  npm run berg -- deploy --dry-run [project-root]");
+    console.log("  npm run berg -- deploy --apply --confirm-push [project-root]");
+}
+main(process.argv.slice(2))
+    .then((exitCode) => {
+    process.exitCode = exitCode;
+})
+    .catch((error) => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+});

package/dist/interfaces/cli/render-command-plan.d.ts

@@ -0,0 +1,2 @@
+import type { CommandPlan } from "../../core/plans/command-plan.js";
+export declare function renderCommandPlan(plan: CommandPlan): string;

package/dist/interfaces/cli/render-command-plan.js

@@ -0,0 +1,87 @@
+export function renderCommandPlan(plan) {
+    const lines = [];
+    const owner = plan.project.repository.owner;
+    const repositoryLabel = owner
+        ? `${owner}/${plan.project.repository.name}`
+        : plan.project.repository.name;
+    lines.push(`${plan.command} plan`);
+    lines.push(`Project: ${repositoryLabel}`);
+    lines.push(plan.summary);
+    lines.push("");
+    if (plan.project.framework) {
+        lines.push(`Framework: ${plan.project.framework.id} (${plan.project.framework.source}, ${plan.project.framework.confidence})`);
+    }
+    else {
+        lines.push("Framework: unknown");
+    }
+    lines.push(`Remote: ${plan.project.repository.remoteUrl ?? "missing"}`);
+    if (plan.project.pages.target?.kind === "codeberg-project") {
+        lines.push(`Pages target: ${plan.project.pages.target.url}`);
+        lines.push(`Base path: ${plan.project.pages.target.basePath}`);
+    }
+    else {
+        lines.push("Pages target: missing");
+        lines.push("Base path: missing");
+    }
+    lines.push(`Deploy mode: ${plan.project.pages.deployMode?.id ?? "missing"}`);
+    lines.push(`Build output: ${plan.project.paths.buildOutputDir ?? "missing"}`);
+    lines.push("");
+    lines.push("Diagnostics:");
+    if (plan.diagnostics.length === 0) {
+        lines.push("- none");
+    }
+    else {
+        for (const diagnostic of plan.diagnostics) {
+            lines.push(`- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.summary}`);
+            if (diagnostic.detail) {
+                lines.push(`  ${diagnostic.detail}`);
+            }
+            if (diagnostic.suggestions && diagnostic.suggestions.length > 0) {
+                lines.push("  Suggestions:");
+                lines.push(...diagnostic.suggestions.map((suggestion) => `  - ${suggestion}`));
+            }
+        }
+    }
+    lines.push("");
+    lines.push("Steps:");
+    for (const step of plan.steps) {
+        lines.push(...renderStep(step));
+    }
+    lines.push("");
+    lines.push(`Effects: ${plan.effectSummary.writes} writes, ${plan.effectSummary.directories} directories, ${plan.effectSummary.commands} commands, ${plan.effectSummary.publishes} publishes, ${plan.effectSummary.verifications} verifications, ${plan.effectSummary.notes} notes`);
+    lines.push(`Safe to apply: ${plan.safeToApply ? "yes" : "no"}`);
+    return lines.join("\n");
+}
+function renderStep(step) {
+    switch (step.kind) {
+        case "verify":
+            return [`- verify ${step.subject} [${step.status}]`, ...(step.detail ? [`  ${step.detail}`] : [])];
+        case "note":
+            return [`- note ${step.category}: ${step.message}`, ...(step.detail ? [`  ${step.detail}`] : [])];
+        case "ensure-directory":
+            return [`- ensure directory ${step.path}`, `  ${step.reason}`];
+        case "write-file":
+            return [
+                `- write file ${step.path} (${step.mode})`,
+                `  ${step.reason}`,
+                "  preview:",
+                ...step.content.split("\n").map((line) => `    ${line}`)
+            ];
+        case "delete-file":
+            return [`- delete file ${step.path}`, `  ${step.reason}`];
+        case "run-command":
+            return [
+                `- run ${step.executable} ${step.args.join(" ")}`.trim(),
+                `  ${step.reason}`
+            ];
+        case "publish-site":
+            return [
+                `- publish ${step.outputDir} to ${step.destination}`,
+                `  source: ${step.sourcePath}`,
+                `  mode: ${step.modeId}, target: ${step.targetKind}`,
+                `  remote: ${step.remote}, branch: ${step.branch}, force: ${step.force ? "yes" : "no"}`,
+                "  operations:",
+                ...step.operations.map((operation) => `  - ${operation}`)
+            ];
+    }
+}

package/docs/CANARY.md

@@ -0,0 +1,117 @@
+# Canary Validation
+
+This document records real-world disposable deploy validation.
+
+Status: passed.
+
+`deploy --apply --confirm-push` has been validated against a disposable Codeberg repository for the supported Vite to Codeberg Pages `git-pages` path.
+
+## Attempt Log
+
+### 2026-05-27
+
+Result: blocked before remote mutation.
+
+What was checked:
+
+- Local worktree was clean and synced with `origin/master`.
+- `https://codeberg.org/nyigoro/berg-pages-canary.git` does not exist yet.
+- No local `tea` CLI was available.
+- No `CODEBERG`, `FORGEJO`, `GITEA`, or `TEA` token environment variable was available.
+- Chrome was running, but the Codex Chrome Extension was not installed in the selected Chrome profile, so the authenticated Codeberg browser session could not be automated.
+
+Next unblock:
+
+- Create a disposable public Codeberg repository named `berg-pages-canary`, or provide an authenticated Codeberg creation path for that repository.
+- Then rerun the planned canary checklist below.
+
+### 2026-05-27 Passing Canary
+
+Date: 2026-05-27
+Codeberg repository: https://codeberg.org/nyigoro/berg-pages-canary
+Local canary path: `C:\Users\Donald\AppData\Local\Temp\berg-pages-canary-run`
+Local source branch before: `main`
+Local source branch after: `main`
+Local source commit before: `ecb2fd98d89d40ceeec245c3c31e5d0e2624e312`
+Local source commit after: `ecb2fd98d89d40ceeec245c3c31e5d0e2624e312`
+Dry-run output saved at: [canary/2026-05-27-deploy-dry-run.txt](canary/2026-05-27-deploy-dry-run.txt)
+Apply result: `Applied 1 deploy publish steps.`
+Remote pages branch commit: `75789b8ff7093bdea59c07b45f51b722f0ae27d2`
+Remote pages branch tree: `index.html`
+Pages URL: https://nyigoro.codeberg.page/berg-pages-canary/
+Pages URL verification: HTTP 200 and response contained `berg-pages canary deployed`
+Unexpected source worktree changes: none from deploy apply; expected local `init --apply` and `dist` files remained uncommitted in the disposable canary worktree
+Temporary publish cleanup notes: no `berg-pages-publish-*` directories remained in the temp directory after deploy apply
+Result: pass
+Notes: The first verification clone hit a transient Codeberg TLS close, then succeeded on retry. No product behavior was changed during the canary.
+
+## Planned Canary
+
+Use a throwaway public Codeberg repository and the supported path only:
+
+- Vite or minimal static project
+- generated `dist/index.html`
+- Codeberg project Pages target
+- `git-pages` deployment mode
+- no custom domain
+- no legacy v2 behavior
+
+## Commands
+
+Replace `<repo-path>` with the local checkout of the disposable repository.
+
+```bash
+npm run berg -- doctor <repo-path>
+npm run berg -- init --dry-run <repo-path>
+npm run berg -- init --apply <repo-path>
+```
+
+Create or build the minimal output:
+
+```bash
+mkdir -p <repo-path>/dist
+printf '<!doctype html><title>berg-pages canary</title>\n' > <repo-path>/dist/index.html
+```
+
+Then validate deploy:
+
+```bash
+npm run berg -- deploy --dry-run <repo-path>
+npm run berg -- deploy --apply --confirm-push <repo-path>
+```
+
+## Pass Checklist
+
+- `doctor` identifies the supported Codeberg project Pages path.
+- `init --dry-run` shows only the intended workflow creation.
+- `init --apply` writes only the planned workflow file.
+- `deploy --dry-run` shows publish source `dist`.
+- `deploy --dry-run` shows the expected Codeberg Pages URL.
+- `deploy --dry-run` shows the expected Codeberg remote.
+- `deploy --dry-run` shows branch `pages`.
+- `deploy --dry-run` shows force-push behavior.
+- `deploy --apply --confirm-push` succeeds.
+- Source branch stays unchanged.
+- Remote `pages` branch contains only intended output.
+- Published Pages URL responds.
+- Temporary publish repository cleanup is confirmed as far as practical.
+
+## Result Template
+
+Use this template after the canary runs.
+
+```text
+Date:
+Codeberg repository:
+Local source branch before:
+Local source branch after:
+Dry-run output saved at:
+Apply result:
+Remote pages branch commit:
+Pages URL:
+Pages URL verification:
+Unexpected source worktree changes:
+Temporary publish cleanup notes:
+Result: pass/fail
+Notes:
+```

package/docs/COMPATIBILITY.md

@@ -0,0 +1,88 @@
+# Compatibility
+
+This document describes the project shapes `berg-pages` currently understands and how contributors should think about compatibility changes.
+
+`berg-pages` is intentionally conservative. A project that is not clearly supported should receive diagnostics or safe refusal, not guessed deployment behavior.
+
+## Supported Project Shapes
+
+The current alpha supports Codeberg project Pages with the `git-pages` deployment mode for these project shapes:
+
+| Shape | Detection signals | Expected output |
+| --- | --- | --- |
+| Vite | `vite.config.*`, a `vite` dependency, or a Vite package script | `dist` |
+| Astro | `astro.config.*`, an `astro` dependency, or an Astro package script | `dist` |
+| Plain static | existing `dist` or `public` directory | `dist` preferred, then `public` |
+
+Supported commands for these shapes:
+
+- `berg-pages doctor .`
+- `berg-pages init --dry-run .`
+- `berg-pages init --apply .`
+- `berg-pages deploy --dry-run .`
+- `berg-pages deploy --apply --confirm-push .`
+
+Deploy commands do not run builds. The expected output directory must already exist before deploy planning can become safe.
+
+## Current Limits
+
+These shapes are intentionally outside the current supported path:
+
+- custom-domain deploy
+- legacy Codeberg Pages v2 behavior
+- root-only static sites that publish directly from repository root
+- framework-specific custom output directories
+- hosted CI execution beyond workflow file planning
+- frameworks other than Vite, Astro, and plain static output
+
+Unsupported shapes should produce diagnostics such as missing framework, missing output directory, missing target, or workflow conflict warnings.
+
+## Custom Domains
+
+`berg-pages` can detect a root `.domains` file and report it in `doctor`.
+
+That support is diagnostic only:
+
+- `doctor` may warn that custom-domain behavior is outside the supported `git-pages` path.
+- `init --dry-run` must not plan `.domains` changes.
+- `deploy --dry-run` must not add custom-domain publish behavior.
+- No command should write or modify `.domains`.
+
+## Existing Workflows
+
+Repositories with existing `.forgejo/workflows/*.yml` or `.forgejo/workflows/*.yaml` files are treated conservatively.
+
+If a workflow already exists outside the generated Pages workflow, `berg-pages` should:
+
+- warn in `doctor`
+- block generated workflow planning in `init --dry-run`
+- block deploy planning when the existing workflow may already publish or mutate deployment state
+
+This avoids silently adding a generated Pages workflow beside another deployment workflow.
+
+## Validation Expectations
+
+Compatibility changes should be validated with:
+
+```bash
+npm run typecheck
+npm run build
+npm test
+npm pack --dry-run
+```
+
+When validating a project shape manually, prefer non-mutating commands:
+
+```bash
+berg-pages doctor .
+berg-pages init --dry-run .
+berg-pages deploy --dry-run .
+```
+
+Do not use `init --apply`, `deploy --apply`, or push-capable behavior for compatibility exploration unless that mutation path is explicitly in scope.
+
+## Known Follow-Ups
+
+Root-level static Pages repositories are not yet supported unless they expose `dist` or `public`.
+
+If real-world validation keeps finding root `index.html` repositories, that should become its own milestone with acceptance criteria before implementation.

package/docs/DEPLOY-SAFETY.md

@@ -0,0 +1,113 @@
+# Deploy Safety
+
+This document describes what `berg-pages deploy` can and cannot mutate.
+
+## Supported Path
+
+The first deploy path is intentionally narrow:
+
+- Vite project
+- Codeberg project Pages URL under `codeberg.page`
+- `git-pages` deployment mode
+- generated site already present in `dist`
+- publish branch named `pages`
+- explicit apply command: `berg-pages deploy --apply --confirm-push`
+
+Codeberg Pages currently publishes `codeberg.page` sites through the newer `git-pages` service by pushing content to a branch named `pages`.
+
+## Dry Run
+
+`berg-pages deploy --dry-run` is non-mutating.
+
+It may inspect local files and git metadata, but it must not:
+
+- write files
+- run build commands
+- create commits
+- create, switch, reset, or delete branches
+- push to a remote
+- contact Codeberg
+- publish site content
+
+The dry-run plan must show:
+
+- publish source directory
+- Pages target URL
+- remote URL
+- publish branch
+- whether the future push is forced
+- the high-level git operations a future apply would perform
+
+## Apply
+
+`berg-pages deploy --apply --confirm-push` is push-capable.
+
+It may:
+
+- copy the planned output directory into a temporary publish repository
+- create a temporary commit from those copied files
+- force push that temporary commit to the planned `pages` branch
+- remove the temporary publish repository after success or failure
+
+It must not:
+
+- run `npm run build`
+- write generated files into the source project
+- create commits on the source branch
+- switch the source worktree branch
+- push to a remote other than the planned Codeberg remote
+- push to a branch other than `pages`
+- execute hidden file, branch, or command steps not shown in the deploy plan
+
+## Force Push
+
+The current supported deploy apply path force-pushes the `pages` branch.
+
+That is intentional because the publish branch is treated as generated output. It also means existing content on the remote `pages` branch can be replaced. The dry-run plan must make this visible before apply.
+
+## Temporary Repository
+
+Deploy apply creates a temporary repository outside the source worktree.
+
+The source worktree should remain untouched by publish mechanics:
+
+- no source branch switch
+- no source branch commit
+- no source worktree reset
+- no source `.git` mutation for the publish operation
+
+The temporary repository is removed in a cleanup step even when publish fails.
+
+## `.domains`
+
+Custom domains are not supported by the current deploy path.
+
+Deploy apply does not fetch an existing `pages` branch to preserve a remote `.domains` file. If a `.domains` file is present inside the planned output directory, it is copied with the rest of the output. Otherwise, any existing `.domains` file on the remote `pages` branch may be replaced by the force push.
+
+Do not use this deploy path for custom-domain sites until custom-domain acceptance criteria exist.
+
+## Refusal Behavior
+
+Deploy apply must refuse before publishing when:
+
+- `--confirm-push` is missing
+- the deploy plan has blocking diagnostics
+- the publish step is missing or ambiguous
+- the publish step targets a non-Codeberg remote
+- the publish step targets a branch other than `pages`
+- the plan includes hidden run-command, file, branch, or directory mutation steps
+
+## Canary Checklist
+
+Before an alpha tag, run one disposable real-world canary:
+
+- create a throwaway Codeberg repository
+- add a tiny `dist/index.html`
+- run `deploy --dry-run`
+- confirm the rendered source, target, remote, branch, and force-push operation
+- run `deploy --apply --confirm-push`
+- verify only the remote `pages` branch changed
+- verify the source branch stayed untouched
+- verify the published Pages URL works
+
+Record the result in [CANARY.md](CANARY.md). Do not expand deploy scope or tag an alpha until this canary passes.

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "berg-pages",
+  "version": "0.1.0-alpha.6",
+  "type": "module",
+  "description": "A plan-first Codeberg Pages onboarding and deployment CLI.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://codeberg.org/nyigoro/berg-pages.git"
+  },
+  "homepage": "https://codeberg.org/nyigoro/berg-pages",
+  "bugs": {
+    "url": "https://codeberg.org/nyigoro/berg-pages/issues"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "berg-pages": "dist/interfaces/cli/main.js"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "docs/COMPATIBILITY.md",
+    "docs/DEPLOY-SAFETY.md",
+    "docs/CANARY.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "berg": "tsx src/interfaces/cli/main.ts",
+    "build": "tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "tsx": "^4.22.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.8"
+  },
+  "directories": {
+    "doc": "docs",
+    "test": "tests"
+  },
+  "dependencies": {
+    "assertion-error": "^2.0.1",
+    "chai": "^6.2.2",
+    "convert-source-map": "^2.0.0",
+    "detect-libc": "^2.1.2",
+    "es-module-lexer": "^2.1.0",
+    "esbuild": "^0.28.0",
+    "estree-walker": "^3.0.3",
+    "expect-type": "^1.3.0",
+    "fdir": "^6.5.0",
+    "lightningcss": "^1.32.0",
+    "lightningcss-win32-x64-msvc": "^1.32.0",
+    "magic-string": "^0.30.21",
+    "nanoid": "^3.3.12",
+    "obug": "^2.1.1",
+    "pathe": "^2.0.3",
+    "picocolors": "^1.1.1",
+    "picomatch": "^4.0.4",
+    "postcss": "^8.5.15",
+    "rolldown": "^1.0.2",
+    "siginfo": "^2.0.0",
+    "source-map-js": "^1.2.1",
+    "stackback": "^0.0.2",
+    "std-env": "^4.1.0",
+    "tinybench": "^2.9.0",
+    "tinyexec": "^1.2.2",
+    "tinyglobby": "^0.2.16",
+    "tinyrainbow": "^3.1.0",
+    "undici-types": "^7.16.0",
+    "vite": "^8.0.14",
+    "why-is-node-running": "^2.3.0"
+  },
+  "keywords": [],
+  "author": ""
+}