@penvhq/cli 0.9.2 → 0.9.4

package/dist/index.js

@@ -59,7 +59,7 @@ var startChild = (invocation) => {
   const ended = new Promise((resolve9, reject) => {
     child.on("error", (cause) => {
       release();
-      reject(cannotStart(executable, cause));
+      reject(cannotStart(executable, cause, invocation.purpose));
     });
     child.on("exit", (code, signal) => {
       release();
@@ -80,8 +80,15 @@ function noCommand() {
     "Put the command after `--`, e.g. `penv run -- pnpm dev`."
   );
 }
-function cannotStart(executable, cause) {
+function cannotStart(executable, cause, purpose) {
   const detail = cause instanceof Error ? cause.message : String(cause);
+  if (purpose !== void 0) {
+    return new PenvError(
+      "PENV_COMMAND_NOT_STARTED",
+      `penv could not start \`${executable}\` to ${purpose}: ${detail}`,
+      `Check that \`${executable}\` runs on its own \u2014 penv starts it the way your shell does, so it has to be on PATH. Nothing was changed.`
+    );
+  }
   return new PenvError(
     "RUN_COMMAND_NOT_STARTED",
     `\`${executable}\` could not be started: ${detail}`,
@@ -110,12 +117,15 @@ function cmdCommandLine(resolved, args) {
     " "
   );
 }
-function extensions(env) {
+function extensions(env, platform) {
+  if (platform !== "win32") {
+    return [""];
+  }
   const declared = env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
-  return ["", ...declared.split(";").filter((extension) => extension.length > 0)];
+  return [...declared.split(";").filter((extension) => extension.length > 0), ""];
 }
-function findExecutable(executable, env) {
-  const candidates = extensions(env);
+function findExecutable(executable, env, platform = process.platform) {
+  const candidates = extensions(env, platform);
   const isFile = (path2) => existsSync(path2) && statSync(path2).isFile();
   if (executable.includes("/") || executable.includes("\\") || isAbsolute(executable)) {
     return candidates.map((extension) => executable + extension).find(isFile);
@@ -141,6 +151,7 @@ function escapeArgument(argument, doubleEscape) {
 
 // src/install.ts
 var RUNTIME_PACKAGE = "@penvhq/penv";
+var SCHEMA_PACKAGE = "zod";
 var LOCKFILES = [
   ["pnpm", "pnpm-lock.yaml"],
   ["yarn", "yarn.lock"],
@@ -155,13 +166,9 @@ var ADD = {
   bun: ["bun", "add", "--exact"]
 };
 function engineVersion() {
-  const manifest = new URL("../package.json", import.meta.url);
-  try {
-    const version = JSON.parse(readFileSync(manifest, "utf8")).version;
-    if (typeof version === "string" && version.length > 0) {
-      return version;
-    }
-  } catch {
+  const version = ownManifest()?.version;
+  if (typeof version === "string" && version.length > 0) {
+    return version;
   }
   throw new PenvError2(
     "ENGINE_VERSION_UNREADABLE",
@@ -169,6 +176,29 @@ function engineVersion() {
     `Reinstall penv, then run \`penv init\` again.`
   );
 }
+function schemaPackageVersion() {
+  const peers = ownManifest()?.peerDependencies;
+  const declared = peers !== null && typeof peers === "object" && !Array.isArray(peers) ? peers[SCHEMA_PACKAGE] : void 0;
+  const floor = typeof declared === "string" ? declared.replace(/^[\^~>=\s]+/, "").trim() : "";
+  if (floor.length > 0) {
+    return floor;
+  }
+  throw new PenvError2(
+    "ENGINE_PEER_UNREADABLE",
+    `penv could not read its own \`${SCHEMA_PACKAGE}\` peer range, so it cannot say which ${SCHEMA_PACKAGE} this project needs`,
+    `Reinstall penv, then run \`penv init\` again.`
+  );
+}
+function ownManifest() {
+  try {
+    const parsed = JSON.parse(
+      readFileSync(new URL("../package.json", import.meta.url), "utf8")
+    );
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function detectPackageManager(root) {
   for (const [manager, lockfile] of LOCKFILES) {
     if (existsSync2(join2(root, lockfile))) {
@@ -197,12 +227,12 @@ function manifestOf(root) {
     return void 0;
   }
 }
-function declaredVersion(root) {
+function declaredVersion(root, name) {
   const manifest = manifestOf(root);
   for (const field of ["dependencies", "devDependencies"]) {
     const block = manifest?.[field];
     if (block !== null && typeof block === "object" && !Array.isArray(block)) {
-      const version = block[RUNTIME_PACKAGE];
+      const version = block[name];
       if (typeof version === "string") {
         return version;
       }
@@ -215,27 +245,61 @@ function planInstall(root, version = engineVersion()) {
   const lockfile = LOCKFILES.find(
     ([name, file]) => name === manager && existsSync2(join2(root, file))
   )?.[1];
-  const declared = declaredVersion(root);
+  const runtimeDeclared = declaredVersion(root, RUNTIME_PACKAGE);
+  const zodDeclared = declaredVersion(root, SCHEMA_PACKAGE);
+  const packages = [
+    {
+      name: RUNTIME_PACKAGE,
+      version,
+      ...runtimeDeclared === void 0 ? {} : { declared: runtimeDeclared },
+      satisfied: runtimeDeclared === version
+    },
+    {
+      name: SCHEMA_PACKAGE,
+      version: schemaPackageVersion(),
+      ...zodDeclared === void 0 ? {} : { declared: zodDeclared },
+      // Any declared zod counts: which zod a project uses is the project's
+      // decision, and penv is here to make sure there is one, not to move it.
+      satisfied: zodDeclared !== void 0
+    }
+  ];
+  const pending = packages.filter((entry) => !entry.satisfied);
+  const specs = (pending.length === 0 ? packages : pending).map(
+    (entry) => `${entry.name}@${entry.version}`
+  );
   return {
     root,
     manager,
-    package: RUNTIME_PACKAGE,
-    version,
-    command: [...ADD[manager], `${RUNTIME_PACKAGE}@${version}`],
+    packages,
+    command: [...ADD[manager], ...specs],
     ...lockfile === void 0 ? {} : { lockfile },
-    ...declared === void 0 ? {} : { declared },
-    satisfied: declared === version
+    satisfied: pending.length === 0
   };
 }
+function describe(entry) {
+  return `${entry.name} ${entry.version}`;
+}
 function renderInstallPlan(plan2) {
   if (plan2.satisfied) {
-    return [`package.json already pins ${plan2.package} ${plan2.version} \u2014 nothing to install.`];
+    return [
+      `package.json already has ${plan2.packages.map(describe).join(" and ")} \u2014 nothing to install.`
+    ];
   }
-  const line = `"${plan2.package}": "${plan2.version}"`;
+  const pending = plan2.packages.filter((entry) => !entry.satisfied);
+  const added = pending.filter((entry) => entry.declared === void 0);
+  const replaced = pending.filter((entry) => entry.declared !== void 0);
   return [
     "package.json",
-    ...plan2.declared === void 0 ? ['  + "dependencies": {', `  +   ${line}`, "  + }"] : [`  - "${plan2.package}": "${plan2.declared}"`, `  + ${line}`],
-    ...plan2.lockfile === void 0 ? [] : [plan2.lockfile, `  + ${plan2.package}@${plan2.version}`],
+    ...added.length === 0 ? [] : [
+      '  + "dependencies": {',
+      ...added.map((entry) => `  +   "${entry.name}": "${entry.version}"`),
+      "  + }"
+    ],
+    ...replaced.flatMap((entry) => [
+      `  - "${entry.name}": "${entry.declared}"`,
+      `  + "${entry.name}": "${entry.version}"`
+    ]),
+    ...plan2.lockfile === void 0 ? [] : [plan2.lockfile, ...pending.map((entry) => `  + ${entry.name}@${entry.version}`)],
     "",
     `Run with: ${plan2.command.join(" ")}`
   ];
@@ -244,7 +308,8 @@ var installWithPackageManager = async (plan2) => {
   const child = startChild({
     command: plan2.command,
     env: process.env,
-    cwd: plan2.root
+    cwd: plan2.root,
+    purpose: `install ${plan2.packages.map(describe).join(" and ")}`
   });
   const ended = await child.ended;
   if (ended.exitCode !== 0 || ended.signal !== null) {
@@ -2152,20 +2217,20 @@ function readCutover(root) {
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw unreadable("it is not an object");
   }
-  const record = parsed;
-  if (record.format !== CUTOVER_FORMAT) {
+  const record2 = parsed;
+  if (record2.format !== CUTOVER_FORMAT) {
     throw unreadable(
-      `it is format ${JSON.stringify(record.format)}, and penv reads format ${CUTOVER_FORMAT}`
+      `it is format ${JSON.stringify(record2.format)}, and penv reads format ${CUTOVER_FORMAT}`
     );
   }
-  const files = record.files;
+  const files = record2.files;
   if (!Array.isArray(files) || files.some((name) => typeof name !== "string")) {
     throw unreadable("it lists no filenames");
   }
-  const environments = Array.isArray(record.environments) ? record.environments.filter((name) => typeof name === "string") : [];
+  const environments = Array.isArray(record2.environments) ? record2.environments.filter((name) => typeof name === "string") : [];
   return {
     format: CUTOVER_FORMAT,
-    movedAt: typeof record.movedAt === "string" ? record.movedAt : "",
+    movedAt: typeof record2.movedAt === "string" ? record2.movedAt : "",
     files,
     environments
   };
@@ -4216,7 +4281,7 @@ var getCommand = defineCommand12({
 });
 
 // src/commands/import.ts
-import { copyFileSync, existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { copyFileSync, existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
 import { basename as basename2, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve7 } from "path";
 import {
   assertNever as assertNever2,
@@ -4470,8 +4535,8 @@ function draftFieldsAcross(sources, environments) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readdirSync as readdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname5, join as join8, resolve as resolve6 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync4, readdirSync as readdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname6, join as join9, resolve as resolve6 } from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import {
   CUTOVER_PATH as CUTOVER_PATH3,
@@ -4494,6 +4559,97 @@ import {
 } from "@penvhq/core";
 import { defineCommand as defineCommand13 } from "citty";
 
+// src/scaffold-undo.ts
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync7,
+  rmdirSync,
+  statSync as statSync3,
+  unlinkSync,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { dirname as dirname5, join as join8 } from "path";
+function record(path, files, dirs) {
+  let stats;
+  try {
+    stats = statSync3(path);
+  } catch {
+    return;
+  }
+  if (stats.isDirectory()) {
+    dirs.add(path);
+    for (const entry of readdirSync4(path)) {
+      record(join8(path, entry), files, dirs);
+    }
+    return;
+  }
+  if (stats.isFile()) {
+    files.set(path, readFileSync7(path));
+  }
+}
+function captureScaffold(root, paths) {
+  const files = /* @__PURE__ */ new Map();
+  const dirs = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    for (let dir = dirname5(path); dir.startsWith(root) && dir !== root; dir = dirname5(dir)) {
+      if (existsSync7(dir)) {
+        dirs.add(dir);
+      }
+    }
+    record(path, files, dirs);
+  }
+  return { root, paths: [...paths], files, dirs };
+}
+function restoreScaffold(undo) {
+  for (const path of undo.paths) {
+    removeAdded(path, undo);
+  }
+  for (const path of undo.paths) {
+    pruneAncestors(path, undo);
+  }
+  for (const [file, contents] of undo.files) {
+    mkdirSync3(dirname5(file), { recursive: true });
+    writeFileSync4(file, contents);
+  }
+}
+function removeAdded(path, undo) {
+  let stats;
+  try {
+    stats = statSync3(path);
+  } catch {
+    return;
+  }
+  if (stats.isFile()) {
+    if (!undo.files.has(path)) {
+      unlinkSync(path);
+    }
+    return;
+  }
+  if (!stats.isDirectory()) {
+    return;
+  }
+  for (const entry of readdirSync4(path)) {
+    removeAdded(join8(path, entry), undo);
+  }
+  if (!undo.dirs.has(path) && readdirSync4(path).length === 0) {
+    rmdirSync(path);
+  }
+}
+function pruneAncestors(path, undo) {
+  for (let dir = dirname5(path); dir.startsWith(undo.root) && dir !== undo.root; dir = dirname5(dir)) {
+    if (undo.dirs.has(dir)) {
+      return;
+    }
+    try {
+      rmdirSync(dir);
+    } catch {
+      return;
+    }
+  }
+}
+
 // src/seams.ts
 function nextjs({ alias, srcDir }) {
   return {
@@ -4649,7 +4805,7 @@ var NOT_ENVIRONMENTS2 = [...RESERVED_TOKENS2, "example", "sample", "template"];
 function suggestEnvironments(root) {
   let entries;
   try {
-    entries = readdirSync4(root);
+    entries = readdirSync5(root);
   } catch {
     return [];
   }
@@ -4693,8 +4849,8 @@ function configOf(decisions) {
   return { environments: decisions.environments, providers: {}, schemaFile: decisions.schemaFile };
 }
 function declaredIn(root) {
-  const file = join8(root, CONFIG_FILE);
-  if (!existsSync7(file)) {
+  const file = join9(root, CONFIG_FILE);
+  if (!existsSync8(file)) {
     return void 0;
   }
   return loadConfigFrom(file);
@@ -5137,15 +5293,15 @@ function renderTsconfig(target, alias) {
 }
 function ensurePenvDir(root) {
   const dir = resolve6(root, PENV_DIR2);
-  if (existsSync7(dir)) {
+  if (existsSync8(dir)) {
     return { target: "penv-dir", action: "kept", text: `Found ${PENV_DIR2}/` };
   }
-  mkdirSync3(dir, { recursive: true });
+  mkdirSync4(dir, { recursive: true });
   return { target: "penv-dir", action: "created", text: `Created ${PENV_DIR2}/` };
 }
 function writeSchemaShapeFile(root, fields, draft, decisions = DEFAULT_DECISIONS) {
-  const file = join8(root, SCHEMA_SHAPE_FILE3);
-  if (existsSync7(file)) {
+  const file = join9(root, SCHEMA_SHAPE_FILE3);
+  if (existsSync8(file)) {
     return {
       target: "schema",
       action: "kept",
@@ -5162,7 +5318,7 @@ function writeSchemaShapeFile(root, fields, draft, decisions = DEFAULT_DECISIONS
       note: `(the shape lives there, from before the ${SCHEMA_SHAPE_FILE3} split \u2014 penv did not add a second one. To adopt the split: move the \`z.object\` (and any \`declare module\` block) into ${SCHEMA_SHAPE_FILE3}, leaving ${oldLayout} importing \`schema\` from it and calling \`load\`.)`
     };
   }
-  writeFileSync4(file, renderSchemaShapeModule(fields, draft), "utf8");
+  writeFileSync5(file, renderSchemaShapeModule(fields, draft), "utf8");
   return {
     target: "schema",
     action: "created",
@@ -5171,8 +5327,8 @@ function writeSchemaShapeFile(root, fields, draft, decisions = DEFAULT_DECISIONS
   };
 }
 function writeEnvFile(root, decisions = DEFAULT_DECISIONS) {
-  const file = join8(root, ...decisions.schemaFile.split("/"));
-  if (existsSync7(file)) {
+  const file = join9(root, ...decisions.schemaFile.split("/"));
+  if (existsSync8(file)) {
     return {
       target: "env",
       action: "kept",
@@ -5180,8 +5336,8 @@ function writeEnvFile(root, decisions = DEFAULT_DECISIONS) {
       note: "(yours \u2014 penv never regenerates it)"
     };
   }
-  mkdirSync3(dirname5(file), { recursive: true });
-  writeFileSync4(file, renderEnvModule(decisions.schemaFile, decisions.inject), "utf8");
+  mkdirSync4(dirname6(file), { recursive: true });
+  writeFileSync5(file, renderEnvModule(decisions.schemaFile, decisions.inject), "utf8");
   return {
     target: "env",
     action: "created",
@@ -5190,19 +5346,19 @@ function writeEnvFile(root, decisions = DEFAULT_DECISIONS) {
   };
 }
 function writeConfigFile(root, decisions = DEFAULT_DECISIONS) {
-  const file = join8(root, CONFIG_FILE);
-  if (existsSync7(file)) {
+  const file = join9(root, CONFIG_FILE);
+  if (existsSync8(file)) {
     return { target: "config", action: "kept", text: `Kept ${CONFIG_FILE}` };
   }
-  writeFileSync4(file, renderConfigModule(decisions), "utf8");
+  writeFileSync5(file, renderConfigModule(decisions), "utf8");
   return { target: "config", action: "created", text: `Generated ${CONFIG_FILE}` };
 }
 function writeTsconfigAlias(root, decisions = DEFAULT_DECISIONS) {
   const alias = decisions.alias;
   const imports = alias.startsWith(IMPORTS_PREFIX);
-  const file = join8(root, imports ? PACKAGE_FILE : TSCONFIG_FILE);
+  const file = join9(root, imports ? PACKAGE_FILE : TSCONFIG_FILE);
   const where = imports ? PACKAGE_FILE : TSCONFIG_FILE;
-  if (!existsSync7(file)) {
+  if (!existsSync8(file)) {
     if (imports) {
       return {
         target: "tsconfig",
@@ -5211,14 +5367,14 @@ function writeTsconfigAlias(root, decisions = DEFAULT_DECISIONS) {
         note: `(run \`npm init\` first, or use \`--alias @env\` to alias through ${TSCONFIG_FILE})`
       };
     }
-    writeFileSync4(file, renderTsconfig(decisions.schemaFile, alias), "utf8");
+    writeFileSync5(file, renderTsconfig(decisions.schemaFile, alias), "utf8");
     return {
       target: "tsconfig",
       action: "created",
       text: `Created ${TSCONFIG_FILE} with the ${alias} path alias`
     };
   }
-  const source = readFileSync7(file, "utf8");
+  const source = readFileSync8(file, "utf8");
   const edit = imports ? insertImportsAlias(source, decisions.schemaFile, alias) : insertEnvAlias(source, decisions.schemaFile, alias);
   if (edit.conflict !== void 0) {
     return {
@@ -5235,7 +5391,7 @@ function writeTsconfigAlias(root, decisions = DEFAULT_DECISIONS) {
       text: `Kept the ${alias} alias in ${where}`
     };
   }
-  writeFileSync4(file, edit.source, "utf8");
+  writeFileSync5(file, edit.source, "utf8");
   return {
     target: "tsconfig",
     action: "updated",
@@ -5243,14 +5399,14 @@ function writeTsconfigAlias(root, decisions = DEFAULT_DECISIONS) {
   };
 }
 function writeGitignore(root, decisions = DEFAULT_DECISIONS) {
-  const file = join8(root, ...STATE_GITIGNORE_PATH.split("/"));
+  const file = join9(root, ...STATE_GITIGNORE_PATH.split("/"));
   const wanted = renderStateGitignore(configOf(decisions));
-  const existing = existsSync7(file) ? readFileSync7(file, "utf8") : void 0;
+  const existing = existsSync8(file) ? readFileSync8(file, "utf8") : void 0;
   if (existing === wanted) {
     return { target: "gitignore", action: "kept", text: `Kept ${STATE_GITIGNORE_PATH}` };
   }
-  mkdirSync3(dirname5(file), { recursive: true });
-  writeFileSync4(file, wanted, "utf8");
+  mkdirSync4(dirname6(file), { recursive: true });
+  writeFileSync5(file, wanted, "utf8");
   return {
     target: "gitignore",
     action: existing === void 0 ? "created" : "updated",
@@ -5266,12 +5422,12 @@ function outdatedRuntimeWarning(root) {
   return `Injection needs @penvhq/penv ${INJECT_MIN_VERSION}+ \u2014 this project has ${version}, whose \`load\` ignores \`{ inject: true }\`. Upgrade, or process.env stays empty.`;
 }
 function installedPenvVersion(root) {
-  const file = join8(root, "node_modules", "@penvhq", "penv", "package.json");
-  if (!existsSync7(file)) {
+  const file = join9(root, "node_modules", "@penvhq", "penv", "package.json");
+  if (!existsSync8(file)) {
     return void 0;
   }
   try {
-    const version = JSON.parse(readFileSync7(file, "utf8")).version;
+    const version = JSON.parse(readFileSync8(file, "utf8")).version;
     return typeof version === "string" ? version : void 0;
   } catch {
     return void 0;
@@ -5311,11 +5467,11 @@ function writeSeam(root, decisions = DEFAULT_DECISIONS, framework = detectFramew
     };
   }
   const alsoNote = writeAlso(root, seam.also);
-  const file = join8(root, ...seam.file.split("/"));
+  const file = join9(root, ...seam.file.split("/"));
   const baseNotes = [...seam.notes, ...alsoNote === void 0 ? [] : [alsoNote]];
   const notes = baseNotes.length === 0 ? "" : `
 ${baseNotes.map((n) => `  ${n}`).join("\n")}`;
-  if (existsSync7(file)) {
+  if (existsSync8(file)) {
     return {
       target: "seam",
       action: "info",
@@ -5323,8 +5479,8 @@ ${baseNotes.map((n) => `  ${n}`).join("\n")}`;
       note: withWarning(`${seam.ifPresent}${notes}`, outdated)
     };
   }
-  mkdirSync3(dirname5(file), { recursive: true });
-  writeFileSync4(file, seam.content, "utf8");
+  mkdirSync4(dirname6(file), { recursive: true });
+  writeFileSync5(file, seam.content, "utf8");
   return {
     target: "seam",
     action: outdated === void 0 ? "created" : "info",
@@ -5336,12 +5492,12 @@ function writeAlso(root, also) {
   if (also === void 0) {
     return void 0;
   }
-  const file = join8(root, ...also.file.split("/"));
-  if (existsSync7(file)) {
+  const file = join9(root, ...also.file.split("/"));
+  if (existsSync8(file)) {
     return also.ifPresent;
   }
-  mkdirSync3(dirname5(file), { recursive: true });
-  writeFileSync4(file, also.content, "utf8");
+  mkdirSync4(dirname6(file), { recursive: true });
+  writeFileSync5(file, also.content, "utf8");
   return `Wrote ${also.file} to register it.`;
 }
 function withWarning(note, warning) {
@@ -5366,6 +5522,23 @@ function scaffold(root, fields, draft, decisions = DEFAULT_DECISIONS, framework
   const seam = writeSeam(root, decisions, framework);
   return seam === void 0 ? steps : [...steps, seam];
 }
+function scaffoldPaths(root, decisions = DEFAULT_DECISIONS, framework = detectFramework(root)?.name) {
+  const fileAt = (relative5) => join9(root, ...relative5.split("/"));
+  const seam = decisions.inject ? seamFor(framework, {
+    alias: decisions.alias,
+    srcDir: srcPrefix(root),
+    schemaFile: decisions.schemaFile
+  }) : void 0;
+  return [
+    fileAt(PENV_DIR2),
+    fileAt(SCHEMA_SHAPE_FILE3),
+    fileAt(decisions.schemaFile),
+    fileAt(CONFIG_FILE),
+    fileAt(TSCONFIG_FILE),
+    fileAt(PACKAGE_FILE),
+    ...seam?.kind === "scaffold" ? [fileAt(seam.file), ...seam.also === void 0 ? [] : [fileAt(seam.also.file)]] : []
+  ];
+}
 var DEVELOPMENT = "development";
 var LOCAL_PROVIDER = "@penvhq/provider-filesystem";
 function planAdoption(root) {
@@ -5428,7 +5601,7 @@ function planCutover(input) {
   const diagnostics = [];
   let variables = 0;
   for (const file of selected) {
-    const parsed = parseDotenv(readFileSync7(join8(root, file.name), "utf8"));
+    const parsed = parseDotenv(readFileSync8(join9(root, file.name), "utf8"));
     const fileRefs = refsForEntries(parsed.entries, file.name, config);
     adopted.push({ file, entries: parsed.entries, refs: fileRefs, scope: scopeOf(file) });
     refs.push(...fileRefs);
@@ -5539,17 +5712,27 @@ async function applyCutover(plan2, options = {}) {
   if (!plan2.install.satisfied) {
     await (options.install ?? installWithPackageManager)(plan2.install);
   }
-  const steps = scaffold(plan2.root, plan2.fields, true, plan2.decisions, plan2.framework);
-  const project = openProject(plan2.root);
-  const tree = localTree(project);
-  for (const adopted of plan2.adopted) {
-    writeEntries(tree, adopted.entries, adopted.refs, adopted.scope);
-  }
-  for (const environment of plan2.adopting) {
-    const check = await checkEnvironment(project, environment);
-    if (!check.result.ok) {
-      throw invalidAfterImport(check.result);
+  const undo = captureScaffold(plan2.root, scaffoldPaths(plan2.root, plan2.decisions, plan2.framework));
+  let steps;
+  try {
+    steps = scaffold(plan2.root, plan2.fields, true, plan2.decisions, plan2.framework);
+    const project = openProject(plan2.root);
+    const tree = localTree(project);
+    for (const adopted of plan2.adopted) {
+      writeEntries(tree, adopted.entries, adopted.refs, adopted.scope);
+    }
+    for (const environment of plan2.adopting) {
+      const check = await checkEnvironment(project, environment);
+      if (check.schema === void 0) {
+        throw draftNotLoaded(check.result);
+      }
+      if (!check.result.ok) {
+        throw invalidAfterImport(check.result);
+      }
     }
+  } catch (error) {
+    restoreScaffold(undo);
+    throw error;
   }
   const cutover = bundleDotenvFiles(
     plan2.root,
@@ -5558,13 +5741,24 @@ async function applyCutover(plan2, options = {}) {
   );
   return { plan: plan2, steps, moved: cutover.files, validated: plan2.adopting };
 }
+function issueLines(result2) {
+  return result2.issues.map((issue) => `  ${issue.subject}: ${issue.message}`).join("\n");
+}
+var SCAFFOLD_ROLLED_BACK = "penv put the project back as it found it \u2014 your dotenv files and everything else are exactly where they were.";
 function invalidAfterImport(result2) {
-  const lines = result2.issues.map((issue) => `  ${issue.subject}: ${issue.message}`).join("\n");
   return new PenvError18(
     "INIT_CUTOVER_INVALID",
-    `The imported values do not satisfy the draft schema for ${result2.environment}, so your dotenv files were left where they are:
-${lines}`,
-    `Correct ${SCHEMA_SHAPE_FILE3} or the values above, then run \`penv init\` again.`
+    `The imported values do not satisfy the draft schema for ${result2.environment}:
+${issueLines(result2)}`,
+    `Correct the values above, then run \`penv init\` again. ${SCAFFOLD_ROLLED_BACK}`
+  );
+}
+function draftNotLoaded(result2) {
+  return new PenvError18(
+    "INIT_DRAFT_NOT_LOADED",
+    `penv could not load the schema it drafted for ${result2.environment}, so nothing was checked against it:
+${issueLines(result2)}`,
+    `Fix the error above, then run \`penv init\` again. ${SCAFFOLD_ROLLED_BACK}`
   );
 }
 function renderSelection(plan2, selected = plan2.preselected) {
@@ -5627,7 +5821,7 @@ function renderCutover(result2) {
       const glyph = step.action === "conflicted" ? WARN : step.action === "info" ? "\u2192" : CHECK;
       return step.note === void 0 ? { glyph, text: step.text } : { glyph, text: step.text, note: step.note };
     }),
-    ...plan2.install.satisfied ? [] : [{ glyph: CHECK, text: `Installed ${plan2.install.package}`, note: plan2.install.version }],
+    ...plan2.install.packages.filter((entry) => !entry.satisfied).map((entry) => ({ glyph: CHECK, text: `Installed ${entry.name}`, note: entry.version })),
     {
       glyph: CHECK,
       text: `Imported ${plan2.fields.length} parameters`,
@@ -5651,12 +5845,12 @@ function dailyCommand(root) {
   return `penv run -- ${detectPackageManager(root)} ${devScript(root)}`;
 }
 function devScript(root) {
-  const file = join8(root, PACKAGE_FILE);
-  if (!existsSync7(file)) {
+  const file = join9(root, PACKAGE_FILE);
+  if (!existsSync8(file)) {
     return "dev";
   }
   try {
-    const scripts = JSON.parse(readFileSync7(file, "utf8")).scripts;
+    const scripts = JSON.parse(readFileSync8(file, "utf8")).scripts;
     if (scripts !== null && typeof scripts === "object" && !Array.isArray(scripts)) {
       const named = Object.keys(scripts);
       return ["dev", "start"].find((script) => named.includes(script)) ?? named[0] ?? "dev";
@@ -6025,14 +6219,14 @@ function configInEffect(cwd, environment) {
 function importDotenv(options) {
   const cwd = resolve7(options.cwd);
   const file = isAbsolute4(options.file) ? options.file : resolve7(cwd, options.file);
-  if (!existsSync8(file)) {
+  if (!existsSync9(file)) {
     throw new PenvError19(
       "IMPORT_FILE_MISSING",
       `There is no file at ${file} to import`,
       "Point `penv import` at an existing dotenv file, e.g. `penv import .env`."
     );
   }
-  const parsed = parseDotenv2(readFileSync8(file, "utf8"));
+  const parsed = parseDotenv2(readFileSync9(file, "utf8"));
   const { config, decisions } = configInEffect(cwd, environmentNamed(file, options.environment));
   const source = displayPath3(cwd, file);
   const named = scopeFromFilename(file, config);
@@ -6383,15 +6577,15 @@ var listCommand = defineCommand16({
 
 // src/commands/migrate.ts
 import {
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync4,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync9,
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync5,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync10,
   renameSync as renameSync2,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "fs";
-import { dirname as dirname6, join as join9 } from "path";
+import { dirname as dirname7, join as join10 } from "path";
 import { createInterface as createInterface3 } from "readline/promises";
 import {
   loadConfig as loadConfig2,
@@ -6407,22 +6601,22 @@ import { defineCommand as defineCommand17 } from "citty";
 var OLD_GITIGNORE = `${PENV_DIR3}/.gitignore`;
 function planMigrate(cwd) {
   const { config, file } = loadConfig2(cwd);
-  const root = dirname6(file);
+  const root = dirname7(file);
   const entries = oldLayoutEntries(root, config);
   const tree = recordsDir3(root);
   const collisions = collidingEntries(entries, tree);
   if (collisions.length > 0) {
     throw new PenvError22(
       "HALF_MIGRATED",
-      `${describe(collisions)} in both \`${PENV_DIR3}/\` and \`${RECORDS_PATH4}/\`, and penv cannot tell which copy is current`,
+      `${describe2(collisions)} in both \`${PENV_DIR3}/\` and \`${RECORDS_PATH4}/\`, and penv cannot tell which copy is current`,
       `Move what is left under \`${PENV_DIR3}/\` into \`${RECORDS_PATH4}/\` yourself, keeping the copy you want, then run \`penv validate\`.`
     );
   }
   const creates = [];
-  if (entries.length > 0 && !existsSync9(tree)) {
+  if (entries.length > 0 && !existsSync10(tree)) {
     creates.push(`${RECORDS_PATH4}/`);
   }
-  if (readIfPresent(join9(root, ...STATE_GITIGNORE_PATH2.split("/"))) !== renderStateGitignore2(config)) {
+  if (readIfPresent(join10(root, ...STATE_GITIGNORE_PATH2.split("/"))) !== renderStateGitignore2(config)) {
     creates.push(STATE_GITIGNORE_PATH2);
   }
   return {
@@ -6432,23 +6626,23 @@ function planMigrate(cwd) {
       to: `${RECORDS_PATH4}/${entry}`
     })),
     creates,
-    removes: existsSync9(join9(root, ...OLD_GITIGNORE.split("/"))) ? [OLD_GITIGNORE] : []
+    removes: existsSync10(join10(root, ...OLD_GITIGNORE.split("/"))) ? [OLD_GITIGNORE] : []
   };
 }
 function readIfPresent(file) {
-  return existsSync9(file) ? readFileSync9(file, "utf8") : void 0;
+  return existsSync10(file) ? readFileSync10(file, "utf8") : void 0;
 }
 function collidingEntries(entries, tree) {
   let held;
   try {
-    held = readdirSync5(tree);
+    held = readdirSync6(tree);
   } catch {
     return [];
   }
   const taken = new Set(held.map((name) => name.toLowerCase()));
   return entries.filter((entry) => taken.has(entry.toLowerCase())).sort();
 }
-function describe(names) {
+function describe2(names) {
   return names.length === 1 ? `\`${names[0]}\` is` : `${names.map((name) => `\`${name}\``).join(", ")} are`;
 }
 function isNoop(plan2) {
@@ -6460,18 +6654,18 @@ function applyMigrate(plan2) {
   }
   const { config } = loadConfig2(plan2.root);
   if (plan2.moves.length > 0) {
-    mkdirSync4(recordsDir3(plan2.root), { recursive: true });
+    mkdirSync5(recordsDir3(plan2.root), { recursive: true });
     for (const move of plan2.moves) {
-      renameSync2(join9(plan2.root, ...move.from.split("/")), join9(plan2.root, ...move.to.split("/")));
+      renameSync2(join10(plan2.root, ...move.from.split("/")), join10(plan2.root, ...move.to.split("/")));
     }
   }
   if (plan2.creates.includes(STATE_GITIGNORE_PATH2)) {
-    const ignore = join9(plan2.root, ...STATE_GITIGNORE_PATH2.split("/"));
-    mkdirSync4(dirname6(ignore), { recursive: true });
-    writeFileSync5(ignore, renderStateGitignore2(config), "utf8");
+    const ignore = join10(plan2.root, ...STATE_GITIGNORE_PATH2.split("/"));
+    mkdirSync5(dirname7(ignore), { recursive: true });
+    writeFileSync6(ignore, renderStateGitignore2(config), "utf8");
   }
   for (const removed of plan2.removes) {
-    rmSync2(join9(plan2.root, ...removed.split("/")), { force: true });
+    rmSync2(join10(plan2.root, ...removed.split("/")), { force: true });
   }
   return { ...plan2, status: "migrated" };
 }
@@ -6973,8 +7167,8 @@ var rotateCommand = defineCommand20({
 });
 
 // src/commands/watch.ts
-import { existsSync as existsSync10, watch as watch2 } from "fs";
-import { basename as basename3, dirname as dirname7, resolve as resolve8 } from "path";
+import { existsSync as existsSync11, watch as watch2 } from "fs";
+import { basename as basename3, dirname as dirname8, resolve as resolve8 } from "path";
 import { SCHEMA_SHAPE_FILE as SCHEMA_SHAPE_FILE4, schemaFileOf as schemaFileOf5, schemaInsideTree } from "@penvhq/core";
 import { defineCommand as defineCommand21 } from "citty";
 var DEBOUNCE_MS2 = 100;
@@ -7033,7 +7227,7 @@ function runWatch(options) {
     watcher.close();
   }
   function armRecovery(target, recursive, only) {
-    const parent = dirname7(target);
+    const parent = dirname8(target);
     const name = basename3(target);
     let recovery;
     try {
@@ -7041,14 +7235,14 @@ function runWatch(options) {
         if (closed || recovery === void 0) {
           return;
         }
-        if (!existsSync10(parent)) {
+        if (!existsSync11(parent)) {
           stop2(recovery);
           return;
         }
         if (filename !== null && basename3(filename) !== name) {
           return;
         }
-        if (!existsSync10(target)) {
+        if (!existsSync11(target)) {
           return;
         }
         stop2(recovery);
@@ -7072,7 +7266,7 @@ function runWatch(options) {
       if (closed) {
         return;
       }
-      if (!existsSync10(target)) {
+      if (!existsSync11(target)) {
         if (watcher !== void 0) {
           stop2(watcher);
         }
@@ -7107,11 +7301,11 @@ function runWatch(options) {
     watchers.add(watcher);
   }
   addWatcher(project.recordsDir, true);
-  addWatcher(dirname7(project.configFile), false, configFile);
+  addWatcher(dirname8(project.configFile), false, configFile);
   addWatcher(project.root, false, SCHEMA_SHAPE_FILE4);
   if (schemaInsideTree(project.config) === void 0) {
     const schemaFile = resolve8(project.root, schemaFileOf5(project.config));
-    addWatcher(dirname7(schemaFile), false, basename3(schemaFile));
+    addWatcher(dirname8(schemaFile), false, basename3(schemaFile));
   }
   void validate();
   return {