void 0.1.6 → 0.7.0

package/dist/init-C7wS5iGP.mjs

@@ -0,0 +1,2625 @@
+import { a as join, i as isAbsolute, n as dirname, o as relative, s as resolve, t as basename } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { n as cliTitle } from "./output-BwlcIYSR.mjs";
+import { _ as me, c as R, g as ge, i as Ee, u as Se, v as ue, x as q, y as ye } from "./dist-Dayj3gCK.mjs";
+import { a as writeProjectConfig, r as readProjectConfig } from "./project-TqORyHn8.mjs";
+import { l as isStagingMode, n as PlatformClient, s as getToken } from "./client-snXOjrp1.mjs";
+import { c as getDatabaseDialect, f as readConfig } from "./config-BIa9HwVX.mjs";
+import { n as detectFramework } from "./plugin-inference-oZ6Ybu2_.mjs";
+import { r as parseDotenvFile, t as expandDotenv } from "./dotenv-DwO4ti0Z.mjs";
+import { n as ensureProjectTsconfig, t as createProjectTsconfig } from "./project-tsconfig-DfkESbDL.mjs";
+import { t as MagicString } from "./magic-string.es-D6g9UnIy.mjs";
+import { n as writeDrizzleConfig } from "./config-BzM9Dy7T.mjs";
+import { n as promptProjectSelection, t as promptAndCreateProject } from "./create-project-BIA15W7z.mjs";
+import { t as promptForLoginToken } from "./login-CkcXUiIu.mjs";
+import { r as formatProjectCommand } from "./preset-D4I73kT4.mjs";
+import { n as getAgentById, r as getPackageDir, t as detectAgents } from "./cli/cli.mjs";
+import { n as findInstalledYarnPnpRuntime, r as hasLocalLockfile, t as buildDrizzleKitSpawnEnv } from "./yarn-pnp-BFqMV_bl.mjs";
+import { createRequire } from "node:module";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { parse } from "jsonc-parser";
+import { spawnSync } from "node:child_process";
+//#region src/cli/deploy-setup.ts
+async function ensureToken(root) {
+	const existing = getToken(root);
+	if (existing) return existing;
+	const token = await promptForLoginToken(root);
+	R.success(isStagingMode(root) ? "Staging token saved." : "Token saved.");
+	return token;
+}
+async function maybeSetupDeployProject(root) {
+	const existing = readProjectConfig(root);
+	if (existing) {
+		R.info(`Project already linked: ${existing.slug}`);
+		return existing;
+	}
+	const existingToken = getToken(root);
+	const shouldSetup = await ue({ message: existingToken ? "Link your Void project now?" : "Log in now and link or create a Void project?" });
+	if (q(shouldSetup)) {
+		me("Setup cancelled.");
+		process.exit(0);
+	}
+	if (!shouldSetup) return null;
+	const client = new PlatformClient(existingToken ?? await ensureToken(root), { root });
+	const projects = await client.listProjects();
+	if (projects.length === 0) return promptAndCreateProject(root, client);
+	const result = await promptProjectSelection(projects, "Select a project to link:", root);
+	if (result.action === "select") {
+		const config = {
+			projectId: result.project.id,
+			slug: result.project.slug
+		};
+		writeProjectConfig(root, config);
+		R.success(`Linked project: ${config.slug}`);
+		return config;
+	}
+	return promptAndCreateProject(root, client);
+}
+//#endregion
+//#region src/cli/env-scaffold.ts
+/**
+* `void init` hook — when the project has no `env.ts` but has dotenv files
+* on disk, scaffold an `env.ts` whose keys mirror what the user already
+* has. Inference is intentionally permissive: we only upgrade from the
+* default `string()` helper when the value is unambiguously a boolean,
+* URL, or small integer. Everything else stays a string and carries a
+* one-line banner nudging the user to tighten the schema.
+*
+* This is a best-effort DX sweetener, not a correctness boundary — a
+* wrong guess only costs the user a single-line edit.
+*/
+/** Dotenv files we harvest keys from, in trust order (first wins per key). */
+const SCAFFOLD_SOURCE_FILES = [
+	".env",
+	".env.local",
+	".env.development",
+	".env.development.local",
+	".env.example"
+];
+const BOOLEAN_LITERAL = /^(true|false)$/i;
+const HTTP_URL = /^https?:\/\/\S+$/;
+const SMALL_INTEGER = /^(?:0|[1-9]\d{0,4})$/;
+/**
+* Classify a single `.env` value into the Void built-in helper to use.
+* Returns `'string'` whenever inference is ambiguous — the comment in the
+* scaffolded file asks the user to tighten any wrong guesses.
+*/
+function inferHelperForValue(value) {
+	if (!value) return "string";
+	const trimmed = value.trim();
+	if (!trimmed) return "string";
+	if (BOOLEAN_LITERAL.test(trimmed)) return "boolean";
+	if (HTTP_URL.test(trimmed)) return "url";
+	if (SMALL_INTEGER.test(trimmed)) return "number";
+	return "string";
+}
+/** Collect a deduped list of inferred entries from the dotenv files we find. */
+function collectInferredEntries(root) {
+	const seen = /* @__PURE__ */ new Map();
+	const cumulative = {};
+	for (const file of SCAFFOLD_SOURCE_FILES) {
+		const parsed = parseDotenvFile(join(root, file), { expand: false });
+		const expanded = expandDotenv({
+			...parsed,
+			...cumulative
+		});
+		for (const key of Object.keys(parsed)) {
+			const value = expanded[key] ?? "";
+			if (!(key in cumulative)) cumulative[key] = parsed[key];
+			const existing = seen.get(key);
+			if (!existing) seen.set(key, {
+				key,
+				helper: inferHelperForValue(value),
+				sampleValue: value || void 0
+			});
+			else if (!existing.sampleValue && value) seen.set(key, {
+				key,
+				helper: inferHelperForValue(value),
+				sampleValue: value
+			});
+		}
+	}
+	return [...seen.values()].sort((a, b) => a.key.localeCompare(b.key));
+}
+/**
+* Render the scaffolded `env.ts` body. The imports are pulled in lazily
+* so only helpers we reference appear in the import statement.
+*/
+function renderEnvTs(entries) {
+	if (entries.length === 0) return [
+		`import { defineEnv } from 'void/env';`,
+		``,
+		`// Define your environment variables here. See https://voidzero.dev/guide/env-vars`,
+		`export default defineEnv({});`,
+		``
+	].join("\n");
+	const helpers = new Set(["string"]);
+	for (const e of entries) helpers.add(e.helper);
+	const importList = [
+		"string",
+		"number",
+		"boolean",
+		"url"
+	].filter((h) => helpers.has(h));
+	const lines = [];
+	lines.push(`import { defineEnv, ${importList.join(", ")} } from 'void/env';`);
+	lines.push("");
+	lines.push(`// Scaffolded from your .env files. Inference is conservative — review each`);
+	lines.push(`// entry and tighten types as needed (e.g. oneOf([...]), url(), .optional(),`);
+	lines.push(`// .default(value), or a Standard Schema validator from valibot/zod/arktype).`);
+	lines.push(`export default defineEnv({`);
+	for (const entry of entries) lines.push(`  ${entry.key}: ${entry.helper}(),`);
+	lines.push(`});`);
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* If the project has no `env.ts`, scaffold one based on `.env*` files the
+* user already has. Safe to call unconditionally during `void init` — it
+* no-ops when `env.ts` is present. Never overwrites an existing file.
+*/
+function maybeScaffoldEnvTs(root) {
+	for (const candidate of [
+		"env.ts",
+		"env.mts",
+		"env.js",
+		"env.mjs"
+	]) if (existsSync(join(root, candidate))) return {
+		written: null,
+		skipReason: "env-ts-exists",
+		entries: []
+	};
+	for (const candidate of [
+		"src/env.ts",
+		"src/env.mts",
+		"src/env.js",
+		"src/env.mjs"
+	]) if (existsSync(join(root, candidate))) return {
+		written: null,
+		skipReason: "env-ts-exists",
+		entries: []
+	};
+	if (!SCAFFOLD_SOURCE_FILES.some((f) => existsSync(join(root, f)))) return {
+		written: null,
+		skipReason: "no-dotenv-files",
+		entries: []
+	};
+	const entries = collectInferredEntries(root);
+	const target = join(root, "env.ts");
+	writeFileSync(target, renderEnvTs(entries));
+	return {
+		written: target,
+		entries
+	};
+}
+//#endregion
+//#region src/cli/template.ts
+const SCAFFOLD_GITIGNORE_LINES = [
+	"node_modules",
+	"dist",
+	".void",
+	".wrangler",
+	"*.tsbuildinfo",
+	".DS_Store"
+];
+const SCAFFOLD_BASE_DEPENDENCIES = { hono: "^4.11.9" };
+const SCAFFOLD_BASE_DEV_DEPENDENCIES = {
+	vite: "^8.0.10",
+	typescript: "^5.9.3"
+};
+const REACT_SCAFFOLD_COMPILER_DEV_DEPENDENCIES = {
+	"@rolldown/plugin-babel": "^0.2.3",
+	"@vitejs/plugin-react": "^6.0.1",
+	"babel-plugin-react-compiler": "^1.0.0"
+};
+const SCAFFOLD_FRAMEWORK_OPTIONS = [
+	{
+		value: "react",
+		label: "React",
+		hint: "TSX Pages starter with the React adapter."
+	},
+	{
+		value: "vue",
+		label: "Vue",
+		hint: "Vue SFC Pages starter with the Vue adapter."
+	},
+	{
+		value: "svelte",
+		label: "Svelte",
+		hint: "Svelte 5 Pages starter with the Svelte adapter."
+	},
+	{
+		value: "solid",
+		label: "Solid",
+		hint: "Fine-grained TSX Pages starter with the Solid adapter."
+	}
+];
+const SCAFFOLD_FRAMEWORKS = {
+	react: {
+		label: "React",
+		adapterPackage: "@void/react",
+		adapterImport: "voidReact",
+		adapterPlugin: "@void/react/plugin",
+		pageExtension: "tsx",
+		dependencies: {
+			react: "^19.2.4",
+			"react-dom": "^19.2.4"
+		},
+		devDependencies: {
+			...REACT_SCAFFOLD_COMPILER_DEV_DEPENDENCIES,
+			"@types/react": "^19.2.14",
+			"@types/react-dom": "^19.2.3"
+		},
+		tsconfigCompilerOptions: { jsx: "react-jsx" }
+	},
+	vue: {
+		label: "Vue",
+		adapterPackage: "@void/vue",
+		adapterImport: "voidVue",
+		adapterPlugin: "@void/vue/plugin",
+		pageExtension: "vue",
+		dependencies: { vue: "^3.5.30" },
+		devDependencies: {},
+		tsconfigCompilerOptions: { jsx: "preserve" }
+	},
+	svelte: {
+		label: "Svelte",
+		adapterPackage: "@void/svelte",
+		adapterImport: "voidSvelte",
+		adapterPlugin: "@void/svelte/plugin",
+		pageExtension: "svelte",
+		dependencies: { svelte: "^5.53.9" },
+		devDependencies: {},
+		tsconfigCompilerOptions: {}
+	},
+	solid: {
+		label: "Solid",
+		adapterPackage: "@void/solid",
+		adapterImport: "voidSolid",
+		adapterPlugin: "@void/solid/plugin",
+		pageExtension: "tsx",
+		dependencies: { "solid-js": "^1.9.11" },
+		devDependencies: {},
+		tsconfigCompilerOptions: {
+			jsx: "preserve",
+			jsxImportSource: "solid-js"
+		}
+	}
+};
+function detectScaffoldFrameworkFromDependencies(deps) {
+	for (const [framework, config] of Object.entries(SCAFFOLD_FRAMEWORKS)) if (config.adapterPackage in deps) return framework;
+}
+function getScaffoldTsconfigCompilerOptions(framework) {
+	return framework ? { ...SCAFFOLD_FRAMEWORKS[framework].tsconfigCompilerOptions } : {};
+}
+function createPagesStarterTemplate(options) {
+	const { framework, starterMode, voidPackageSpec, adapterPackageSpec } = options;
+	const config = SCAFFOLD_FRAMEWORKS[framework];
+	const files = {
+		"vite.config.ts": getViteConfig(framework, config),
+		[`pages/index.${config.pageExtension}`]: getIndexPage(framework, starterMode)
+	};
+	if (starterMode !== "static") {
+		files["pages/index.server.ts"] = getIndexServer();
+		files["routes/api/hello.ts"] = getHelloRoute(config.label, starterMode);
+		files["db/schema.ts"] = getSchemaFile(starterMode);
+		files["db/seed.ts"] = getSeedFile();
+	}
+	return {
+		scripts: {
+			dev: "vite",
+			build: "vite build",
+			preview: "vite preview"
+		},
+		dependencies: {
+			...SCAFFOLD_BASE_DEPENDENCIES,
+			...config.dependencies
+		},
+		devDependencies: {
+			void: voidPackageSpec,
+			...SCAFFOLD_BASE_DEV_DEPENDENCIES,
+			[config.adapterPackage]: adapterPackageSpec,
+			...config.devDependencies
+		},
+		files
+	};
+}
+function getViteConfig(framework, config) {
+	if (framework === "react") return `import babel from "@rolldown/plugin-babel";
+import { reactCompilerPreset } from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+import { voidPlugin } from "void";
+import { ${config.adapterImport} } from "${config.adapterPlugin}";
+
+export default defineConfig({
+  plugins: [
+    babel({
+      presets: [reactCompilerPreset()],
+    }),
+    voidPlugin(),
+    ${config.adapterImport}(),
+  ],
+});
+`;
+	return `import { defineConfig } from "vite";
+import { voidPlugin } from "void";
+import { ${config.adapterImport} } from "${config.adapterPlugin}";
+
+export default defineConfig({
+  plugins: [voidPlugin(), ${config.adapterImport}()],
+});
+`;
+}
+function getIndexServer() {
+	return `import { defineHandler, type InferProps } from "void";
+import { db, desc } from "void/db";
+import { messages } from "@schema";
+
+export type Props = InferProps<typeof loader>;
+
+export const loader = defineHandler(async () => {
+  const rows = await db.select().from(messages).orderBy(desc(messages.id));
+  return { messages: rows };
+});
+`;
+}
+function getHelloRoute(frameworkLabel, starterMode) {
+	return `import { defineHandler } from "void";
+
+export const GET = defineHandler(() => {
+  return {
+    message: "Hello from Void",
+    framework: "${frameworkLabel}",
+    database: "${starterMode === "postgresql" ? "PostgreSQL" : "D1"}",
+  };
+});
+`;
+}
+function getSchemaFile(starterMode) {
+	if (starterMode === "postgresql") return `import { pgTable, serial, text, timestamp } from "void/schema-pg";
+
+export const messages = pgTable("messages", {
+  id: serial("id").primaryKey(),
+  text: text("text").notNull(),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+});
+`;
+	return `import { sql } from "void/db";
+import { integer, sqliteTable, text } from "void/schema-d1";
+
+export const messages = sqliteTable("messages", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  text: text("text").notNull(),
+  createdAt: text("created_at").notNull().default(sql\`(datetime('now'))\`),
+});
+`;
+}
+function getSeedFile() {
+	return `import { defineSeed } from "void/seed";
+
+const SAMPLE_MESSAGES = ["Hello from Void"];
+
+export default defineSeed<typeof import("./schema")>(async ({ db, schema }) => {
+  await db.insert(schema.messages).values(
+    SAMPLE_MESSAGES.map((text) => ({
+      text,
+    })),
+  );
+});
+`;
+}
+function getIndexPage(framework, starterMode) {
+	if (starterMode === "static") switch (framework) {
+		case "react": return `export default function HomePage() {
+  return (
+    <main>
+      <h1>Welcome to Void</h1>
+      <p>This starter is running in Pages mode with no database or server code yet.</p>
+      <p>
+        Add <code>pages/*.server.ts</code>, <code>routes/</code>, or <code>void/db</code> when
+        you want to grow into full-stack features.
+      </p>
+    </main>
+  );
+}
+`;
+		case "vue": return `<template>
+  <main>
+    <h1>Welcome to Void</h1>
+    <p>This starter is running in Pages mode with no database or server code yet.</p>
+    <p>
+      Add <code>pages/*.server.ts</code>, <code>routes/</code>, or <code>void/db</code> when you
+      want to grow into full-stack features.
+    </p>
+  </main>
+</template>
+`;
+		case "svelte": return `<main>
+  <h1>Welcome to Void</h1>
+  <p>This starter is running in Pages mode with no database or server code yet.</p>
+  <p>
+    Add <code>pages/*.server.ts</code>, <code>routes/</code>, or <code>void/db</code> when you
+    want to grow into full-stack features.
+  </p>
+</main>
+`;
+		case "solid": return `export default function HomePage() {
+  return (
+    <main>
+      <h1>Welcome to Void</h1>
+      <p>This starter is running in Pages mode with no database or server code yet.</p>
+      <p>
+        Add <code>pages/*.server.ts</code>, <code>routes/</code>, or <code>void/db</code> when
+        you want to grow into full-stack features.
+      </p>
+    </main>
+  );
+}
+`;
+	}
+	switch (framework) {
+		case "react": return `import type { Props } from "./index.server";
+
+export default function HomePage({ messages }: Props) {
+  return (
+    <main>
+      <h1>Welcome to Void</h1>
+      <p>
+        This starter is running in Pages mode. The list below is loaded from your database in
+        <code> pages/index.server.ts</code>.
+      </p>
+      <p>
+        API example: <a href="/api/hello">/api/hello</a>
+      </p>
+      {messages.length === 0 ? (
+        <p>
+          No messages yet. Run <code>void db seed</code> to load the sample row from
+          <code> db/seed.ts</code>.
+        </p>
+      ) : (
+        <ul>
+          {messages.map((message) => (
+            <li key={message.id}>
+              <strong>{message.text}</strong>
+              <br />
+              <small>{String(message.createdAt)}</small>
+            </li>
+          ))}
+        </ul>
+      )}
+    </main>
+  );
+}
+`;
+		case "vue": return `<script setup lang="ts">
+import type { Props } from "./index.server";
+
+defineProps<Props>();
+<\/script>
+
+<template>
+  <main>
+    <h1>Welcome to Void</h1>
+    <p>
+      This starter is running in Pages mode. The list below is loaded from your database in
+      <code>pages/index.server.ts</code>.
+    </p>
+    <p>
+      API example: <a href="/api/hello">/api/hello</a>
+    </p>
+    <p v-if="messages.length === 0">
+      No messages yet. Run <code>void db seed</code> to load the sample row from
+      <code>db/seed.ts</code>.
+    </p>
+    <ul v-else>
+      <li v-for="message in messages" :key="message.id">
+        <strong>{{ message.text }}</strong>
+        <br />
+        <small>{{ String(message.createdAt) }}</small>
+      </li>
+    </ul>
+  </main>
+</template>
+`;
+		case "svelte": return `<script lang="ts">
+  import type { Props } from "./index.server";
+
+  let { messages }: Props = $props();
+<\/script>
+
+<main>
+  <h1>Welcome to Void</h1>
+  <p>
+    This starter is running in Pages mode. The list below is loaded from your database in
+    <code>pages/index.server.ts</code>.
+  </p>
+  <p>
+    API example: <a href="/api/hello">/api/hello</a>
+  </p>
+  {#if messages.length === 0}
+    <p>
+      No messages yet. Run <code>void db seed</code> to load the sample row from
+      <code>db/seed.ts</code>.
+    </p>
+  {:else}
+    <ul>
+      {#each messages as message (message.id)}
+        <li>
+          <strong>{message.text}</strong>
+          <br />
+          <small>{String(message.createdAt)}</small>
+        </li>
+      {/each}
+    </ul>
+  {/if}
+</main>
+`;
+		case "solid": return `import type { Props } from "./index.server";
+
+export default function HomePage(props: Props) {
+  return (
+    <main>
+      <h1>Welcome to Void</h1>
+      <p>
+        This starter is running in Pages mode. The list below is loaded from your database in
+        <code> pages/index.server.ts</code>.
+      </p>
+      <p>
+        API example: <a href="/api/hello">/api/hello</a>
+      </p>
+      {props.messages.length === 0 ? (
+        <p>
+          No messages yet. Run <code>void db seed</code> to load the sample row from
+          <code> db/seed.ts</code>.
+        </p>
+      ) : (
+        <ul>
+          {props.messages.map((message) => (
+            <li>
+              <strong>{message.text}</strong>
+              <br />
+              <small>{String(message.createdAt)}</small>
+            </li>
+          ))}
+        </ul>
+      )}
+    </main>
+  );
+}
+`;
+	}
+}
+//#endregion
+//#region src/cli/init.ts
+function parseInitArgs(args) {
+	let parsed;
+	try {
+		parsed = parseArgs({
+			args,
+			options: {
+				tsconfig: { type: "boolean" },
+				github: { type: "boolean" },
+				agents: { type: "boolean" }
+			},
+			strict: true
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`init: ${message}.`);
+	}
+	return {
+		tsconfig: parsed.values.tsconfig === true,
+		github: parsed.values.github === true,
+		agents: parsed.values.agents === true
+	};
+}
+const EMPTY_PROJECT_ALLOWED_ENTRIES = new Set([
+	".git",
+	".gitignore",
+	"AGENTS.md",
+	"CLAUDE.md",
+	".node-version",
+	".npmrc",
+	".nvmrc",
+	".editorconfig",
+	".vscode",
+	".idea",
+	".DS_Store",
+	"node_modules",
+	"package.json",
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"yarn.lock",
+	"bun.lock",
+	"bun.lockb",
+	".agents",
+	".claude",
+	".cline",
+	".codex",
+	".continue",
+	".cursor",
+	".gemini",
+	".goose",
+	".junie",
+	".kilocode",
+	".kiro",
+	".opencode",
+	".qwen",
+	".roo",
+	".trae",
+	".windsurf",
+	".zencoder"
+]);
+const PNPM_ONLY_BUILT_DEPENDENCIES = [
+	"better-sqlite3",
+	"esbuild",
+	"workerd"
+];
+const drizzleKitBin = join(fileURLToPath(import.meta.resolve("drizzle-kit")), "..", "bin.cjs");
+const EMPTY_PROJECT_ALLOWED_PACKAGES = new Set([
+	"void",
+	"@void/react",
+	"@void/vue",
+	"@void/svelte",
+	"@void/solid"
+]);
+const VITE_CONFIG_FILES = [
+	"vite.config.ts",
+	"vite.config.js",
+	"vite.config.mts",
+	"vite.config.mjs",
+	"vite.config.cts",
+	"vite.config.cjs"
+];
+const VOID_CONFIG_FILE = "void.json";
+function asRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	return value;
+}
+function parseJsoncFile(path) {
+	const errors = [];
+	const parsed = asRecord(parse(readFileSync(path, "utf-8"), errors));
+	return errors.length === 0 ? parsed : null;
+}
+function uniqueStrings(values) {
+	return Array.from(new Set(values));
+}
+function normalizeRelativePath(fromDir, toPath) {
+	const rel = relative(fromDir, toPath).replaceAll("\\", "/");
+	return rel === ".." || rel.startsWith("../") || rel.startsWith("./") ? rel : `./${rel}`;
+}
+function getOwnConfigBaseUrlDir(config, configDir) {
+	const compilerOptions = asRecord(config.compilerOptions);
+	return compilerOptions && typeof compilerOptions.baseUrl === "string" ? resolve(configDir, compilerOptions.baseUrl) : null;
+}
+function getEffectiveConfigBaseUrlDir(config, configPath, seen) {
+	if (seen.has(configPath)) return null;
+	seen.add(configPath);
+	const ownBaseUrl = getOwnConfigBaseUrlDir(config, dirname(configPath));
+	if (ownBaseUrl) return ownBaseUrl;
+	const extendsValues = typeof config.extends === "string" ? [config.extends] : Array.isArray(config.extends) ? config.extends.filter((value) => typeof value === "string") : [];
+	let inheritedBaseUrl = null;
+	for (const extendsValue of extendsValues) {
+		const extendedPath = resolveExtendedTsconfig(configPath, extendsValue);
+		if (!extendedPath || !existsSync(extendedPath)) continue;
+		const extendedConfig = parseJsoncFile(extendedPath);
+		if (!extendedConfig) continue;
+		inheritedBaseUrl = getEffectiveConfigBaseUrlDir(extendedConfig, extendedPath, seen) ?? inheritedBaseUrl;
+	}
+	return inheritedBaseUrl;
+}
+function effectiveConfigPathBaseDir(config, configPath) {
+	return getEffectiveConfigBaseUrlDir(config, configPath, /* @__PURE__ */ new Set()) ?? dirname(configPath);
+}
+function convertConfigFileEntry(value, configDir, root) {
+	if (isAbsolute(value)) return normalizeRelativePath(root, value);
+	return normalizeRelativePath(root, resolve(configDir, value));
+}
+function convertPathTarget(value, fromBaseDir, toBaseDir) {
+	if (isAbsolute(value)) return normalizeRelativePath(toBaseDir, value);
+	return normalizeRelativePath(toBaseDir, resolve(fromBaseDir, value));
+}
+function mergePathMaps(target, source) {
+	for (const [key, values] of Object.entries(source)) target[key] = values;
+}
+function readStringArray(value) {
+	return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function readPaths(value) {
+	const paths = asRecord(value);
+	if (!paths) return {};
+	const result = {};
+	for (const [key, values] of Object.entries(paths)) {
+		const stringValues = readStringArray(values);
+		if (stringValues.length > 0) result[key] = stringValues;
+	}
+	return result;
+}
+function resolveExtendedTsconfig(fromConfigPath, specifier) {
+	if (specifier.startsWith(".") || specifier.startsWith("/")) {
+		const resolved = resolve(dirname(fromConfigPath), specifier);
+		return resolved.endsWith(".json") ? resolved : `${resolved}.json`;
+	}
+	try {
+		return createRequire(fromConfigPath).resolve(specifier);
+	} catch {
+		try {
+			return createRequire(fromConfigPath).resolve(`${specifier}.json`);
+		} catch {
+			return null;
+		}
+	}
+}
+function collectTsconfigPatchFromConfig(config, configPath, root, outputBaseDir, seen) {
+	const patch = {
+		files: [],
+		paths: {}
+	};
+	if (seen.has(configPath)) return patch;
+	seen.add(configPath);
+	const extendsValues = typeof config.extends === "string" ? [config.extends] : Array.isArray(config.extends) ? config.extends.filter((value) => typeof value === "string") : [];
+	const hasOwnFiles = Array.isArray(config.files);
+	const compilerOptions = asRecord(config.compilerOptions);
+	const hasOwnPaths = asRecord(compilerOptions?.paths) !== null;
+	for (const extendsValue of extendsValues) {
+		const extendedPath = resolveExtendedTsconfig(configPath, extendsValue);
+		if (!extendedPath || !existsSync(extendedPath)) continue;
+		const extendedConfig = parseJsoncFile(extendedPath);
+		if (!extendedConfig) continue;
+		const extendedPatch = collectTsconfigPatchFromConfig(extendedConfig, extendedPath, root, outputBaseDir, seen);
+		if (!hasOwnFiles) patch.files.push(...extendedPatch.files);
+		if (!hasOwnPaths) mergePathMaps(patch.paths, extendedPatch.paths);
+	}
+	const configDir = dirname(configPath);
+	if (hasOwnFiles) patch.files.push(...readStringArray(config.files).map((entry) => convertConfigFileEntry(entry, configDir, root)));
+	if (hasOwnPaths) {
+		const paths = readPaths(compilerOptions?.paths);
+		const pathBaseDir = effectiveConfigPathBaseDir(config, configPath);
+		const convertedPaths = {};
+		for (const [key, values] of Object.entries(paths)) convertedPaths[key] = values.map((value) => convertPathTarget(value, pathBaseDir, outputBaseDir));
+		mergePathMaps(patch.paths, convertedPaths);
+	}
+	return patch;
+}
+function createVoidTsconfigPatch(root, outputBaseDir) {
+	const hasSchema = hasDrizzleSchema(root);
+	return collectTsconfigPatchFromConfig(createProjectTsconfig(root, void 0, hasSchema, hasSchema), join(root, ".void", "tsconfig.json"), root, outputBaseDir, /* @__PURE__ */ new Set());
+}
+function isScaffoldableEmptyProject(root) {
+	for (const dir of [
+		"src",
+		"routes",
+		"db",
+		"migrations",
+		"middleware",
+		"crons",
+		"queues",
+		"pages"
+	]) if (existsSync(join(root, dir))) return false;
+	if (existsSync(join(root, "index.html"))) return false;
+	for (const file of VITE_CONFIG_FILES) if (existsSync(join(root, file))) return false;
+	for (const entry of readdirSync(root, { withFileTypes: true })) {
+		if (EMPTY_PROJECT_ALLOWED_ENTRIES.has(entry.name)) continue;
+		if (entry.name.startsWith("README")) continue;
+		return false;
+	}
+	const packageJsonPath = join(root, "package.json");
+	if (!existsSync(packageJsonPath)) return true;
+	let pkgRaw;
+	try {
+		pkgRaw = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+	} catch {
+		return false;
+	}
+	const pkg = asRecord(pkgRaw);
+	if (!pkg) return false;
+	const deps = {
+		...asRecord(pkg.dependencies) ?? {},
+		...asRecord(pkg.devDependencies) ?? {}
+	};
+	if (Object.keys(deps).some((dep) => !EMPTY_PROJECT_ALLOWED_PACKAGES.has(dep))) return false;
+	const scripts = asRecord(pkg.scripts) ?? {};
+	if (Object.keys(scripts).some((name) => name !== "test")) return false;
+	return true;
+}
+function parsePackageManagerField(pkg) {
+	if (!pkg || typeof pkg !== "object") return;
+	const raw = pkg.packageManager;
+	if (typeof raw !== "string") return;
+	const name = raw.split("@", 1)[0]?.trim();
+	if (name === "npm" || name === "pnpm" || name === "yarn" || name === "bun") return name;
+}
+/**
+* Returns `true` when a project should be treated as pnpm-managed for
+* purposes of installing build-script allowlists and picking a
+* `workspace:` rewrite strategy. We honor BOTH local signals — a committed
+* `pnpm-lock.yaml`, a local `pnpm-workspace.yaml`, or a Corepack
+* `packageManager: pnpm` pin in `package.json` — AND the same signals on
+* any ancestor workspace root.
+*
+* Ancestor walking matters for pnpm workspace subpackages: pnpm writes the
+* lockfile at the workspace root, not per-package, and many subpackages
+* omit their own `packageManager` field in favor of the workspace root's.
+* A subpackage with a `workspace:*` dep in its `package.json` but no local
+* pnpm markers is still pnpm-managed if the enclosing workspace root has
+* `pnpm-workspace.yaml`, a `pnpm-lock.yaml`, or `packageManager: pnpm@...`.
+*
+* Round 33: local non-pnpm signals MUST outrank the ancestor walk. A bun
+* or yarn subproject nested under a pnpm workspace ancestor is still
+* bun/yarn — its local `bun.lockb` / `yarn.lock` / `package-lock.json` or
+* a local Corepack pin for bun/yarn/npm proves the ancestor's pnpm shape
+* does not govern this subpackage. `detectProjectState` would pick
+* bun/yarn for such a project and try to install with that manager, so
+* the pnpm check must not inherit ancestor workspace state too eagerly.
+*/
+function isPnpmProject(root, pkg) {
+	if (existsSync(join(root, "pnpm-lock.yaml"))) return true;
+	if (existsSync(join(root, "pnpm-workspace.yaml"))) return true;
+	const localPm = parsePackageManagerField(pkg);
+	if (localPm === "pnpm") return true;
+	if (localPm === "bun" || localPm === "yarn" || localPm === "npm") return false;
+	if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock")) || existsSync(join(root, "yarn.lock")) || existsSync(join(root, "package-lock.json"))) return false;
+	return hasAncestorPnpmMarkers(root);
+}
+/**
+* Returns `true` when `start` is a declared member of an ancestor pnpm
+* workspace. Used to detect pnpm workspace subpackages whose enclosing
+* workspace root is pnpm-managed even when the subpackage has no local
+* pnpm signals.
+*
+* Round 43: an ancestor `pnpm-workspace.yaml` / `pnpm-lock.yaml` /
+* Corepack pnpm pin alone is NOT proof that `start` is governed by
+* that repo's pnpm install. A scratch app nested under a pnpm
+* monorepo is a separate project when its path doesn't match the
+* workspace globs. Previously this returned `true` too eagerly, and
+* `ensureVoidDependency` / `scaffoldPagesApp` then treated it like a
+* workspace member even though the subsequent local install used the
+* standalone fallback path.
+*
+* Delegate workspace membership to `findWorkspaceRoot` +
+* `isWorkspaceSubpackage` — the same check used by the
+* workspace-subpackage skip path in `runInitCommand` — so the two
+* paths can't disagree.
+*/
+function hasAncestorPnpmMarkers(start) {
+	const workspaceRoot = findWorkspaceRoot(start);
+	if (workspaceRoot === void 0) return false;
+	if (!isWorkspaceSubpackage(workspaceRoot, start)) return false;
+	if (existsSync(join(workspaceRoot, "pnpm-workspace.yaml"))) return true;
+	if (existsSync(join(workspaceRoot, "pnpm-lock.yaml"))) return true;
+	const pkgPath = join(workspaceRoot, "package.json");
+	if (existsSync(pkgPath)) try {
+		if (parsePackageManagerField(JSON.parse(readFileSync(pkgPath, "utf-8"))) === "pnpm") return true;
+	} catch {}
+	return false;
+}
+/**
+* Walk up from `start` checking each ancestor directory for a
+* `node_modules/void/package.json`. Mirrors Node's module resolution
+* algorithm for the `void` package name — returns true as soon as any
+* ancestor has `void` installed, false only when the entire chain is
+* empty. Used by the demo install gate so workspace subpackages whose
+* `void` is hoisted at the workspace root are detected as already
+* installed and we don't trigger a spurious subpackage install.
+*
+* PnP rationale: in a Yarn Berry PnP workspace, dependencies resolve
+* via `.pnp.cjs` at the workspace root and there is no `node_modules`
+* tree — not in the subpackage, not in ancestors. By the time we call
+* this, `scaffoldDemo`/`ensureVoidDependency` has added `void` to the
+* subpackage's `package.json` (or verified it was already there), and
+* under PnP the workspace-root install is what wires up resolution.
+*
+* Round 40: a committed-but-unfetched `.pnp.cjs` is NOT proof that
+* `yarn install` has run. Yarn Berry repos commonly commit `.pnp.cjs`
+* but gitignore `.yarn/cache/*.zip` (zero-install is opt-in), so a
+* fresh clone has the runtime file on disk while the archives it
+* points at are missing. The stricter `findInstalledYarnPnpRuntime`
+* also requires `<pnp-root>/.yarn/install-state.gz` — Yarn's canonical
+* post-install marker, gitignored by convention — as proof that yarn
+* install has actually populated the archives. Without that marker,
+* we fall through and return false so the caller triggers the install
+* step before attempting to spawn drizzle-kit.
+*/
+function isVoidResolvableFrom(start) {
+	let dir = start;
+	while (true) {
+		if (existsSync(join(dir, "node_modules", "void", "package.json"))) return true;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	const installed = findInstalledYarnPnpRuntime(start);
+	if (installed !== void 0) {
+		const probeArgs = installed.pnpCjs ? ["-e", "require.resolve('void')"] : [
+			"--input-type=module",
+			"-e",
+			"import.meta.resolve('void')"
+		];
+		const probe = spawnSync(process.execPath, probeArgs, {
+			cwd: start,
+			stdio: "ignore",
+			shell: process.platform === "win32",
+			env: buildDrizzleKitSpawnEnv(start)
+		});
+		return !probe.error && probe.status === 0;
+	}
+	return false;
+}
+/**
+* Walks ancestors from `start` looking for workspace-root markers: a
+* `pnpm-workspace.yaml` next to a `package.json`, or a `package.json`
+* whose top-level `workspaces` field exists (array or object). Returns
+* the discovered workspace root path if `start` is a subpackage inside
+* such a workspace, or `undefined` when it is not. Stops at the
+* filesystem root. Skips `start` itself — a root with its own
+* `workspaces` field is its own root, not a subpackage.
+*/
+function findWorkspaceRoot(start) {
+	let dir = dirname(start);
+	while (true) {
+		const pkgPath = join(dir, "package.json");
+		if (existsSync(pkgPath)) try {
+			const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+			if (pkg && typeof pkg === "object" && "workspaces" in pkg) return dir;
+		} catch {}
+		if (existsSync(join(dir, "pnpm-workspace.yaml"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return;
+		dir = parent;
+	}
+}
+/**
+* Read the declared workspace-member glob patterns from a workspace root.
+* Supports:
+*   - `pnpm-workspace.yaml` — extracts patterns under the top-level
+*     `packages:` key via a regex matcher (no `js-yaml` dep). Only the
+*     `packages:` key is used; pnpm-specific keys like `catalog:` are
+*     ignored.
+*   - `package.json#workspaces` — either an array of patterns or a
+*     `{ packages: [...] }` object form (npm/yarn/bun convention).
+*
+* Returns an empty array if no patterns are declared or parsing fails —
+* callers should treat that as "can't verify membership" and fall back
+* to the fresh-clone install path.
+*/
+function readWorkspacePatterns(workspaceRoot) {
+	const pnpmWorkspacePath = join(workspaceRoot, "pnpm-workspace.yaml");
+	if (existsSync(pnpmWorkspacePath)) try {
+		return extractPnpmWorkspacePackages(readFileSync(pnpmWorkspacePath, "utf-8"));
+	} catch {
+		return [];
+	}
+	const pkgPath = join(workspaceRoot, "package.json");
+	if (existsSync(pkgPath)) try {
+		const workspaces = JSON.parse(readFileSync(pkgPath, "utf-8")).workspaces;
+		if (Array.isArray(workspaces)) return workspaces.filter((x) => typeof x === "string");
+		if (workspaces && typeof workspaces === "object") {
+			const packages = workspaces.packages;
+			if (Array.isArray(packages)) return packages.filter((x) => typeof x === "string");
+		}
+	} catch {
+		return [];
+	}
+	return [];
+}
+/**
+* Strip a trailing YAML line comment from a raw line while preserving
+* `#` characters that live inside single- or double-quoted scalars.
+* YAML treats `#` as a comment marker only when it is preceded by
+* whitespace (or is the first column) AND it is not inside a quoted
+* scalar. Flow-style inline quoting is handled by a plain state machine
+* — no escape sequence support, because real-world workspace globs
+* never contain escaped quotes.
+*
+* This replaces the original `/\s+#.*$/` strip which was greedy and
+* would truncate legitimate quoted values like `- "path #hash/*"`,
+* leaving a broken glob that silently failed
+* `isWorkspaceSubpackage` membership.
+*/
+function stripYamlLineComment(line) {
+	let inSingle = false;
+	let inDouble = false;
+	for (let i = 0; i < line.length; i++) {
+		const ch = line[i];
+		if (inSingle) {
+			if (ch === "'") inSingle = false;
+			continue;
+		}
+		if (inDouble) {
+			if (ch === "\"") inDouble = false;
+			continue;
+		}
+		if (ch === "'") {
+			inSingle = true;
+			continue;
+		}
+		if (ch === "\"") {
+			inDouble = true;
+			continue;
+		}
+		if (ch === "#" && i > 0 && /\s/.test(line[i - 1])) return line.slice(0, i).replace(/\s+$/, "");
+	}
+	return line;
+}
+/**
+* Minimal YAML extractor for the `packages:` key of a
+* `pnpm-workspace.yaml`. Supports both the block-style form:
+*
+*   packages:
+*     - 'packages/*'
+*     - "apps/*"
+*     - docs
+*
+* and the flow-style (inline) form:
+*
+*   packages: ['packages/*', "apps/*"]
+*   packages: [packages/*]
+*
+* Anything else (other top-level keys, comments, nested blocks) is
+* ignored. This intentionally does NOT pull in `js-yaml` — the
+* surface area we need is tiny and the real YAML we see in practice
+* uses one of these two shapes.
+*/
+function extractPnpmWorkspacePackages(yaml) {
+	const lines = yaml.split(/\r?\n/);
+	const patterns = [];
+	let inPackages = false;
+	for (const rawLine of lines) {
+		const line = stripYamlLineComment(rawLine);
+		const inlineMatch = line.match(/^\s*packages\s*:\s*\[(.*)\]\s*$/);
+		if (inlineMatch) {
+			const items = inlineMatch[1].match(/(['"])(?:(?!\1).)*\1|[^,\s]+/g) ?? [];
+			for (const raw of items) {
+				const unquoted = raw.trim().replace(/^(['"])(.*)\1$/, "$2");
+				if (unquoted) patterns.push(unquoted);
+			}
+			inPackages = false;
+			continue;
+		}
+		if (/^\s*packages\s*:\s*$/.test(line)) {
+			inPackages = true;
+			continue;
+		}
+		if (!inPackages) continue;
+		if (/^[A-Za-z_][\w-]*\s*:\s*(?:\S.*)?$/.test(line) && !/^\s/.test(line)) {
+			inPackages = false;
+			continue;
+		}
+		const m = line.match(/^\s*-\s*(['"]?)([^'"\s][^'"]*?)\1\s*$/);
+		if (m) patterns.push(m[2]);
+	}
+	return patterns;
+}
+/**
+* Expand brace groups in a workspace glob pattern. Supports the forms
+* that appear in real workspace manifests, like `{apps,packages}/*`
+* and nested forms like `{apps,packages}/{core,web}`. Returns an array
+* of expanded patterns with no braces. No-op for patterns that don't
+* contain `{...}`. Does not support escaped braces or nested braces
+* inside a group (neither appears in real workspace manifests).
+*/
+function expandBraces(pattern) {
+	const match = pattern.match(/^([^{}]*)\{([^{}]*)\}(.*)$/);
+	if (!match) return [pattern];
+	const [, before, group, after] = match;
+	const options = group.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+	if (options.length === 0) return [pattern];
+	const results = [];
+	for (const opt of options) for (const sub of expandBraces(before + opt + after)) results.push(sub);
+	return results;
+}
+/**
+* Match a path against a workspace glob pattern. Supports the forms
+* that appear in real workspace manifests:
+*   - Literal path: `packages/void`              → exact match.
+*   - Leading `./`: `./packages/*`               → stripped before matching.
+*   - Single-segment glob: `packages/*`          → one segment under prefix.
+*   - Partial-segment glob: `packages/*-app`     → regex within a segment.
+*   - Recursive glob: `packages/**`              → any depth under prefix.
+*   - Brace expansion: `{apps,packages}/*`       → expanded before matching.
+* Does not support character classes or extended globs — those don't
+* appear in any workspace manifest we've seen, and adding a full
+* minimatch pulls in a dep we don't need.
+*/
+function matchesWorkspacePattern(relPath, pattern) {
+	return expandBraces(pattern).some((p) => matchesSingleWorkspacePattern(relPath, p));
+}
+function matchesSingleWorkspacePattern(relPath, pattern) {
+	const normalizedPattern = pattern.replace(/^\.\/+/, "");
+	return matchSegments(relPath.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean), 0, normalizedPattern.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean).map(compilePatternSegment), 0);
+}
+function compilePatternSegment(seg) {
+	if (seg === "**") return { kind: "globstar" };
+	if (!seg.includes("*")) return {
+		kind: "literal",
+		value: seg
+	};
+	return {
+		kind: "regex",
+		re: new RegExp("^" + seg.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*") + "$")
+	};
+}
+function matchSegments(path, pi, pat, qi) {
+	while (qi < pat.length) {
+		const seg = pat[qi];
+		if (seg.kind === "globstar") {
+			if (qi === pat.length - 1) return true;
+			for (let k = pi; k <= path.length; k++) if (matchSegments(path, k, pat, qi + 1)) return true;
+			return false;
+		}
+		if (pi >= path.length) return false;
+		if (seg.kind === "literal") {
+			if (seg.value !== path[pi]) return false;
+		} else if (!seg.re.test(path[pi])) return false;
+		pi++;
+		qi++;
+	}
+	return pi === path.length;
+}
+/**
+* Verify that `root` is actually a declared member of the workspace
+* rooted at `workspaceRoot`. An ancestor workspace root found by
+* `findWorkspaceRoot` is not enough — a standalone app nested under a
+* monorepo (e.g. `repo/scratch/my-app` inside a repo whose
+* `pnpm-workspace.yaml` only lists `packages/*`) is NOT a workspace
+* subpackage, and treating it as one leaves the demo scaffold in a
+* broken state: install is skipped, `generateStarterMigration` is
+* skipped, and the user ends up with unresolved `void` imports.
+*
+* Supports positive and negation (`!pattern`) patterns. A path is
+* considered a member if it matches at least one positive pattern and
+* no negation pattern.
+*
+* Returns `false` if no patterns are declared at all — callers treat
+* that as "not a subpackage" so the fresh-clone install path still runs.
+*/
+function isWorkspaceSubpackage(workspaceRoot, root) {
+	const relPath = relative(workspaceRoot, root);
+	if (relPath === "" || relPath.startsWith("..")) return false;
+	const normalized = relPath.split(/[\\/]/).join("/");
+	const patterns = readWorkspacePatterns(workspaceRoot);
+	if (patterns.length === 0) return false;
+	let matched = false;
+	for (const raw of patterns) {
+		const isNegation = raw.startsWith("!");
+		if (matchesWorkspacePattern(normalized, isNegation ? raw.slice(1) : raw)) {
+			if (isNegation) return false;
+			matched = true;
+		}
+	}
+	return matched;
+}
+/**
+* Returns true iff `root` is structurally a declared member of an
+* ancestor workspace — regardless of whether the subpackage manages its
+* own install via a local lockfile or Corepack pin. This is the signal
+* Step 8 (GitHub Actions) uses: `.github/workflows/*` files are only
+* read from the repository root, so dropping them under a subpackage
+* root is always wrong, whether or not the subpackage self-manages
+* install.
+*/
+function isInsideWorkspaceSubpackage(root) {
+	const workspaceRoot = findWorkspaceRoot(root);
+	if (workspaceRoot === void 0) return false;
+	return isWorkspaceSubpackage(workspaceRoot, root);
+}
+/**
+* Returns the workspace root if `root` should defer its install +
+* starter migration to a parent workspace install — i.e. it is a
+* declared member of an ancestor workspace AND has no local lockfile or
+* non-pnpm Corepack pin claiming it manages its own install. Returns
+* undefined when `root` is either not a subpackage at all, or is a
+* leaf-managed project nested inside a workspace.
+*
+* This is the single source of truth used by both the starter and the
+* demo branches in `runInitCommand` so they can never disagree about
+* whether to skip install/migration.
+*/
+function resolveWorkspaceDeferral(root, pkg) {
+	const workspaceRoot = findWorkspaceRoot(root);
+	if (workspaceRoot === void 0) return;
+	if (!isWorkspaceSubpackage(workspaceRoot, root)) return;
+	if (hasLocalLockfile(root)) return;
+	const localPm = parsePackageManagerField(pkg);
+	if (localPm === "bun" || localPm === "yarn" || localPm === "npm") return;
+	return { workspaceRoot };
+}
+function detectProjectState(root) {
+	let hasTypescript = false;
+	let pkg;
+	try {
+		pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"));
+		const pkgRecord = pkg ?? {};
+		const allDeps = {
+			...asRecord(pkgRecord.dependencies) ?? {},
+			...asRecord(pkgRecord.devDependencies) ?? {}
+		};
+		hasTypescript = "typescript" in allDeps || "@typescript/native-preview" in allDeps;
+	} catch {}
+	let packageManager;
+	if (existsSync(join(root, "pnpm-lock.yaml"))) packageManager = "pnpm";
+	else if (existsSync(join(root, "yarn.lock"))) packageManager = "yarn";
+	else if (existsSync(join(root, "bun.lock")) || existsSync(join(root, "bun.lockb"))) packageManager = "bun";
+	else if (existsSync(join(root, "pnpm-workspace.yaml"))) packageManager = "pnpm";
+	else {
+		const field = parsePackageManagerField(pkg);
+		if (field === "pnpm" || field === "yarn" || field === "bun") packageManager = field;
+		else packageManager = "npm";
+	}
+	return {
+		hasTypescript,
+		hasTsconfig: existsSync(join(root, "tsconfig.json")),
+		hasGithubWorkflows: existsSync(join(root, ".github", "workflows")),
+		hasRoutes: existsSync(join(root, "routes")),
+		hasMigrations: existsSync(join(root, "db", "migrations")) || existsSync(join(root, "migrations")),
+		hasPages: existsSync(join(root, "pages")),
+		packageManager,
+		typescriptWanted: hasTypescript
+	};
+}
+function findViteConfig(root) {
+	return VITE_CONFIG_FILES.find((file) => existsSync(join(root, file)));
+}
+function hasDrizzleSchema(root) {
+	return existsSync(join(root, "db", "schema.ts")) || existsSync(join(root, "db", "schema"));
+}
+function detectPagesFramework(root) {
+	try {
+		const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"));
+		return detectScaffoldFrameworkFromDependencies({
+			...asRecord(pkg.dependencies) ?? {},
+			...asRecord(pkg.devDependencies) ?? {}
+		});
+	} catch {
+		return;
+	}
+}
+function readPackageJson(root) {
+	try {
+		return asRecord(JSON.parse(readFileSync(join(root, "package.json"), "utf-8"))) ?? void 0;
+	} catch {
+		return;
+	}
+}
+const DEPENDENCY_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+function getDeclaredDependencySpec(root, packageName) {
+	const pkg = readPackageJson(root);
+	if (!pkg) return;
+	for (const field of DEPENDENCY_FIELDS) {
+		const group = asRecord(pkg[field]);
+		if (typeof group?.[packageName] === "string") return group[packageName];
+	}
+}
+function resolveScaffoldDependencySpec(root, packageName, fallbackVersion) {
+	const explicit = getDeclaredDependencySpec(root, packageName);
+	if (explicit) return explicit;
+	return fallbackVersion;
+}
+function setupTsconfig(root, state, pagesFramework) {
+	const tsconfigPath = join(root, "tsconfig.json");
+	if (state.hasTsconfig) {
+		let tsconfig;
+		try {
+			const parsed = parseJsoncFile(tsconfigPath);
+			if (!parsed) throw new SyntaxError("Failed to parse tsconfig.json");
+			tsconfig = parsed;
+		} catch {
+			R.warn("Could not parse tsconfig.json, skipping");
+			return;
+		}
+		let updated = false;
+		const rootPathBaseDir = effectiveConfigPathBaseDir(tsconfig, tsconfigPath);
+		const existingPatch = collectTsconfigPatchFromConfig(tsconfig, tsconfigPath, root, rootPathBaseDir, /* @__PURE__ */ new Set());
+		const voidPatch = createVoidTsconfigPatch(root, rootPathBaseDir);
+		const extendsValue = tsconfig.extends;
+		const target = "./.void/tsconfig.json";
+		if (!(extendsValue === target || Array.isArray(extendsValue) && extendsValue.includes(target))) {
+			if (typeof extendsValue === "string") tsconfig.extends = [extendsValue, target];
+			else if (Array.isArray(extendsValue)) tsconfig.extends = [...extendsValue, target];
+			else tsconfig.extends = target;
+			updated = true;
+			R.success("Updated tsconfig.json — added extends .void/tsconfig.json");
+		}
+		const compilerOptions = asRecord(tsconfig.compilerOptions) ?? {};
+		tsconfig.compilerOptions = compilerOptions;
+		const types = Array.isArray(compilerOptions.types) ? compilerOptions.types.filter((value) => typeof value === "string") : [];
+		if (!types.includes("void/env")) {
+			types.push("void/env");
+			updated = true;
+			R.success("Updated tsconfig.json — added void/env to types");
+		}
+		const cfIdx = types.indexOf("@cloudflare/workers-types");
+		if (cfIdx !== -1) {
+			types.splice(cfIdx, 1);
+			updated = true;
+			R.success("Removed @cloudflare/workers-types from tsconfig types (included in void/env)");
+		}
+		compilerOptions.types = types;
+		const existingFiles = uniqueStrings(existingPatch.files);
+		if (existingFiles.length > 0 || Array.isArray(tsconfig.files)) {
+			const files = uniqueStrings([...existingFiles, ...voidPatch.files]);
+			if (JSON.stringify(tsconfig.files) !== JSON.stringify(files)) {
+				tsconfig.files = files;
+				updated = true;
+				R.success("Updated tsconfig.json — merged generated Void type files");
+			}
+		}
+		if (Object.keys(existingPatch.paths).length > 0 || asRecord(compilerOptions.paths) !== null) {
+			const paths = { ...existingPatch.paths };
+			mergePathMaps(paths, voidPatch.paths);
+			const existingPaths = readPaths(compilerOptions.paths);
+			if (JSON.stringify(existingPaths) !== JSON.stringify(paths)) {
+				compilerOptions.paths = paths;
+				updated = true;
+				R.success("Updated tsconfig.json — merged generated Void path aliases");
+			}
+		}
+		if (updated) {
+			const { extends: ext, ...rest } = tsconfig;
+			const ordered = {
+				extends: ext,
+				...rest
+			};
+			writeFileSync(tsconfigPath, JSON.stringify(ordered, null, 2) + "\n");
+		} else R.success("tsconfig.json looks good");
+		try {
+			const pkgPath = join(root, "package.json");
+			const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+			let pkgUpdated = false;
+			if (pkg.dependencies?.["@cloudflare/workers-types"]) {
+				delete pkg.dependencies["@cloudflare/workers-types"];
+				pkgUpdated = true;
+			}
+			if (pkg.devDependencies?.["@cloudflare/workers-types"]) {
+				delete pkg.devDependencies["@cloudflare/workers-types"];
+				pkgUpdated = true;
+			}
+			if (pkgUpdated) {
+				writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+				R.success("Removed @cloudflare/workers-types from package.json (included in void/env)");
+				R.info(`Re-run ${state.packageManager} install to update your lockfile`);
+			}
+		} catch {}
+	} else {
+		const tsconfig = {
+			extends: "./.void/tsconfig.json",
+			compilerOptions: {
+				target: "ES2022",
+				module: "ESNext",
+				moduleResolution: "bundler",
+				strict: true,
+				esModuleInterop: true,
+				skipLibCheck: true,
+				types: ["void/env"],
+				...getScaffoldTsconfigCompilerOptions(pagesFramework)
+			},
+			include: [
+				"src",
+				"pages",
+				"routes",
+				"middleware",
+				"crons",
+				"queues",
+				"db"
+			]
+		};
+		writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+		R.success("Created tsconfig.json");
+		if (!state.hasTypescript) R.info("Don't forget to install typescript");
+	}
+}
+/** Today's UTC date as YYYY-MM-DD for wrangler compatibility_date. */
+function getTodayCompatDate() {
+	const d = /* @__PURE__ */ new Date();
+	return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`;
+}
+function readProjectWranglerCompatDate(root) {
+	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
+		const configPath = join(root, name);
+		if (!existsSync(configPath)) continue;
+		try {
+			const raw = readFileSync(configPath, "utf-8");
+			const errors = [];
+			const parsed = parse(raw, errors);
+			if (errors.length > 0) throw new SyntaxError("Failed to parse JSONC");
+			if (typeof parsed?.compatibility_date === "string") return parsed.compatibility_date;
+		} catch {}
+	}
+}
+/**
+* Ensure wrangler.jsonc exists with `compatibility_date` and `nodejs_als` flag
+* for class B/C meta-frameworks that need it for local dev.
+*/
+function setupWranglerConfig(root, framework) {
+	if (framework.class === "a") return;
+	let configPath;
+	let parsed;
+	let created = false;
+	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
+		const p = join(root, name);
+		if (existsSync(p)) {
+			configPath = p;
+			try {
+				const raw = readFileSync(p, "utf-8");
+				const errors = [];
+				parsed = parse(raw, errors);
+				if (errors.length > 0) throw new SyntaxError("Failed to parse JSONC");
+			} catch {}
+			break;
+		}
+	}
+	if (!configPath || !parsed) {
+		configPath = join(root, "wrangler.jsonc");
+		parsed = {};
+		created = true;
+	}
+	let modified = false;
+	if (!parsed.compatibility_date) {
+		parsed.compatibility_date = getTodayCompatDate();
+		modified = true;
+	}
+	const flags = Array.isArray(parsed.compatibility_flags) ? parsed.compatibility_flags : [];
+	if (!flags.includes("nodejs_als")) {
+		parsed.compatibility_flags = [...flags, "nodejs_als"];
+		modified = true;
+	}
+	if (created || modified) {
+		writeFileSync(configPath, JSON.stringify(parsed, null, 2) + "\n");
+		if (created) R.success("Created wrangler.jsonc with compatibility_date and nodejs_als");
+		else R.success("Updated wrangler.jsonc with compatibility_date and nodejs_als");
+	} else R.success("wrangler.jsonc looks good");
+}
+function writeVoidConfig(root, config) {
+	writeFileSync(join(root, VOID_CONFIG_FILE), JSON.stringify(config, null, 2) + "\n");
+}
+function ensureVoidWorkerCompatibilityDate(root) {
+	const config = readConfig(root);
+	if (typeof config.target === "string" && config.target !== "cloudflare") return;
+	const worker = asRecord(config.worker) ?? {};
+	if (typeof worker.compatibility_date === "string" && worker.compatibility_date.length > 0) return;
+	const compatibilityDate = readProjectWranglerCompatDate(root) ?? getTodayCompatDate();
+	config.worker = {
+		...worker,
+		compatibility_date: compatibilityDate
+	};
+	writeVoidConfig(root, config);
+	R.success("Pinned worker compatibility_date in void.json");
+}
+function clearConfiguredDatabase(root, messages) {
+	const config = readConfig(root);
+	const configPath = join(root, VOID_CONFIG_FILE);
+	if (config.database !== "pg") {
+		R.info(messages.unchanged);
+		return;
+	}
+	delete config.database;
+	if (Object.keys(config).length === 0) {
+		unlinkSync(configPath);
+		R.success(messages.updated);
+		return;
+	}
+	writeVoidConfig(root, config);
+	R.success(messages.updated);
+}
+function applyDatabaseDialect(root, dialect) {
+	const config = readConfig(root);
+	if (dialect === "postgresql") {
+		if (config.database === "pg") {
+			R.info("PostgreSQL already configured in void.json");
+			return;
+		}
+		config.database = "pg";
+		writeVoidConfig(root, config);
+		R.success("Configured PostgreSQL in void.json");
+		return;
+	}
+	clearConfiguredDatabase(root, {
+		unchanged: "Using default D1 (SQLite) configuration",
+		updated: "Updated void.json to use the default D1 (SQLite) configuration"
+	});
+}
+function detectDatabaseSetup(root) {
+	if (getDatabaseDialect(readConfig(root)) === "postgresql") return "postgresql";
+	if (hasDrizzleSchema(root) || existsSync(join(root, "db", "migrations")) || existsSync(join(root, "migrations"))) return "sqlite";
+	return "none";
+}
+function applyDatabaseSetup(root, choice) {
+	if (choice === "none") {
+		clearConfiguredDatabase(root, {
+			unchanged: "No database configured yet",
+			updated: "Removed database config from void.json"
+		});
+		return;
+	}
+	applyDatabaseDialect(root, choice);
+}
+async function promptStarterMode() {
+	const choice = await Ee({
+		message: "Choose a Pages starter:",
+		options: [
+			{
+				value: "sqlite",
+				label: "D1 (SQLite)",
+				hint: "Recommended starter. Scaffolds a DB-backed page, schema, generated migration, seed file, and API route."
+			},
+			{
+				value: "postgresql",
+				label: "PostgreSQL",
+				hint: "Scaffolds the same starter with PostgreSQL, a generated migration, a seed file, and writes \"database\": \"pg\" to void.json."
+			},
+			{
+				value: "static",
+				label: "Static Pages",
+				hint: "No database or server starter files yet. Good for content sites; add Void features later."
+			}
+		]
+	});
+	if (q(choice)) {
+		me("Setup cancelled.");
+		process.exit(0);
+	}
+	return choice;
+}
+async function promptScaffoldFramework() {
+	const choice = await Ee({
+		message: "Choose a Pages framework to scaffold:",
+		options: [...SCAFFOLD_FRAMEWORK_OPTIONS]
+	});
+	if (q(choice)) {
+		me("Setup cancelled.");
+		process.exit(0);
+	}
+	return choice;
+}
+async function promptDatabaseSetup(root) {
+	const currentSetup = detectDatabaseSetup(root);
+	const choice = await Ee({
+		message: "Choose a database setup for this project:",
+		initialValue: currentSetup === "none" ? "sqlite" : currentSetup,
+		options: [
+			{
+				value: "sqlite",
+				label: currentSetup === "sqlite" ? "D1 (SQLite) [current]" : "D1 (SQLite)",
+				hint: "Zero-config and fully managed by Void; best for prototyping and read-heavy apps."
+			},
+			{
+				value: "postgresql",
+				label: currentSetup === "postgresql" ? "PostgreSQL [current]" : "PostgreSQL",
+				hint: "Bring your own Postgres via Hyperdrive; best for write-heavy apps, complex queries, or existing infra."
+			},
+			{
+				value: "none",
+				label: "No Database Yet",
+				hint: "Skip database setup for now. You can add D1 or PostgreSQL later as your app grows."
+			}
+		]
+	});
+	if (q(choice)) {
+		me("Setup cancelled.");
+		process.exit(0);
+	}
+	return choice;
+}
+/** Get the dev command for a detected framework. */
+function getDevCommand(root, framework) {
+	if (!framework) return formatProjectCommand(root, "vite dev");
+	switch (framework.name) {
+		case "nuxt": return "nuxt dev";
+		case "astro": return "astro dev";
+		default: return formatProjectCommand(root, "vite dev");
+	}
+}
+function getNodeVersionLine(root) {
+	if (existsSync(join(root, ".node-version"))) return "node-version-file: .node-version";
+	return "node-version: lts/*";
+}
+function getWorkflowYaml(root, pm) {
+	const nodeVersion = getNodeVersionLine(root);
+	switch (pm) {
+		case "pnpm": return `name: Deploy
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: pnpm/action-setup@v5
+      - uses: actions/setup-node@v6
+        with:
+          ${nodeVersion}
+          cache: pnpm
+      - run: pnpm install
+      - run: pnpm void deploy
+        env:
+          VOID_TOKEN: \${{ secrets.VOID_TOKEN }}
+`;
+		case "yarn": return `name: Deploy
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          ${nodeVersion}
+          cache: yarn
+      - run: yarn install --immutable
+      - run: yarn void deploy
+        env:
+          VOID_TOKEN: \${{ secrets.VOID_TOKEN }}
+`;
+		case "bun": return `name: Deploy
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: oven-sh/setup-bun@v2
+      - run: bun install
+      - run: bunx void deploy
+        env:
+          VOID_TOKEN: \${{ secrets.VOID_TOKEN }}
+`;
+		default: return `name: Deploy
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          ${nodeVersion}
+          cache: npm
+      - run: npm ci
+      - run: npx void deploy
+        env:
+          VOID_TOKEN: \${{ secrets.VOID_TOKEN }}
+`;
+	}
+}
+function setupGithubActions(root, state) {
+	const workflowPath = join(root, ".github", "workflows", "deploy.yml");
+	if (existsSync(workflowPath)) {
+		R.warn("deploy.yml already exists, skipping");
+		return;
+	}
+	mkdirSync(join(root, ".github", "workflows"), { recursive: true });
+	writeFileSync(workflowPath, getWorkflowYaml(root, state.packageManager));
+	R.success("Created .github/workflows/deploy.yml");
+	Se("After init completes, run `npx void auth token` to copy a deploy token.\nThen add it in GitHub under Settings → Secrets and variables → Actions as `VOID_TOKEN`.", "GitHub Actions deploy token");
+}
+function writeFileIfMissing(root, filePath, content) {
+	const fullPath = join(root, filePath);
+	if (existsSync(fullPath)) return;
+	mkdirSync(dirname(fullPath), { recursive: true });
+	writeFileSync(fullPath, content);
+	R.success(`Created ${filePath}`);
+}
+function ensureGitignore(root) {
+	const gitignorePath = join(root, ".gitignore");
+	if (!existsSync(gitignorePath)) {
+		writeFileSync(gitignorePath, SCAFFOLD_GITIGNORE_LINES.join("\n") + "\n");
+		R.success("Created .gitignore");
+		return;
+	}
+	const content = readFileSync(gitignorePath, "utf-8");
+	const existing = new Set(content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+	const missing = SCAFFOLD_GITIGNORE_LINES.filter((line) => !existing.has(line));
+	if (missing.length === 0) return;
+	writeFileSync(gitignorePath, content + (content.endsWith("\n") ? "" : "\n") + missing.join("\n") + "\n");
+	R.success("Updated .gitignore with Void defaults");
+}
+function ensurePnpmBuiltDependencies(pkg) {
+	const pnpm = asRecord(pkg.pnpm) ?? {};
+	pkg.pnpm = pnpm;
+	const onlyBuiltDependencies = Array.isArray(pnpm.onlyBuiltDependencies) ? pnpm.onlyBuiltDependencies.filter((value) => typeof value === "string") : [];
+	for (const dependency of PNPM_ONLY_BUILT_DEPENDENCIES) if (!onlyBuiltDependencies.includes(dependency)) onlyBuiltDependencies.push(dependency);
+	pnpm.onlyBuiltDependencies = onlyBuiltDependencies;
+}
+function installProjectDependencies(root, packageManager) {
+	R.step(`Installing dependencies with ${packageManager}`);
+	const result = spawnSync(packageManager, ["install"], {
+		cwd: root,
+		stdio: "inherit",
+		shell: process.platform === "win32"
+	});
+	if (result.error) throw result.error;
+	if (result.status !== 0) throw new Error(`${packageManager} install failed with exit code ${result.status ?? "unknown"}`);
+	R.success(`Installed dependencies with ${packageManager}`);
+}
+function generateStarterMigration(root, starterMode) {
+	const dialect = starterMode === "postgresql" ? "postgresql" : "sqlite";
+	const configPath = writeDrizzleConfig(root, dialect === "postgresql" ? "postgresql://dummy" : ":memory:", dialect);
+	const migrationsDir = join(root, "db", "migrations");
+	const metaDir = join(migrationsDir, "meta");
+	const journalPath = join(metaDir, "_journal.json");
+	const migrationsDirExistedBefore = existsSync(migrationsDir);
+	const metaDirExistedBefore = existsSync(metaDir);
+	const originalJournalBytes = existsSync(journalPath) ? readFileSync(journalPath) : null;
+	const snapshotsBefore = metaDirExistedBefore ? new Set(readdirSync(metaDir).filter((f) => f.endsWith("_snapshot.json"))) : /* @__PURE__ */ new Set();
+	const sqlFilesBefore = migrationsDirExistedBefore ? new Set(readdirSync(migrationsDir).filter((f) => f.endsWith(".sql"))) : /* @__PURE__ */ new Set();
+	R.step("Generating initial Drizzle migration");
+	const result = spawnSync(process.execPath, [
+		drizzleKitBin,
+		"generate",
+		"--config",
+		configPath
+	], {
+		cwd: root,
+		stdio: "pipe",
+		encoding: "utf-8",
+		shell: process.platform === "win32",
+		env: buildDrizzleKitSpawnEnv(root)
+	});
+	if (Boolean(result.error) || result.status !== 0) {
+		if (originalJournalBytes !== null) try {
+			writeFileSync(journalPath, originalJournalBytes);
+		} catch {}
+		else if (!metaDirExistedBefore && existsSync(metaDir)) try {
+			for (const f of readdirSync(metaDir)) try {
+				unlinkSync(join(metaDir, f));
+			} catch {}
+			try {
+				rmdirSync(metaDir);
+			} catch {}
+		} catch {}
+		if (metaDirExistedBefore && existsSync(metaDir)) {
+			for (const f of readdirSync(metaDir)) if (f.endsWith("_snapshot.json") && !snapshotsBefore.has(f)) try {
+				unlinkSync(join(metaDir, f));
+			} catch {}
+		}
+		if (!migrationsDirExistedBefore && existsSync(migrationsDir)) try {
+			for (const f of readdirSync(migrationsDir)) if (f.endsWith(".sql")) try {
+				unlinkSync(join(migrationsDir, f));
+			} catch {}
+		} catch {}
+		else if (migrationsDirExistedBefore && existsSync(migrationsDir)) {
+			for (const f of readdirSync(migrationsDir)) if (f.endsWith(".sql") && !sqlFilesBefore.has(f)) try {
+				unlinkSync(join(migrationsDir, f));
+			} catch {}
+		}
+	}
+	if (result.error) throw result.error;
+	if (result.status !== 0) {
+		const detail = [result.stderr, result.stdout].filter(Boolean).join("\n").trim();
+		throw new Error(["Failed to generate the starter database migration.", ...detail ? [detail] : []].join("\n\n"));
+	}
+	R.success("Generated initial Drizzle migration");
+}
+function scaffoldPagesApp(root, packageManager, framework, starterMode) {
+	const packageJsonPath = join(root, "package.json");
+	const template = createPagesStarterTemplate({
+		framework,
+		starterMode,
+		voidPackageSpec: resolveScaffoldDependencySpec(root, "void", getOwnVersion()),
+		adapterPackageSpec: resolveScaffoldDependencySpec(root, SCAFFOLD_FRAMEWORKS[framework].adapterPackage, getOwnVersion())
+	});
+	let pkg = {};
+	if (existsSync(packageJsonPath)) try {
+		pkg = asRecord(JSON.parse(readFileSync(packageJsonPath, "utf-8"))) ?? {};
+	} catch {
+		throw new Error("Could not parse package.json in empty project");
+	}
+	const fallbackName = basename(root).toLowerCase().replace(/[^a-z0-9-]/g, "-") || "my-app";
+	if (!pkg.name || typeof pkg.name !== "string") pkg.name = fallbackName;
+	if (pkg.private === void 0) pkg.private = true;
+	if (!pkg.type) pkg.type = "module";
+	const scripts = asRecord(pkg.scripts) ?? {};
+	pkg.scripts = scripts;
+	for (const [name, command] of Object.entries(template.scripts)) if (!scripts[name]) scripts[name] = command;
+	const dependencies = asRecord(pkg.dependencies) ?? {};
+	const devDependencies = asRecord(pkg.devDependencies) ?? {};
+	pkg.dependencies = dependencies;
+	pkg.devDependencies = devDependencies;
+	let dependencyAdded = false;
+	const ensureDependency = (group, name, fallbackVersion) => {
+		const otherGroup = group === "dependencies" ? "devDependencies" : "dependencies";
+		const targetGroup = group === "dependencies" ? dependencies : devDependencies;
+		const sourceGroup = otherGroup === "dependencies" ? dependencies : devDependencies;
+		const existing = targetGroup[name] ?? sourceGroup[name];
+		if (!targetGroup[name]) {
+			targetGroup[name] = existing ?? fallbackVersion;
+			dependencyAdded = true;
+		}
+		if (sourceGroup[name]) {
+			delete sourceGroup[name];
+			dependencyAdded = true;
+		}
+	};
+	for (const [name, version] of Object.entries(template.dependencies)) ensureDependency("dependencies", name, version);
+	for (const [name, version] of Object.entries(template.devDependencies)) ensureDependency("devDependencies", name, version);
+	if (isPnpmProject(root, pkg)) ensurePnpmBuiltDependencies(pkg);
+	if (packageManager === "pnpm" && (!pkg.packageManager || typeof pkg.packageManager !== "string")) pkg.packageManager = "pnpm@10.33.0";
+	writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+	R.success("Updated package.json with starter scripts and dependencies");
+	for (const [filePath, content] of Object.entries(template.files)) writeFileIfMissing(root, filePath, content);
+	ensureGitignore(root);
+	if (starterMode !== "static") applyDatabaseDialect(root, starterMode);
+	if (starterMode === "postgresql") Se(`Add DATABASE_URL to .env.local before running \`${getDevCommand(root)}\`.\nVoid uses that direct connection for local PostgreSQL development.`, "PostgreSQL local dev");
+	return dependencyAdded;
+}
+function hasDeclaredDependency(pkg, name) {
+	return DEPENDENCY_FIELDS.some((field) => {
+		return typeof asRecord(pkg[field])?.[name] === "string";
+	});
+}
+function ensureExistingProjectPackage(root, options = {}) {
+	const packageJsonPath = join(root, "package.json");
+	const voidSpec = resolveScaffoldDependencySpec(root, "void", getOwnVersion());
+	const plainViteSetup = options.plainViteSetup ?? true;
+	let pkg = {};
+	let existedBefore = false;
+	if (existsSync(packageJsonPath)) {
+		existedBefore = true;
+		try {
+			pkg = asRecord(JSON.parse(readFileSync(packageJsonPath, "utf-8"))) ?? {};
+		} catch {
+			throw new Error("Could not parse package.json while configuring Void");
+		}
+	}
+	const fallbackName = basename(root).toLowerCase().replace(/[^a-z0-9-]/g, "-") || "my-app";
+	let changed = !existedBefore;
+	let dependencyAdded = false;
+	if (!pkg.name || typeof pkg.name !== "string") {
+		pkg.name = fallbackName;
+		changed = true;
+	}
+	if (!existedBefore && pkg.private === void 0) {
+		pkg.private = true;
+		changed = true;
+	}
+	if (!existedBefore && !pkg.type) {
+		pkg.type = "module";
+		changed = true;
+	}
+	if (plainViteSetup) {
+		const scripts = asRecord(pkg.scripts) ?? {};
+		pkg.scripts = scripts;
+		if (typeof scripts.dev !== "string") {
+			scripts.dev = "vite";
+			changed = true;
+		}
+		if (typeof scripts.build !== "string") {
+			scripts.build = "vite build";
+			changed = true;
+		}
+	}
+	const devDependencies = asRecord(pkg.devDependencies) ?? {};
+	pkg.devDependencies = devDependencies;
+	if (!hasDeclaredDependency(pkg, "void")) {
+		devDependencies.void = voidSpec;
+		changed = true;
+		dependencyAdded = true;
+	}
+	if (plainViteSetup && !hasDeclaredDependency(pkg, "vite")) {
+		devDependencies.vite = SCAFFOLD_BASE_DEV_DEPENDENCIES.vite;
+		changed = true;
+		dependencyAdded = true;
+	}
+	if (isPnpmProject(root, pkg)) {
+		const before = JSON.stringify(asRecord(pkg.pnpm)?.onlyBuiltDependencies ?? null);
+		ensurePnpmBuiltDependencies(pkg);
+		if (before !== JSON.stringify(asRecord(pkg.pnpm)?.onlyBuiltDependencies ?? null)) changed = true;
+	}
+	if (changed) {
+		writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+		R.success(existedBefore ? plainViteSetup ? "Updated package.json with Void dependencies and Vite scripts" : "Updated package.json with Void dependency" : plainViteSetup ? "Created package.json with Void dependencies and Vite scripts" : "Created package.json with Void dependency");
+	}
+	return {
+		dependencyAdded,
+		packageJsonMutated: changed
+	};
+}
+function insertVoidImport(code) {
+	if (/import\s*\{[^}]*\bvoidPlugin\b[^}]*\}\s*from\s*["']void["']/.test(code)) return code;
+	const importLine = "import { voidPlugin } from \"void\";\n";
+	const lines = code.split(/(?<=\n)/);
+	let insertAt = 0;
+	for (let i = 0; i < lines.length; i++) if (/^\s*import\b/.test(lines[i])) insertAt = i + 1;
+	lines.splice(insertAt, 0, importLine);
+	return lines.join("");
+}
+function isIdentifierStart(char) {
+	return char !== void 0 && /[$A-Za-z_]/.test(char);
+}
+function isIdentifierPart(char) {
+	return char !== void 0 && /[$0-9A-Za-z_]/.test(char);
+}
+function isKeywordAt(code, index, keyword) {
+	return code.startsWith(keyword, index) && !isIdentifierPart(code[index - 1]) && !isIdentifierPart(code[index + keyword.length]);
+}
+function skipStringLiteral(code, index) {
+	const quote = code[index];
+	let i = index + 1;
+	while (i < code.length) {
+		const char = code[i];
+		if (char === "\\") {
+			i += 2;
+			continue;
+		}
+		if (char === quote) return i + 1;
+		i++;
+	}
+	return code.length;
+}
+function skipTemplateLiteral(code, index) {
+	let i = index + 1;
+	while (i < code.length) {
+		const char = code[i];
+		if (char === "\\") {
+			i += 2;
+			continue;
+		}
+		if (char === "`") return i + 1;
+		i++;
+	}
+	return code.length;
+}
+function skipIgnored(code, index) {
+	const char = code[index];
+	if (char === "\"" || char === "'") return skipStringLiteral(code, index);
+	if (char === "`") return skipTemplateLiteral(code, index);
+	if (char === "/" && code[index + 1] === "/") {
+		const newline = code.indexOf("\n", index + 2);
+		return newline === -1 ? code.length : newline + 1;
+	}
+	if (char === "/" && code[index + 1] === "*") {
+		const end = code.indexOf("*/", index + 2);
+		return end === -1 ? code.length : end + 2;
+	}
+	return index;
+}
+function skipTrivia(code, index) {
+	let i = index;
+	while (i < code.length) {
+		if (/\s/.test(code[i])) {
+			i++;
+			continue;
+		}
+		const next = skipIgnored(code, i);
+		if (next === i) return i;
+		i = next;
+	}
+	return i;
+}
+function skipIdentifier(code, index) {
+	let i = index;
+	while (isIdentifierPart(code[i])) i++;
+	return i;
+}
+function skipBalanced(code, start, open, close) {
+	let depth = 1;
+	let i = start + 1;
+	while (i < code.length) {
+		const ignored = skipIgnored(code, i);
+		if (ignored !== i) {
+			i = ignored;
+			continue;
+		}
+		const char = code[i];
+		if (char === open) depth++;
+		else if (char === close) {
+			depth--;
+			if (depth === 0) return i;
+		}
+		i++;
+	}
+}
+function skipTypeArguments(code, index) {
+	const start = skipTrivia(code, index);
+	if (code[start] !== "<") return start;
+	const end = skipBalanced(code, start, "<", ">");
+	return end === void 0 ? start : skipTrivia(code, end + 1);
+}
+function findTopLevelConfigObject(code) {
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	let parenDepth = 0;
+	let i = 0;
+	while (i < code.length) {
+		const ignored = skipIgnored(code, i);
+		if (ignored !== i) {
+			i = ignored;
+			continue;
+		}
+		if (braceDepth === 0 && bracketDepth === 0 && parenDepth === 0 && isKeywordAt(code, i, "export")) {
+			const defaultIndex = skipTrivia(code, i + 6);
+			if (!isKeywordAt(code, defaultIndex, "default")) {
+				i++;
+				continue;
+			}
+			let expressionStart = skipTrivia(code, defaultIndex + 7);
+			if (code[expressionStart] === "{") {
+				const end = skipBalanced(code, expressionStart, "{", "}");
+				return end === void 0 ? void 0 : {
+					start: expressionStart,
+					end
+				};
+			}
+			if (!isKeywordAt(code, expressionStart, "defineConfig")) return;
+			expressionStart = skipTypeArguments(code, expressionStart + 12);
+			if (code[expressionStart] !== "(") return;
+			const firstArgumentStart = skipTrivia(code, expressionStart + 1);
+			if (code[firstArgumentStart] !== "{") return;
+			const end = skipBalanced(code, firstArgumentStart, "{", "}");
+			return end === void 0 ? void 0 : {
+				start: firstArgumentStart,
+				end
+			};
+		}
+		const char = code[i];
+		if (char === "{") braceDepth++;
+		else if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		else if (char === "[") bracketDepth++;
+		else if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		else if (char === "(") parenDepth++;
+		else if (char === ")") parenDepth = Math.max(0, parenDepth - 1);
+		i++;
+	}
+}
+function readPropertyName(code, index) {
+	const char = code[index];
+	if (isIdentifierStart(char)) {
+		const end = skipIdentifier(code, index);
+		return {
+			name: code.slice(index, end),
+			end
+		};
+	}
+	if (char === "\"" || char === "'") {
+		const end = skipStringLiteral(code, index);
+		return {
+			name: code.slice(index + 1, end - 1),
+			end
+		};
+	}
+}
+function skipPropertyValue(code, index, objectEnd) {
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	let parenDepth = 0;
+	let i = index;
+	while (i < objectEnd) {
+		const ignored = skipIgnored(code, i);
+		if (ignored !== i) {
+			i = ignored;
+			continue;
+		}
+		const char = code[i];
+		if (braceDepth === 0 && bracketDepth === 0 && parenDepth === 0 && char === ",") return i + 1;
+		if (char === "{") braceDepth++;
+		else if (char === "}") {
+			if (braceDepth === 0) return i;
+			braceDepth--;
+		} else if (char === "[") bracketDepth++;
+		else if (char === "]") {
+			if (bracketDepth === 0) return i;
+			bracketDepth--;
+		} else if (char === "(") parenDepth++;
+		else if (char === ")") {
+			if (parenDepth === 0) return i;
+			parenDepth--;
+		}
+		i++;
+	}
+	return i;
+}
+function findTopLevelPluginsProperty(code, object) {
+	let i = object.start + 1;
+	while (i < object.end) {
+		i = skipTrivia(code, i);
+		if (code[i] === ",") {
+			i++;
+			continue;
+		}
+		const propertyStart = i;
+		const propertyName = readPropertyName(code, i);
+		if (!propertyName) {
+			i = skipPropertyValue(code, i, object.end);
+			continue;
+		}
+		const colon = skipTrivia(code, propertyName.end);
+		if (code[colon] !== ":") {
+			i = skipPropertyValue(code, propertyName.end, object.end);
+			continue;
+		}
+		const valueStart = skipTrivia(code, colon + 1);
+		if (propertyName.name === "plugins") {
+			if (code[valueStart] !== "[") return "unsupported";
+			const arrayEnd = skipBalanced(code, valueStart, "[", "]");
+			return arrayEnd === void 0 ? "unsupported" : {
+				arrayStart: valueStart,
+				arrayEnd,
+				propertyStart
+			};
+		}
+		i = skipPropertyValue(code, valueStart, object.end);
+	}
+}
+function getLineIndent(code, index) {
+	const lineStart = code.lastIndexOf("\n", index) + 1;
+	return code.slice(lineStart, index).match(/^\s*/)?.[0] ?? "";
+}
+function insertVoidPluginIntoTopLevelConfig(code) {
+	const object = findTopLevelConfigObject(code);
+	if (!object) return;
+	const pluginsProperty = findTopLevelPluginsProperty(code, object);
+	const ms = new MagicString(code);
+	if (pluginsProperty === "unsupported") return;
+	if (pluginsProperty) {
+		const arrayContent = code.slice(pluginsProperty.arrayStart + 1, pluginsProperty.arrayEnd);
+		if (/^\s*$/.test(arrayContent)) {
+			ms.overwrite(pluginsProperty.arrayStart + 1, pluginsProperty.arrayEnd, "voidPlugin()");
+			return ms.toString();
+		}
+		const propIndent = getLineIndent(code, pluginsProperty.propertyStart);
+		const insertAt = pluginsProperty.arrayStart + 1;
+		const next = code[insertAt];
+		const insertion = next === "\n" || next === "\r" ? `\n${propIndent}  voidPlugin(),` : "voidPlugin(), ";
+		ms.appendLeft(insertAt, insertion);
+		return ms.toString();
+	}
+	const objectContent = code.slice(object.start + 1, object.end);
+	if (/^\s*$/.test(objectContent)) {
+		ms.overwrite(object.start + 1, object.end, " plugins: [voidPlugin()] ");
+		return ms.toString();
+	}
+	const baseIndent = getLineIndent(code, object.start);
+	const next = code[object.start + 1];
+	const insertion = next === "\n" || next === "\r" ? `\n${baseIndent}  plugins: [voidPlugin()],` : " plugins: [voidPlugin()],";
+	ms.appendLeft(object.start + 1, insertion);
+	return ms.toString();
+}
+function patchViteConfigWithVoidPlugin(filePath, code) {
+	if (/\bvoidPlugin\s*\(/.test(code)) return code;
+	if (filePath.endsWith(".cjs") || filePath.endsWith(".cts")) return;
+	const withPlugin = insertVoidPluginIntoTopLevelConfig(code);
+	if (!withPlugin) return;
+	return insertVoidImport(withPlugin);
+}
+function getBasicVoidViteConfig() {
+	return `import { defineConfig } from "vite";
+import { voidPlugin } from "void";
+
+export default defineConfig({
+  plugins: [voidPlugin()],
+});
+`;
+}
+function noteManualViteConfigSetup(configPath) {
+	Se(`Could not safely update ${configPath ?? "your framework Vite config"} automatically.\n\nAdd \`voidPlugin()\` to the top-level Vite plugins array:\n\nimport { voidPlugin } from "void";\n\nexport default defineConfig({\n  plugins: [voidPlugin()],\n});`, "Manual Vite config step");
+}
+function noteManualFrameworkConfigSetup(framework) {
+	if (framework.name === "astro") {
+		Se("Detected Astro. Void init does not patch astro.config.* automatically.\n\nAdd `voidPlugin()` to the Astro Vite plugins option:\n\nimport { voidPlugin } from \"void\";\n\nexport default defineConfig({\n  vite: { plugins: [voidPlugin()] },\n});", "Manual Astro config step");
+		return;
+	}
+	if (framework.name === "nuxt") {
+		Se("Detected Nuxt. Void init does not patch nuxt.config.* automatically.\n\nAdd `voidPlugin()` to the Nuxt Vite plugins option:\n\nimport { voidPlugin } from \"void\";\n\nexport default defineNuxtConfig({\n  vite: { plugins: [voidPlugin()] },\n});", "Manual Nuxt config step");
+		return;
+	}
+	noteManualViteConfigSetup();
+}
+function ensureExistingProjectViteConfig(root, framework) {
+	if (framework?.class === "c") {
+		noteManualFrameworkConfigSetup(framework);
+		return;
+	}
+	const configPath = findViteConfig(root);
+	if (!configPath) {
+		writeFileIfMissing(root, "vite.config.ts", getBasicVoidViteConfig());
+		return;
+	}
+	const fullPath = join(root, configPath);
+	const original = readFileSync(fullPath, "utf-8");
+	const updated = patchViteConfigWithVoidPlugin(configPath, original);
+	if (updated === void 0) {
+		noteManualViteConfigSetup(configPath);
+		return;
+	}
+	if (updated === original) {
+		R.info(`${configPath} already includes voidPlugin()`);
+		return;
+	}
+	writeFileSync(fullPath, updated);
+	R.success(`Added voidPlugin() to ${configPath}`);
+}
+function setupExistingProject(root, framework) {
+	R.info("Existing project detected. Configuring Void...");
+	const packageResult = ensureExistingProjectPackage(root, { plainViteSetup: framework?.class !== "c" });
+	ensureExistingProjectViteConfig(root, framework);
+	return packageResult;
+}
+/**
+* Scaffolds the minimal "SQL → types → handler → fetch" demo into an
+* existing project. The demo files import from `void/db` and
+* `void/schema-d1`, so `void` MUST be present in `package.json` before
+* the caller runs `installProjectDependencies` +
+* `generateStarterMigration`; otherwise `drizzle-kit generate` cannot
+* resolve the schema imports. This function ensures `void` is declared,
+* preserving whatever spec is already there or adding the current CLI
+* version used by greenfield scaffolds.
+* `scaffoldPagesApp` has the same contract via its template; we just
+* replicate the "ensure void dep" slice here for the demo path.
+*/
+function scaffoldDemo(root) {
+	const devCommand = getDevCommand(root);
+	const packageJsonMutated = ensureVoidDependency(root);
+	mkdirSync(join(root, "db"), { recursive: true });
+	writeFileSync(join(root, "db", "schema.ts"), `import { sql } from "void/db";
+import { integer, sqliteTable, text } from "void/schema-d1";
+
+export const posts = sqliteTable("posts", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  title: text("title").notNull(),
+  body: text("body").notNull(),
+  createdAt: text("created_at").notNull().default(sql\`(datetime('now'))\`),
+});
+`);
+	R.success("Created db/schema.ts");
+	mkdirSync(join(root, "routes", "api"), { recursive: true });
+	writeFileSync(join(root, "routes", "api", "posts.ts"), `import { defineHandler } from "void";
+import { db } from "void/db";
+import { posts } from "@schema";
+
+// GET /api/posts — returns all posts, fully typed from migration schema
+export const GET = defineHandler(async () => {
+  return db.select().from(posts);
+});
+`);
+	R.success("Created routes/api/posts.ts");
+	ensureProjectTsconfig(root, void 0, true, true);
+	mkdirSync(join(root, "src"), { recursive: true });
+	writeFileSync(join(root, "src", "demo.ts"), `import { fetch } from "void/client";
+
+// Fully typed: response type is inferred from the GET handler's return type,
+// which is derived from the migration schema. No manual types needed.
+const posts = await fetch("/api/posts");
+
+console.log(posts);
+// posts[0].title  ← string (type-checked)
+// posts[0].body   ← string (type-checked)
+// posts[0].nope   ← TypeScript error
+`);
+	R.success("Created src/demo.ts");
+	Se(`SQL migration → DB types → Route handler → Route types → Typed fetch
+
+Run \`${devCommand}\` and open src/demo.ts to see the types in action.\nTry changing the migration or handler — types update automatically.`, "Type Safety Demo");
+	return { packageJsonMutated };
+}
+/**
+* Ensures `void` is declared in `package.json`, creating the file if it
+* does not exist. This is a narrow, scaffoldDemo-specific helper:
+* `scaffoldPagesApp` handles greenfield projects via
+* `createPagesStarterTemplate` (which knows about adapters,
+* devDependencies, scripts, etc.); `scaffoldDemo` only needs enough in
+* `package.json` for `drizzle-kit generate` to resolve `void/schema-d1`
+* via `node_modules/void` after install.
+*/
+function ensureVoidDependency(root) {
+	const packageJsonPath = join(root, "package.json");
+	const voidSpec = resolveScaffoldDependencySpec(root, "void", getOwnVersion());
+	let pkg = {};
+	let existedBefore = false;
+	if (existsSync(packageJsonPath)) {
+		existedBefore = true;
+		try {
+			pkg = asRecord(JSON.parse(readFileSync(packageJsonPath, "utf-8"))) ?? {};
+		} catch {
+			throw new Error("Could not parse package.json while scaffolding demo");
+		}
+	}
+	const fallbackName = basename(root).toLowerCase().replace(/[^a-z0-9-]/g, "-") || "my-app";
+	let changed = !existedBefore;
+	if (!pkg.name || typeof pkg.name !== "string") {
+		pkg.name = fallbackName;
+		changed = true;
+	}
+	if (!existedBefore && pkg.private === void 0) {
+		pkg.private = true;
+		changed = true;
+	}
+	if (!existedBefore && !pkg.type) {
+		pkg.type = "module";
+		changed = true;
+	}
+	if (!pkg.devDependencies || typeof pkg.devDependencies !== "object" || Array.isArray(pkg.devDependencies)) pkg.devDependencies = {};
+	if (!pkg.dependencies || typeof pkg.dependencies !== "object" || Array.isArray(pkg.dependencies)) pkg.dependencies = {};
+	const devDependencies = asRecord(pkg.devDependencies) ?? {};
+	pkg.devDependencies = devDependencies;
+	if (!DEPENDENCY_FIELDS.some((field) => {
+		return typeof asRecord(pkg[field])?.void === "string";
+	})) {
+		devDependencies.void = voidSpec;
+		changed = true;
+	}
+	if (isPnpmProject(root, pkg)) {
+		const before = JSON.stringify(asRecord(pkg.pnpm)?.onlyBuiltDependencies ?? null);
+		ensurePnpmBuiltDependencies(pkg);
+		if (before !== JSON.stringify(asRecord(pkg.pnpm)?.onlyBuiltDependencies ?? null)) changed = true;
+	}
+	if (changed) {
+		writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
+		R.success(existedBefore ? "Ensured void is in package.json devDependencies" : "Created package.json with void as a devDependency");
+	}
+	return changed;
+}
+function detectInstructionFilePath(root, agents) {
+	if (agents.some((a) => a.skillsDir === ".claude/skills")) return "CLAUDE.md";
+	if (existsSync(join(root, "CLAUDE.md"))) return "CLAUDE.md";
+	if (existsSync(join(root, "AGENTS.md"))) return "AGENTS.md";
+	return "AGENTS.md";
+}
+async function pickAgentWhenUndetected() {
+	const choice = await Ee({
+		message: "Could not detect your coding agent. Which one are you using?",
+		options: [
+			{
+				value: "claude-code",
+				label: "Claude Code"
+			},
+			{
+				value: "cursor",
+				label: "Cursor"
+			},
+			{
+				value: "codex",
+				label: "Codex"
+			},
+			{
+				value: "gemini-cli",
+				label: "Gemini CLI"
+			},
+			{
+				value: "generic",
+				label: "Generic"
+			}
+		]
+	});
+	if (q(choice)) {
+		me("Setup cancelled.");
+		process.exit(0);
+	}
+	if (choice === "generic") return {
+		instructionFilePath: "AGENTS.md",
+		agents: []
+	};
+	const selected = getAgentById(choice);
+	if (!selected) return {
+		instructionFilePath: "AGENTS.md",
+		agents: []
+	};
+	return {
+		instructionFilePath: choice === "claude-code" ? "CLAUDE.md" : "AGENTS.md",
+		agents: [selected]
+	};
+}
+async function resolveAgentSetup(root) {
+	const detected = detectAgents(root);
+	if (detected.length > 0) return {
+		instructionFilePath: detectInstructionFilePath(root, detected),
+		agents: detected
+	};
+	return pickAgentWhenUndetected();
+}
+function readAgentPrompt() {
+	return readFileSync(join(getPackageDir(), "AGENT_PROMPT.md"), "utf-8");
+}
+function getOwnVersion() {
+	return JSON.parse(readFileSync(join(getPackageDir(), "package.json"), "utf-8")).version;
+}
+const MARKER_OPEN_RE = /<!--injected-by-void-v([\d.]+)-->/;
+const MARKER_CLOSE = "<!--/injected-by-void-->";
+const MARKER_BLOCK_RE = /<!--injected-by-void-v[\d.]+-->\n[\s\S]*?<!--\/injected-by-void-->/;
+function injectAgentBlock(root, filePath) {
+	const fullPath = join(root, filePath);
+	const version = getOwnVersion();
+	const promptContent = readAgentPrompt();
+	const block = `${`<!--injected-by-void-v${version}-->`}\n${promptContent}\n${MARKER_CLOSE}`;
+	if (existsSync(fullPath)) {
+		const existing = readFileSync(fullPath, "utf-8");
+		const match = existing.match(MARKER_OPEN_RE);
+		if (match) {
+			if (match[1] === version) {
+				R.info(`${filePath} already has Void instructions (v${version})`);
+				return;
+			}
+			writeFileSync(fullPath, existing.replace(MARKER_BLOCK_RE, block));
+			R.success(`Updated Void instructions in ${filePath} (v${match[1]} → v${version})`);
+		} else {
+			writeFileSync(fullPath, existing + (existing.endsWith("\n") ? "\n" : "\n\n") + block + "\n");
+			R.success(`Added Void instructions to ${filePath}`);
+		}
+	} else {
+		writeFileSync(fullPath, block + "\n");
+		R.success(`Created ${filePath} with Void instructions`);
+	}
+}
+function writeMcpConfigForTarget(root, target) {
+	const fullPath = join(root, target.filePath);
+	let existing = {};
+	if (existsSync(fullPath)) try {
+		existing = asRecord(JSON.parse(readFileSync(fullPath, "utf-8"))) ?? {};
+	} catch {}
+	const rootConfig = asRecord(existing[target.rootKey]) ?? {};
+	existing[target.rootKey] = rootConfig;
+	if (rootConfig["void"]) {
+		R.info(`${target.filePath} already has void MCP config`);
+		return;
+	}
+	rootConfig["void"] = {
+		command: "npx",
+		args: ["void", "mcp"],
+		...target.extraFields
+	};
+	mkdirSync(dirname(fullPath), { recursive: true });
+	writeFileSync(fullPath, JSON.stringify(existing, null, 2) + "\n");
+	R.success(`Added void MCP server to ${target.filePath}`);
+}
+function pickMcpTarget(root, targets) {
+	if (targets.length === 1) return targets[0];
+	const existingTargets = targets.filter((t) => existsSync(join(root, t.filePath)));
+	if (existingTargets.length > 0) return existingTargets[0];
+	return targets[0];
+}
+function setupMcpConfig(root, selectedAgents) {
+	const mcpAgents = [];
+	const hintAgents = [];
+	for (const agent of selectedAgents) if (agent.mcpConfig) mcpAgents.push({
+		agent,
+		targets: agent.mcpConfig
+	});
+	else if (agent.mcpHint) hintAgents.push({
+		agent,
+		hint: agent.mcpHint
+	});
+	if (selectedAgents.length === 0) {
+		Se(JSON.stringify({ void: {
+			command: "npx",
+			args: ["void", "mcp"]
+		} }, null, 2), "Add this MCP server config to your agent");
+		return;
+	}
+	for (const { agent, hint } of hintAgents) R.info(`${agent.displayName}: ${hint}`);
+	for (const { agent, targets } of mcpAgents) {
+		const target = pickMcpTarget(root, targets);
+		R.info(`${agent.displayName} MCP target: ${target.filePath}`);
+		writeMcpConfigForTarget(root, target);
+	}
+}
+async function runInitCommand(root, initArgs) {
+	console.log();
+	ge(cliTitle("init"));
+	const targeted = Boolean(initArgs && (initArgs.tsconfig || initArgs.github || initArgs.agents));
+	const framework = detectFramework(root);
+	const preScaffoldState = detectProjectState(root);
+	const detectedPagesFramework = detectPagesFramework(root);
+	let scaffoldedPagesFramework;
+	let scaffoldedStarterMode;
+	let didScaffoldStarter = false;
+	let scaffoldAddedDependencies = false;
+	let workspaceSubpackageSkip = false;
+	if (framework) R.info(`Detected ${framework.name} framework`);
+	if (!targeted && !framework && isScaffoldableEmptyProject(root)) {
+		R.info("Empty project detected. Scaffolding a Pages starter...");
+		if (detectedPagesFramework) {
+			scaffoldedPagesFramework = detectedPagesFramework;
+			R.info(`Detected ${SCAFFOLD_FRAMEWORKS[detectedPagesFramework].label} adapter in package.json`);
+		} else scaffoldedPagesFramework = await promptScaffoldFramework();
+		const starterMode = await promptStarterMode();
+		const scaffoldWroteDeps = scaffoldPagesApp(root, preScaffoldState.packageManager, scaffoldedPagesFramework, starterMode);
+		const deferral = resolveWorkspaceDeferral(root, readPackageJson(root));
+		const voidResolvable = isVoidResolvableFrom(root);
+		if (deferral && (!voidResolvable || scaffoldWroteDeps)) {
+			workspaceSubpackageSkip = true;
+			const relRoot = relative(deferral.workspaceRoot, root) || ".";
+			const dbFollowUp = starterMode === "static" ? "" : `\nthen run \`void db generate\` from ./${relRoot} to create the initial migration.`;
+			Se(`Scaffolded the Pages starter in ./${relRoot}.\n\nRun your workspace install from ${deferral.workspaceRoot} to pick up the new dependencies.${dbFollowUp}`, "Workspace subpackage");
+		} else if (scaffoldWroteDeps || !voidResolvable) scaffoldAddedDependencies = true;
+		if (starterMode !== "static") scaffoldedStarterMode = starterMode;
+		didScaffoldStarter = true;
+	}
+	const state = detectProjectState(root);
+	const pagesFramework = scaffoldedPagesFramework ?? detectPagesFramework(root);
+	if (!targeted && !didScaffoldStarter) {
+		const existingSetup = setupExistingProject(root, framework);
+		const voidResolvable = isVoidResolvableFrom(root);
+		if (existingSetup.dependencyAdded || !voidResolvable) {
+			const deferral = resolveWorkspaceDeferral(root, readPackageJson(root));
+			if (deferral) {
+				workspaceSubpackageSkip = true;
+				const relRoot = relative(deferral.workspaceRoot, root) || ".";
+				Se(`Configured Void in ./${relRoot}.\n\nRun your workspace install from ${deferral.workspaceRoot} to sync the lockfile and pick up the updated dependencies.\nIf this init flow scaffolds database files, then run \`void db generate\` from ./${relRoot}.`, "Workspace subpackage");
+			} else scaffoldAddedDependencies = true;
+		}
+	}
+	if (!targeted || initArgs?.tsconfig) {
+		state.typescriptWanted = true;
+		setupTsconfig(root, state, pagesFramework);
+	}
+	if (state.typescriptWanted) {
+		const hasSchema = hasDrizzleSchema(root);
+		ensureProjectTsconfig(root, void 0, hasSchema, hasSchema);
+	}
+	ensureGitignore(root);
+	if (framework) setupWranglerConfig(root, framework);
+	if (!targeted) ensureVoidWorkerCompatibilityDate(root);
+	if (!targeted && !didScaffoldStarter) applyDatabaseSetup(root, await promptDatabaseSetup(root));
+	if (!targeted || initArgs?.agents) {
+		const agentSetup = await resolveAgentSetup(root);
+		injectAgentBlock(root, agentSetup.instructionFilePath);
+		if (agentSetup.agents.length > 0) {
+			const { linkSkillsForSpecificAgents } = await import("./skills-ipldjlKE.mjs");
+			linkSkillsForSpecificAgents(root, agentSetup.agents);
+		} else R.info("Skills linking skipped for generic agent setup");
+		setupMcpConfig(root, agentSetup.agents);
+	}
+	if (!targeted && !framework) if (didScaffoldStarter || state.hasRoutes || state.hasMigrations || state.hasPages) R.info("Project already has pages, routes, or migrations, skipping demo");
+	else if (!state.typescriptWanted) {} else {
+		const scaffold = await ue({ message: "Scaffold demo code? (migration + API route + frontend fetch)" });
+		if (q(scaffold)) {
+			me("Setup cancelled.");
+			process.exit(0);
+		}
+		if (scaffold) {
+			const { packageJsonMutated } = scaffoldDemo(root);
+			const voidResolvable = isVoidResolvableFrom(root);
+			const deferral = resolveWorkspaceDeferral(root, readPackageJson(root));
+			if (deferral && (!voidResolvable || packageJsonMutated)) {
+				workspaceSubpackageSkip = true;
+				const relRoot = relative(deferral.workspaceRoot, root) || ".";
+				Se(`Scaffolded the starter demo in ./${relRoot}.\n\n${voidResolvable ? `\`void\` is already hoisted at an ancestor node_modules, but \`./${relRoot}/package.json\` was updated.\nRun your workspace install from ${deferral.workspaceRoot} to sync the lockfile,` : `Run your workspace install from ${deferral.workspaceRoot} to pick up the new \`void\` dep,`}\nthen run \`void db generate\` from ./${relRoot} to create the initial migration.`, "Workspace subpackage");
+			} else if (!voidResolvable || packageJsonMutated) scaffoldAddedDependencies = true;
+			scaffoldedStarterMode = "sqlite";
+		}
+	}
+	const githubStepSkipForSubpackage = isInsideWorkspaceSubpackage(root);
+	if ((!targeted || initArgs?.github) && !githubStepSkipForSubpackage) if (existsSync(join(root, ".github", "workflows", "deploy.yml"))) R.warn("deploy.yml already exists, skipping");
+	else if (targeted) setupGithubActions(root, state);
+	else {
+		const setupGha = await ue({ message: "Create .github/workflows/deploy.yml to deploy on pushes to main?" });
+		if (q(setupGha)) {
+			me("Setup cancelled.");
+			process.exit(0);
+		}
+		if (setupGha) setupGithubActions(root, state);
+	}
+	else if (githubStepSkipForSubpackage && (initArgs?.github || !targeted)) R.info("Skipping GitHub Actions setup: workflow files must live at the repo root, not in a workspace subpackage.");
+	if (!targeted) {
+		const scaffoldResult = maybeScaffoldEnvTs(root);
+		if (scaffoldResult.written) {
+			const rel = relative(root, scaffoldResult.written) || "env.ts";
+			if (scaffoldResult.entries.length > 0) R.success(`Scaffolded ${rel} from your .env files — review inferred types before running dev.`);
+			else R.success(`Created empty ${rel} — add your env keys with \`defineEnv({...})\`.`);
+		}
+	}
+	if (scaffoldAddedDependencies) installProjectDependencies(root, state.packageManager);
+	if (scaffoldedStarterMode && !workspaceSubpackageSkip) generateStarterMigration(root, scaffoldedStarterMode);
+	if (!targeted) await maybeSetupDeployProject(root);
+	if (workspaceSubpackageSkip) if (scaffoldedStarterMode) ye("Run your workspace install, then `void db generate` to finish setup.");
+	else ye("Run your workspace install to finish setup.");
+	else ye(`Run \`${getDevCommand(root, framework)}\` to start developing`);
+}
+//#endregion
+export { parseInitArgs, runInitCommand };