void 0.26.1 → 0.28.0

package/dist/{init-Bw-fRKGp.mjs → init-ZWOJvc-Z.mjs}

@@ -1,33 +1,34 @@
-import { a as join, i as isAbsolute, l as relative, n as dirname, t as basename, u as resolve } from "./dist-BVqXeR_h.mjs";
-import { r as detectFramework } from "./plugin-inference-BlQbOL0P.mjs";
-import { n as readProjectPaths, o as TYPED_CONFIG_FILE } from "./project-paths-GgcMozYz.mjs";
-import { m as readConfig, u as getDatabaseDialect } from "./config-DiowPT80.mjs";
-import { l as writeProjectConfig, n as readDeploymentPlatform, r as readProjectConfig, s as writeDeploymentPlatform, t as attachSelectedPlatform } from "./project-DQstYTxO.mjs";
-import { r as materializeCloudflareConfig } from "./cloudflare-config-BmhBv3HV.mjs";
-import { i as LATEST_KNOWN_COMPAT_DATE, j as writeProvisionedWranglerConfig } from "./wrangler-D9KTuqnv.mjs";
-import { c as getToken } from "./auth-B5_tZLxT.mjs";
-import { A as confirm, K as select, L as log, O as cancel, X as text, tt as isCancel } from "./dist-D3m88sjf.mjs";
-import { d as printSuccess, u as note } from "./output-C50ag2r3.mjs";
-import { n as ensureProjectTsconfig, t as createProjectTsconfig } from "./project-tsconfig-CVJhNMxs.mjs";
+import { a as join, c as resolve, i as isAbsolute, n as dirname, s as relative, t as basename } from "./dist-ipQi0Q8y.mjs";
+import { r as detectFramework } from "./plugin-inference-DsARdQKE.mjs";
+import { n as readProjectPaths, o as TYPED_CONFIG_FILE } from "./project-paths-DMvEeSau.mjs";
+import { d as readConfig, s as getDatabaseDialect } from "./config-Bx_1SpnO.mjs";
 import { t as MagicString } from "./dist-Cegxq8gs.mjs";
-import { t as parseDotenvFile } from "./dotenv-BfU6eqFt.mjs";
-import { n as getPackageDir, t as detectAgents } from "./agents-B_pX_HmQ.mjs";
-import { r as PlatformClient } from "./client-C2Prx_Bi.mjs";
-import { i as migrateFrameworkAdapterPaths, t as migrateLegacyVoidConfig } from "./migrate-NLsjBbuM.mjs";
-import { s as formatProjectCommand } from "./cloudflare-process-2-TfIEzB.mjs";
-import { a as promptProjectSelection, r as promptAndCreateProject } from "./create-project-DxiyW6iX.mjs";
-import { n as writeDrizzleConfig } from "./config-CLYAosnQ.mjs";
-import { n as writeVoidProjectConfig, t as canRewriteVoidProjectConfig } from "./config-write-AHGesphx.mjs";
-import { t as promptForLoginToken } from "./login-D-Q4xw3Q.mjs";
-import { i as saveDiscoveredPlatform, t as discoverPlatform } from "./platform-cmd-B8-bCb7t.mjs";
-import { t as connectCloudflare } from "./cloudflare-connect-2G3rL2rP.mjs";
-import { n as findInstalledYarnPnpRuntime, r as hasLocalLockfile, t as buildDrizzleKitSpawnEnv } from "./yarn-pnp-CUX_iTPA.mjs";
+import { c as writeDeploymentPlatform, n as readDeploymentPlatform, r as readProjectConfig, t as attachSelectedPlatform, u as writeProjectConfig } from "./project-rqDnVsJN.mjs";
+import { r as materializeCloudflareConfig } from "./cloudflare-config-DV60XFFK.mjs";
+import { i as LATEST_KNOWN_COMPAT_DATE, j as writeProvisionedWranglerConfig } from "./wrangler-BYs07Rxy.mjs";
+import { i as readPackageJson, n as hasPackageDependency } from "./package-json-BjYqR-So.mjs";
+import { c as getToken } from "./auth-B6iOCjKI.mjs";
+import { A as confirm, K as select, L as log, O as cancel, X as text, tt as isCancel } from "./dist-D3m88sjf.mjs";
+import { l as formatUrl, m as printSuccess, p as note } from "./output-FNHKw5Ac.mjs";
+import { n as ensureProjectTsconfig, t as createProjectTsconfig } from "./project-tsconfig-bveqhlYA.mjs";
+import { t as parseDotenvFile } from "./dotenv-CNazY3-w.mjs";
+import { r as writeDrizzleConfig, t as PLACEHOLDER_DB_URL } from "./config-BEm9vRvS.mjs";
+import { n as getOwnVersion, r as getPackageDir, t as detectAgents } from "./agents-CuNtT0D_.mjs";
+import { r as PlatformClient } from "./client-DM9Kcf4e.mjs";
+import { a as promptProjectSelection, r as promptAndCreateProject } from "./create-project-D4APeBwX.mjs";
+import { s as formatProjectCommand } from "./cloudflare-process-CeDWJRhj.mjs";
+import { i as hasLocalLockfile, n as drizzleKitBin, r as findInstalledYarnPnpRuntime, t as buildDrizzleKitSpawnEnv } from "./yarn-pnp-DLbEFMT0.mjs";
+import { t as promptForLoginToken } from "./login-CZ2Cqa-D.mjs";
+import { i as saveDiscoveredPlatform, t as discoverPlatform } from "./platform-cmd-DxxZO6e5.mjs";
+import { t as connectCloudflare } from "./cloudflare-connect-BosmCNlq.mjs";
+import { n as snapshotDrizzleOutputs } from "./generate-Dat0UTry.mjs";
+import { i as writeVoidProjectConfig, o as migrateFrameworkAdapterPaths, r as canRewriteVoidProjectConfig, t as migrateLegacyVoidConfig } from "./migrate-uFwojusJ.mjs";
 import { createRequire } from "node:module";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmdirSync, unlinkSync, writeFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { parseSync } from "vite";
-import { parse } from "jsonc-parser";
+import { isRecord } from "@void/deploy-core";
 import { parseArgs } from "node:util";
+import { parse } from "jsonc-parser";
 import { spawnSync } from "node:child_process";
 //#region src/cli/deploy-setup.ts
 async function maybeSetupDeployProject(root) {
@@ -57,7 +58,7 @@ async function maybeSetupDeployProject(root) {
 			projectId: result.project.id,
 			slug: result.project.slug
 		};
-		writeProjectConfig(root, attachSelectedPlatform(root, config, client.apiUrl));
+		writeProjectConfig(root, attachSelectedPlatform(config, client.apiUrl));
 		log.step(`Linked project: ${config.slug}`);
 		return config;
 	}
@@ -796,12 +797,13 @@ const EMPTY_PROJECT_ALLOWED_ENTRIES = /* @__PURE__ */ new Set([
 	".windsurf",
 	".zencoder"
 ]);
-const PNPM_ALLOWED_BUILDS = [
-	"esbuild",
-	"sharp",
-	"workerd"
+const PNPM_BUILD_DEFAULTS = [
+	["better-sqlite3", false],
+	["esbuild", true],
+	["sharp", true],
+	["workerd", true]
 ];
-const drizzleKitBin = join(fileURLToPath(import.meta.resolve("drizzle-kit")), "..", "bin.cjs");
+const PNPM_BUILD_PLACEHOLDER = "set this to true or false";
 const EMPTY_PROJECT_ALLOWED_PACKAGES = /* @__PURE__ */ new Set([
 	"void",
 	"hono",
@@ -863,8 +865,7 @@ const VITE_CONFIG_FILES = [
 ];
 const VOID_CONFIG_FILE = "void.json";
 function asRecord(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-	return value;
+	return isRecord(value) ? value : null;
 }
 function parseJsoncFile(path) {
 	const errors = [];
@@ -1091,27 +1092,9 @@ function parsePackageManagerField(pkg) {
 	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@...`.
-*
-* 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.
+* Whether pnpm manages `root`. pnpm keeps the lockfile and Corepack pin at the
+* workspace root, so a member without local markers inherits them, but a local
+* lockfile or pin for another manager always wins.
 */
 function isPnpmProject(root, pkg) {
 	if (existsSync(join(root, "pnpm-lock.yaml"))) return true;
@@ -1123,23 +1106,8 @@ function isPnpmProject(root, pkg) {
 	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.
-*
-* 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; treating it as a member would make
-* `ensureVoidDependency` / `scaffoldPagesApp` disagree with the local
-* install, which uses 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.
+* Whether `start` is a declared member of a pnpm-managed ancestor workspace.
+* A scratch app outside the workspace globs is a separate project.
 */
 function hasAncestorPnpmMarkers(start) {
 	const workspaceRoot = findWorkspaceRoot(start);
@@ -1154,30 +1122,8 @@ function hasAncestorPnpmMarkers(start) {
 	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.
-*
-* 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 a post-install marker next to the runtime
-* (`.yarn/install-state.gz` or a populated `.yarn/cache`). Without it,
-* we fall through and return false so the caller triggers the install
-* step before attempting to spawn drizzle-kit.
+* Whether `void` resolves from `start`, through an ancestor `node_modules`
+* (hoisted workspace installs) or an installed Yarn PnP runtime.
 */
 function isVoidResolvableFrom(start) {
 	let dir = start;
@@ -1197,7 +1143,6 @@ function isVoidResolvableFrom(start) {
 		const probe = spawnSync(process.execPath, probeArgs, {
 			cwd: start,
 			stdio: "ignore",
-			shell: process.platform === "win32",
 			env: buildDrizzleKitSpawnEnv(start)
 		});
 		return !probe.error && probe.status === 0;
@@ -1205,13 +1150,8 @@ function isVoidResolvableFrom(start) {
 	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.
+* Nearest ancestor of `start` (excluding `start`) with a `pnpm-workspace.yaml`
+* or a `package.json#workspaces` field.
 */
 function findWorkspaceRoot(start) {
 	let dir = dirname(start);
@@ -1228,18 +1168,8 @@ function findWorkspaceRoot(start) {
 	}
 }
 /**
-* 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.
+* Member globs from `pnpm-workspace.yaml#packages` or `package.json#workspaces`
+* (an array or `{ packages }`). Empty when none can be read.
 */
 function readWorkspacePatterns(workspaceRoot) {
 	const pnpmWorkspacePath = join(workspaceRoot, "pnpm-workspace.yaml");
@@ -1261,16 +1191,7 @@ function readWorkspacePatterns(workspaceRoot) {
 	}
 	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. A naive `/\s+#.*$/` strip would
-* truncate quoted values like `- "path #hash/*"`.
-*/
+/** Strip a trailing YAML comment, keeping `#` inside quotes (`- "path #hash/*"`). */
 function stripYamlLineComment(line) {
 	let inSingle = false;
 	let inDouble = false;
@@ -1297,23 +1218,8 @@ function stripYamlLineComment(line) {
 	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.
+* Read the `packages:` list of a `pnpm-workspace.yaml` in block (`- 'apps/*'`)
+* or flow (`packages: ['apps/*']`) form.
 */
 function extractPnpmWorkspacePackages(yaml) {
 	const lines = yaml.split(/\r?\n/);
@@ -1345,14 +1251,7 @@ function extractPnpmWorkspacePackages(yaml) {
 	}
 	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).
-*/
+/** Expand `{a,b}` brace groups, including several groups in one pattern. */
 function expandBraces(pattern) {
 	const match = pattern.match(/^([^{}]*)\{([^{}]*)\}(.*)$/);
 	if (!match) return [pattern];
@@ -1363,19 +1262,6 @@ function expandBraces(pattern) {
 	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));
 }
@@ -1412,21 +1298,8 @@ function matchSegments(path, pi, pat, 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.
+* Whether `root` matches a workspace glob and no `!` glob. A nested app outside
+* the globs is a separate project.
 */
 function isWorkspaceSubpackage(workspaceRoot, root) {
 	const relPath = relative(workspaceRoot, root);
@@ -1444,31 +1317,15 @@ function isWorkspaceSubpackage(workspaceRoot, root) {
 	}
 	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.
-*/
+/** Workspace membership, even when the member manages its own 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.
+* The workspace root that should install for `root`: set when `root` is a
+* member without its own lockfile or non-pnpm Corepack pin, as in `isPnpmProject`.
 */
 function resolveWorkspaceDeferral(root, pkg) {
 	const workspaceRoot = findWorkspaceRoot(root);
@@ -1504,7 +1361,6 @@ function detectProjectState(root) {
 	return {
 		hasTypescript,
 		hasTsconfig: existsSync(join(root, "tsconfig.json")),
-		hasGithubWorkflows: existsSync(join(root, ".github", "workflows")),
 		hasRoutes: existsSync(paths.routesDir),
 		hasMigrations: existsSync(paths.migrationsDir) || existsSync(join(root, "migrations")),
 		hasPages: existsSync(paths.pagesDir),
@@ -1527,29 +1383,20 @@ function detectPagesFramework(root) {
 		...asRecord(pkg.devDependencies) ?? {}
 	});
 }
-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) {
+/** The first declared spec for `packageName`, in `DEPENDENCY_FIELDS` order. */
+function resolveScaffoldDependencySpec(root, packageName, fallbackVersion) {
 	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];
+		const spec = asRecord(pkg?.[field])?.[packageName];
+		if (typeof spec === "string") return spec || fallbackVersion;
 	}
-}
-function resolveScaffoldDependencySpec(root, packageName, fallbackVersion) {
-	return getDeclaredDependencySpec(root, packageName) || fallbackVersion;
+	return fallbackVersion;
 }
 function defaultPackageName(root) {
 	return basename(root).toLowerCase().replace(/[^a-z0-9-]/g, "-") || "my-app";
@@ -1885,7 +1732,7 @@ async function ensureVoidPlatformConnection(root) {
 	let selectedApiUrl = null;
 	let promptedForPlatform = false;
 	try {
-		const { getApiUrl, getSiteDomain } = await import("./auth-BgX2qYSY.mjs");
+		const { getApiUrl, getSiteDomain } = await import("./auth-wn6F8dB8.mjs");
 		selectedApiUrl = getApiUrl(root);
 		getSiteDomain(root);
 	} catch (error) {
@@ -1905,7 +1752,7 @@ async function ensureVoidPlatformConnection(root) {
 	}
 	const discovery = await discoverPlatform(selectedApiUrl);
 	saveDiscoveredPlatform(discovery);
-	if (promptedForPlatform) log.step(`Connected to ${discovery.displayName} at ${discovery.apiUrl}.`);
+	if (promptedForPlatform) log.step(`Connected to ${discovery.displayName} at ${formatUrl(discovery.apiUrl)}.`);
 	return discovery;
 }
 async function setupCloudflareDeployment(root) {
@@ -1965,17 +1812,9 @@ function getWorkflowSetupSteps(root, pm) {
 	}
 }
 /**
-* Scaffold the GitHub Actions workflow that deploys via GitHub OIDC — no
-* long-lived secret stored in the repo. `void deploy` itself detects GitHub
-* Actions, mints an OIDC token (audience `void`), exchanges it at
-* `POST $VOID_API_URL/auth/github-oidc` for a short-lived, project-scoped deploy
-* token, and uses it — so the workflow is a single `void deploy` step (no
-* curl/jq). `permissions: id-token: write` is still required: it is what lets
-* the job (and thus the CLI) mint the OIDC token.
-*
-* `slug` is the linked project slug when known (from `.void/project.json`);
-* otherwise a `${{ vars.VOID_PROJECT }}` placeholder is emitted with a comment
-* telling the user to set the repository variable.
+* The deploy workflow. Void deploys exchange a GitHub OIDC token (`id-token: write`)
+* at deploy time, so no long-lived token is stored. Without a `slug`, the workflow
+* reads a `vars.VOID_PROJECT` repository variable.
 */
 function getWorkflowYaml(root, pm, slug, platform = "void", platformApiUrl) {
 	const { setup, install, runner } = getWorkflowSetupSteps(root, pm);
@@ -2068,15 +1907,8 @@ function setupGithubActions(root, state, platform = "void", platformApiUrl) {
 	else note("Pushes to main will build and deploy via GitHub OIDC — no token to store.\nSet a VOID_PROJECT repository variable (Settings → Secrets and variables → Actions → Variables)\nto your project slug, and connect the repo to your project in the Void dashboard.", "GitHub Actions OIDC deploy");
 }
 /**
-* Bake a resolved project slug into an already-written `void-deploy.yml`.
-*
-* Step 8 (GitHub Actions) runs BEFORE Step 9 (project link), so when a user
-* links a project during the same interactive init the workflow was written
-* with the `${{ vars.VOID_PROJECT }}` placeholder. Once the link resolves a
-* slug, rewrite the placeholder `env.VOID_PROJECT` block in place so the user
-* does not also have to set a repository variable. No-op (returns `false`)
-* when the workflow is missing or the placeholder is not present (e.g. the
-* slug was already known at scaffold time, or the user declined linking).
+* Replace the `vars.VOID_PROJECT` placeholder in `void-deploy.yml` with a slug
+* linked after the workflow was written. Returns false when there is none.
 */
 function patchWorkflowProjectSlug(root, slug) {
 	const workflowPath = join(root, ".github", "workflows", "void-deploy.yml");
@@ -2110,9 +1942,11 @@ function ensureGitignore(root) {
 	writeFileSync(gitignorePath, content + separator + missing.join("\n") + "\n");
 	log.step("Updated .gitignore with Void defaults");
 }
+/** Removes each block-style top-level `key:` block; `removed` holds its non-blank lines. */
 function removeTopLevelYamlBlock(yaml, key) {
 	const lines = yaml.split(/\r?\n/);
 	const next = [];
+	const removed = [];
 	for (let i = 0; i < lines.length; i += 1) {
 		const line = lines[i];
 		if (!new RegExp(`^${key}:\\s*(?:#.*)?$`).test(line)) {
@@ -2120,19 +1954,46 @@ function removeTopLevelYamlBlock(yaml, key) {
 			continue;
 		}
 		i += 1;
-		while (i < lines.length && (lines[i].trim() === "" || /^\s/.test(lines[i]))) i += 1;
+		while (i < lines.length && (lines[i].trim() === "" || /^(?:\s|-(?:\s|$))/.test(lines[i]))) {
+			if (lines[i].trim() !== "") removed.push(lines[i]);
+			i += 1;
+		}
 		i -= 1;
 	}
-	return next.join("\n");
+	return {
+		yaml: next.join("\n"),
+		removed
+	};
 }
-function pnpmAllowBuildsYaml() {
-	const lines = ["allowBuilds:", "  better-sqlite3: false"];
-	for (const dependency of PNPM_ALLOWED_BUILDS) lines.push(`  ${dependency}: true`);
-	return lines.join("\n");
+function pnpmAllowBuildsEntryName(line) {
+	return /^\s+(?!#)(["']?)(.+?)\1\s*:(?:\s|$)/.exec(line)?.[2];
 }
-function insertPnpmAllowBuilds(yaml) {
+/**
+* Keeps the existing `allowBuilds` entries as written, approves the legacy
+* `onlyBuiltDependencies` list, and adds each Void default that is missing.
+*/
+function pnpmAllowBuildsYaml(entries, legacyList) {
+	const legacy = legacyList.flatMap((line) => {
+		const name = /^\s*-\s+(["']?)(.+?)\1\s*(?:#.*)?$/.exec(line)?.[2];
+		return name === void 0 ? [] : [name];
+	});
+	const decided = /* @__PURE__ */ new Set([...legacy, ...PNPM_BUILD_DEFAULTS.map(([name]) => name)]);
+	const lines = entries.filter((line) => {
+		const name = pnpmAllowBuildsEntryName(line);
+		return !(name !== void 0 && decided.has(name) && line.includes(PNPM_BUILD_PLACEHOLDER));
+	});
+	const names = new Set(lines.map((line) => pnpmAllowBuildsEntryName(line)));
+	const firstEntry = lines.find((line) => pnpmAllowBuildsEntryName(line) !== void 0);
+	const indent = /^\s+/.exec(firstEntry ?? "")?.[0] ?? "  ";
+	const additions = [...legacy.map((name) => [name, true]), ...PNPM_BUILD_DEFAULTS];
+	for (const [name, value] of additions) if (!names.has(name)) {
+		names.add(name);
+		lines.push(`${indent}${/^[\w.-]+$/.test(name) ? name : JSON.stringify(name)}: ${value}`);
+	}
+	return ["allowBuilds:", ...lines].join("\n");
+}
+function insertPnpmAllowBuilds(yaml, allowBuilds) {
 	const trimmed = yaml.trim();
-	const allowBuilds = pnpmAllowBuildsYaml();
 	if (trimmed === "") return `${allowBuilds}\n`;
 	const lines = trimmed.split(/\r?\n/);
 	const packagesIndex = lines.findIndex((line) => /^packages:\s*(?:#.*)?$/.test(line));
@@ -2151,37 +2012,67 @@ function resolvePnpmConfigRoot(root, pkg) {
 function ensurePnpmAllowBuilds(root, pkg) {
 	const configRoot = resolvePnpmConfigRoot(root, pkg);
 	const workspacePath = join(configRoot, "pnpm-workspace.yaml");
+	const displayPath = configRoot === root ? "pnpm-workspace.yaml" : relative(root, workspacePath);
 	const before = existsSync(workspacePath) ? readFileSync(workspacePath, "utf-8") : "";
-	const after = insertPnpmAllowBuilds(removeTopLevelYamlBlock(removeTopLevelYamlBlock(before, "onlyBuiltDependencies"), "allowBuilds"));
+	const inline = /^allowBuilds:[ \t]*([^\s#].*)$/m.exec(before)?.[1];
+	if (inline !== void 0) {
+		const missing = PNPM_BUILD_DEFAULTS.filter(([name]) => !new RegExp(`[{,]\\s*["']?${name}["']?\\s*:`).test(inline));
+		if (missing.length > 0) log.warn(`Add ${missing.map(([name, value]) => `${name}: ${value}`).join(", ")} to allowBuilds in ${displayPath}. Void only edits allowBuilds when each entry is on its own line.`);
+		return;
+	}
+	const legacy = removeTopLevelYamlBlock(before, "onlyBuiltDependencies");
+	const current = removeTopLevelYamlBlock(legacy.yaml, "allowBuilds");
+	const after = insertPnpmAllowBuilds(current.yaml, pnpmAllowBuildsYaml(current.removed, legacy.removed));
 	if (after !== before) {
 		writeFileSync(workspacePath, after);
-		log.step(configRoot === root ? "Updated pnpm-workspace.yaml with approved builds" : `Updated ${relative(root, workspacePath)} with approved builds`);
-		return true;
+		log.step(`Updated ${displayPath} with approved builds`);
 	}
-	return false;
 }
 function installProjectDependencies(root, packageManager) {
-	log.step(`Installing dependencies with ${packageManager}`);
-	const result = spawnSync(packageManager, packageManager === "pnpm" ? ["install", "--no-frozen-lockfile"] : ["install"], {
+	const pkg = readPackageJson(root);
+	const useVitePlus = pkg !== null && hasPackageDependency(pkg, "vite-plus");
+	const installer = useVitePlus ? "vp" : packageManager;
+	log.step(`Installing dependencies with ${installer}`);
+	let command = installer;
+	let args = useVitePlus || packageManager === "pnpm" ? ["install", "--no-frozen-lockfile"] : ["install"];
+	if (useVitePlus) {
+		let localBin;
+		try {
+			const require = createRequire(join(root, "package.json"));
+			localBin = join(dirname(require.resolve("vite-plus/package.json")), "bin/vp");
+		} catch {}
+		if (localBin) {
+			command = process.execPath;
+			args = [localBin, ...args];
+		} else if (spawnSync("vp", ["--version"], {
+			cwd: root,
+			stdio: "ignore",
+			shell: process.platform === "win32",
+			timeout: 5e3
+		}).status !== 0) {
+			command = "npx";
+			const packageArg = `--package=vite-plus@${SCAFFOLD_VITE_PLUS_DEV_DEPENDENCIES["vite-plus"]}`;
+			args = [
+				"--yes",
+				process.platform === "win32" ? `"${packageArg}"` : packageArg,
+				"vp",
+				...args
+			];
+		}
+	}
+	const result = spawnSync(command, args, {
 		cwd: root,
 		stdio: "inherit",
-		shell: process.platform === "win32"
+		shell: command !== process.execPath && 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"}`);
-	log.step(`Installed dependencies with ${packageManager}`);
+	if (result.status !== 0) throw new Error(`${installer} install failed with exit code ${result.status ?? "unknown"}`);
+	log.step(`Installed dependencies with ${installer}`);
 }
 function generateStarterMigration(root, starterMode) {
 	const dialect = starterMode;
-	const configPath = writeDrizzleConfig(root, dialect === "postgresql" ? "postgresql://dummy" : dialect === "mysql" ? "mysql://dummy" : ":memory:", dialect);
-	const migrationsDir = readProjectPaths(root).migrationsDir;
-	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();
+	const configPath = writeDrizzleConfig(root, PLACEHOLDER_DB_URL[dialect], dialect);
+	const rollBack = snapshotDrizzleOutputs(readProjectPaths(root).migrationsDir);
 	log.step("Generating initial Drizzle migration");
 	const result = spawnSync(process.execPath, [
 		drizzleKitBin,
@@ -2192,37 +2083,9 @@ function generateStarterMigration(root, starterMode) {
 		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 || result.status !== 0) rollBack();
 	if (result.error) throw result.error;
 	if (result.status !== 0) {
 		const detail = [result.stderr, result.stdout].filter(Boolean).join("\n").trim();
@@ -2276,8 +2139,7 @@ function scaffoldPagesApp(root, packageManager, framework, starterMode, toolchai
 	};
 	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)) ensurePnpmAllowBuilds(root, pkg);
-	if (packageManager === "pnpm" && resolveWorkspaceDeferral(root, pkg) === void 0 && (!pkg.packageManager || typeof pkg.packageManager !== "string")) pkg.packageManager = "pnpm@12.4.1";
+	if (packageManager === "pnpm" || isPnpmProject(root, pkg)) ensurePnpmAllowBuilds(root, pkg);
 	writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
 	log.step("Updated package.json with starter scripts and dependencies");
 	for (const [filePath, content] of Object.entries(template.files)) writeFileIfMissing(root, filePath, content);
@@ -2292,11 +2154,7 @@ function scaffoldPagesApp(root, packageManager, framework, starterMode, toolchai
 	}
 	return dependencyAdded;
 }
-function hasDeclaredDependency(pkg, name) {
-	return DEPENDENCY_FIELDS.some((field) => {
-		return typeof asRecord(pkg[field])?.[name] === "string";
-	});
-}
+/** Returns whether a dependency was added. */
 function ensureExistingProjectPackage(root, options = {}) {
 	const packageJsonPath = join(root, "package.json");
 	const voidSpec = resolveScaffoldDependencySpec(root, "void", getOwnVersion());
@@ -2340,25 +2198,22 @@ function ensureExistingProjectPackage(root, options = {}) {
 	}
 	const devDependencies = asRecord(pkg.devDependencies) ?? {};
 	pkg.devDependencies = devDependencies;
-	if (!hasDeclaredDependency(pkg, "void")) {
+	if (!hasPackageDependency(pkg, "void", DEPENDENCY_FIELDS)) {
 		devDependencies.void = voidSpec;
 		changed = true;
 		dependencyAdded = true;
 	}
-	if (plainViteSetup && !hasDeclaredDependency(pkg, "vite")) {
+	if (plainViteSetup && !hasPackageDependency(pkg, "vite", DEPENDENCY_FIELDS)) {
 		devDependencies.vite = SCAFFOLD_BASE_DEV_DEPENDENCIES.vite;
 		changed = true;
 		dependencyAdded = true;
 	}
-	const pnpmConfigChanged = isPnpmProject(root, pkg) ? ensurePnpmAllowBuilds(root, pkg) : false;
+	if (isPnpmProject(root, pkg)) ensurePnpmAllowBuilds(root, pkg);
 	if (changed) {
 		writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
 		log.step(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 || pnpmConfigChanged
-	};
+	return dependencyAdded;
 }
 function getBasicVoidViteConfig() {
 	return `import { defineConfig } from "vite";
@@ -2410,28 +2265,20 @@ function ensureExistingProjectViteConfig(root, framework) {
 	writeFileSync(fullPath, updated);
 	log.step(`Added voidPlugin() to ${configPath}`);
 }
+/** Returns whether a dependency was added. */
 function setupExistingProject(root, framework) {
 	log.info("Existing project detected. Configuring Void...");
-	const packageResult = ensureExistingProjectPackage(root, { plainViteSetup: framework?.class !== "c" });
+	const dependencyAdded = ensureExistingProjectPackage(root, { plainViteSetup: framework?.class !== "c" });
 	ensureExistingProjectViteConfig(root, framework);
-	return packageResult;
+	return dependencyAdded;
 }
 /**
-* 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.
+* Scaffolds the "SQL → types → handler → fetch" demo into an existing project.
+* `setupExistingProject` has already declared `void` in `package.json`.
 */
 function scaffoldDemo(root) {
 	const devCommand = getDevCommand(root);
 	const paths = readProjectPaths(root);
-	const packageJsonMutated = ensureVoidDependency(root);
 	mkdirSync(paths.dbDir, { recursive: true });
 	writeFileSync(paths.schemaFile, `import { sql } from "void/db";
 import { integer, sqliteTable, text } from "void/schema-d1";
@@ -2472,61 +2319,6 @@ console.log(posts);
 	note(`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 = defaultPackageName(root);
-	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 (!hasDeclaredDependency(pkg, "void")) {
-		devDependencies.void = voidSpec;
-		changed = true;
-	}
-	const pnpmConfigChanged = isPnpmProject(root, pkg) ? ensurePnpmAllowBuilds(root, pkg) : false;
-	if (changed) {
-		writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2) + "\n");
-		log.step(existedBefore ? "Ensured void is in package.json devDependencies" : "Created package.json with void as a devDependency");
-	}
-	return changed || pnpmConfigChanged;
-}
-function getOwnVersion() {
-	return JSON.parse(readFileSync(join(getPackageDir(), "package.json"), "utf-8")).version;
 }
 const MARKER_VERSION_SOURCE = String.raw`\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?` + String.raw`(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?`;
 const MARKER_CLOSE = "<!--/injected-by-void-->";
@@ -2600,7 +2392,9 @@ async function runInitCommand(root, initArgs) {
 			log.info(`Detected ${SCAFFOLD_FRAMEWORKS[detectedPagesFramework].label} adapter in package.json`);
 		} else scaffoldedPagesFramework = await promptScaffoldFramework();
 		const starterMode = await promptStarterMode();
-		const scaffoldPackageManager = scaffoldToolchain === "vite-plus" ? "pnpm" : preScaffoldState.packageManager;
+		const existingPackageJson = readPackageJson(root);
+		const hasPackageManager = hasLocalLockfile(root) || existsSync(join(root, "pnpm-workspace.yaml")) || parsePackageManagerField(existingPackageJson) !== void 0 || resolveWorkspaceDeferral(root, existingPackageJson) !== void 0;
+		const scaffoldPackageManager = scaffoldToolchain === "vite-plus" && !hasPackageManager ? "pnpm" : preScaffoldState.packageManager;
 		const scaffoldWroteDeps = scaffoldPagesApp(root, scaffoldPackageManager, scaffoldedPagesFramework, starterMode, scaffoldToolchain);
 		const deferral = resolveWorkspaceDeferral(root, readPackageJson(root));
 		const voidResolvable = isVoidResolvableFrom(root);
@@ -2616,9 +2410,9 @@ async function runInitCommand(root, initArgs) {
 	const state = detectProjectState(root);
 	const pagesFramework = scaffoldedPagesFramework ?? detectPagesFramework(root);
 	if (!targeted && !didScaffoldStarter) {
-		const existingSetup = setupExistingProject(root, framework);
+		const dependencyAdded = setupExistingProject(root, framework);
 		const voidResolvable = isVoidResolvableFrom(root);
-		if (existingSetup.dependencyAdded || !voidResolvable) {
+		if (dependencyAdded || !voidResolvable) {
 			const deferral = resolveWorkspaceDeferral(root, readPackageJson(root));
 			if (deferral) {
 				workspaceSubpackageSkip = true;
@@ -2643,27 +2437,25 @@ async function runInitCommand(root, initArgs) {
 	await injectAgentBlock(root, newProject);
 	const agents = detectAgents(root);
 	if (agents.length > 0) {
-		const { linkSkillsForSpecificAgents } = await import("./skills-BgVMvQdy.mjs");
+		const { linkSkillsForSpecificAgents } = await import("./skills-BJsan98C.mjs");
 		linkSkillsForSpecificAgents(root, agents);
 	} else log.info("Bundled Void docs: node_modules/void/docs/");
 	if (!targeted && !framework) {
 		if (didScaffoldStarter || state.hasRoutes || state.hasMigrations || state.hasPages) log.info("Project already has pages, routes, or migrations, skipping demo");
-		else if (!state.typescriptWanted) {} else {
+		else {
 			const scaffold = await confirm({ message: "Scaffold demo code? (migration + API route + frontend fetch)" });
 			if (isCancel(scaffold)) {
 				cancel("Setup cancelled.");
 				process.exit(0);
 			}
 			if (scaffold) {
-				const { packageJsonMutated } = scaffoldDemo(root);
+				scaffoldDemo(root);
 				const voidResolvable = isVoidResolvableFrom(root);
 				const deferral = resolveWorkspaceDeferral(root, readPackageJson(root));
-				if (deferral && (!voidResolvable || packageJsonMutated)) {
-					workspaceSubpackageSkip = true;
+				if (deferral && !voidResolvable) {
 					const relRoot = relative(deferral.workspaceRoot, root) || ".";
-					const headline = 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,`;
-					note(`Scaffolded the starter demo in ./${relRoot}.\n\n${headline}\nthen run \`void db generate\` from ./${relRoot} to create the initial migration.`, "Workspace subpackage");
-				} else if (!voidResolvable || packageJsonMutated) scaffoldAddedDependencies = true;
+					note(`Scaffolded the starter demo in ./${relRoot}.\n\nRun 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");
+				}
 				scaffoldedStarterMode = "sqlite";
 			}
 		}
@@ -2672,11 +2464,10 @@ async function runInitCommand(root, initArgs) {
 	let voidPlatformDiscovery = null;
 	if (!targeted && deploymentPlatform === "cloudflare") await setupCloudflareDeployment(root);
 	if (!targeted && deploymentPlatform === "void") voidPlatformDiscovery = await ensureVoidPlatformConnection(root);
-	const githubStepSkipForSubpackage = workspaceSubpackage;
 	let shouldSetupGithub = targeted ? initArgs?.github === true : deploymentPlatform !== "none";
-	if (shouldSetupGithub && !githubStepSkipForSubpackage && deploymentPlatform !== "cloudflare" && deploymentPlatform !== "none") {
+	if (shouldSetupGithub && !workspaceSubpackage && deploymentPlatform !== "cloudflare" && deploymentPlatform !== "none") {
 		if (!voidPlatformDiscovery) {
-			const { getApiUrl } = await import("./auth-BgX2qYSY.mjs");
+			const { getApiUrl } = await import("./auth-wn6F8dB8.mjs");
 			voidPlatformDiscovery = await discoverPlatform(getApiUrl(root));
 		}
 		if (!voidPlatformDiscovery.capabilities.githubActions) {
@@ -2686,7 +2477,7 @@ async function runInitCommand(root, initArgs) {
 			shouldSetupGithub = false;
 		}
 	}
-	if (shouldSetupGithub && !githubStepSkipForSubpackage) {
+	if (shouldSetupGithub && !workspaceSubpackage) {
 		if (targeted) setupGithubActions(root, state, deploymentPlatform === "cloudflare" ? "cloudflare" : "void", voidPlatformDiscovery?.apiUrl);
 		else {
 			const setupGha = await confirm({ message: "Create .github/workflows/void-deploy.yml to deploy on pushes to main?" });
@@ -2696,7 +2487,7 @@ async function runInitCommand(root, initArgs) {
 			}
 			if (setupGha) setupGithubActions(root, state, deploymentPlatform === "cloudflare" ? "cloudflare" : "void", voidPlatformDiscovery?.apiUrl);
 		}
-	} else if (githubStepSkipForSubpackage && shouldSetupGithub) log.info("Skipping GitHub Actions setup: workflow files must live at the repo root, not in a workspace subpackage.");
+	} else if (workspaceSubpackage && shouldSetupGithub) log.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) {