@cellajs/cli 0.6.4 → 0.6.6

package/dist/index.js

@@ -49,6 +49,7 @@ async function importFromApp(forkPath, file) {
   setEnv("NODE_ENV", "development");
   return import(pathToFileURL(path).href);
 }
+var movedPath = (forkPath, current, legacy) => !existsSync(join(forkPath, current)) && existsSync(join(forkPath, legacy)) ? legacy : current;
 async function loadAppFacts(forkPath) {
   const parsed2 = appConfigSchema.safeParse((await importFromApp(forkPath, "shared/index.ts")).appConfig);
   if (!parsed2.success)
@@ -233,7 +234,7 @@ import process6 from "process";
 // package.json
 var package_default = {
   name: "@cellajs/cli",
-  version: "0.6.4",
+  version: "0.6.6",
   private: false,
   license: "MIT",
   description: "CLI for managing your monorepo and upgrading it with upstream Cella.",
@@ -761,6 +762,15 @@ async function gitMv(cwd, oldPath, newPath) {
   await mkdir2(newDir, { recursive: true });
   await git(["mv", "-f", oldPath, newPath], cwd);
 }
+async function moveFromRef(cwd, ref, from, to) {
+  const [mode, , blob] = (await git(["ls-tree", ref, "--", from], cwd)).split(/\s+/);
+  if (!blob) throw new Error(`${ref} holds no ${from}`);
+  await gitRm(cwd, [to], { cached: true });
+  await git(["update-index", "--add", "--cacheinfo", `${mode},${blob},${to}`], cwd);
+  await mkdir2(dirname3(join3(cwd, to)), { recursive: true });
+  await git(["checkout-index", "-f", "--", to], cwd);
+  await removeFileFully(cwd, from);
+}
 async function fileExistsInWorktree(cwd, filePath) {
   return existsSync3(join3(cwd, filePath));
 }
@@ -1373,12 +1383,20 @@ var STARTUP_TIMEOUT_MS = 5 * 6e4;
 var STOP_TIMEOUT_MS = 1e4;
 var DATABASE = "testbed";
 var DATABASE_SERVICE = "db_testbed";
+var showcaseFile = (forkPath) => movedPath(forkPath, "backend/scripts/seeds/showcase.json", "json/showcase.json");
+var showcasePath = (forkPath) => join4(forkPath, showcaseFile(forkPath));
+var hasShowcase = (forkPath) => existsSync4(showcasePath(forkPath));
+function showcaseAdmin(forkPath) {
+  const { admin } = JSON.parse(readFileSync2(showcasePath(forkPath), "utf8"));
+  if (typeof admin?.email !== "string") throw new Error(`${showcaseFile(forkPath)} names no admin email`);
+  return admin.email;
+}
 var shiftPort = (url) => {
   const next = new URL(url);
   next.port = String(Number(next.port) + PORT_SHIFT);
   return next.toString().replace(/\/$/, "");
 };
-async function resolveTestbed(forkPath) {
+async function resolveTestbed(forkPath, data = "seed") {
   const [facts, databases] = await Promise.all([loadAppFacts(forkPath), loadLocalDatabases(forkPath)]);
   const databasePort = databases.port(DATABASE);
   if (!Number.isInteger(databasePort)) {
@@ -1398,6 +1416,7 @@ async function resolveTestbed(forkPath) {
       // The seed creates the admin that backend/.env names, and a command signs in as that user
       ...fileEnv.ADMIN_EMAIL ? { ADMIN_EMAIL: fileEnv.ADMIN_EMAIL } : {},
       ...getEnvSnapshot(),
+      ...data === "showcase" ? { ADMIN_EMAIL: showcaseAdmin(forkPath) } : {},
       ...composeEnv,
       NODE_ENV: "development",
       DATABASE_URL: databases.url(DATABASE, "runtime_role"),
@@ -1411,12 +1430,22 @@ async function resolveTestbed(forkPath) {
       ({ port, internalPort }) => (internalPort === void 0 ? [port] : [port, internalPort]).map((value) => value + PORT_SHIFT)
     ),
     container: `${composeEnv.PROJECT_SLUG}_${DATABASE_SERVICE}`,
+    data,
     yjs: facts.services.yjs?.enabled ?? false,
     stateDir: toolDir(forkPath, "testbed", "repository")
   };
 }
 var lockPath = (testbed) => join4(testbed.stateDir, "lock.json");
 var logPath = (testbed) => join4(testbed.stateDir, "testbed.log");
+var dataPath = (testbed) => join4(testbed.stateDir, "data.json");
+function heldData(testbed) {
+  try {
+    return JSON.parse(readFileSync2(dataPath(testbed), "utf8")).data === "showcase" ? "showcase" : "seed";
+  } catch {
+    return "seed";
+  }
+}
+var describeData = (data) => data === "showcase" ? "the showcase" : "the seed data";
 function isAlive(pid) {
   try {
     process8.kill(pid, 0);
@@ -1498,7 +1527,12 @@ async function startTestbed(testbed, fresh, drop = false) {
   mkdirSync(testbed.stateDir, { recursive: true });
   writeFileSync(
     lockPath(testbed),
-    JSON.stringify({ pid: process8.pid, forkPath: testbed.forkPath, frontendUrl: testbed.frontendUrl })
+    JSON.stringify({
+      pid: process8.pid,
+      forkPath: testbed.forkPath,
+      frontendUrl: testbed.frontendUrl,
+      data: testbed.data
+    })
   );
   const log = openSync(logPath(testbed), "w");
   let stack;
@@ -1525,14 +1559,15 @@ async function startTestbed(testbed, fresh, drop = false) {
   };
   const forget = onShutdown(stop);
   try {
-    if (fresh) removeDatabase(testbed);
+    if (fresh || testbed.data === "showcase" || heldData(testbed) !== testbed.data) removeDatabase(testbed);
     const spinner = createSpinner(`starting the database on port ${testbed.databasePort}`);
     if (!compose(testbed, ["up", "-d", "--wait", DATABASE_SERVICE])) {
       throw new Error("the testbed database did not start: is Docker running?");
     }
     const seeded = isSeeded(testbed);
-    spinner.text = seeded ? "migrating the database" : "migrating and seeding the database (first start only)";
-    const prepare = seeded ? ["--filter", "backend", "migrate"] : ["seed"];
+    spinner.text = seeded ? "migrating the database" : `migrating the database and seeding ${describeData(testbed.data)}`;
+    const seed = testbed.data === "showcase" ? ["seed", "showcase"] : ["seed"];
+    const prepare = seeded ? ["--filter", "backend", "migrate"] : seed;
     const prepared = spawnSync3("pnpm", prepare, {
       cwd: testbed.forkPath,
       env: testbed.env,
@@ -1540,7 +1575,11 @@ async function startTestbed(testbed, fresh, drop = false) {
     });
     if (prepared.status !== 0) throw new Error(`\`pnpm ${prepare.join(" ")}\` failed:
 ${logTail(testbed)}`);
-    printStep("database", `${seeded ? "migrated" : "seeded"}, port ${testbed.databasePort}`);
+    writeFileSync(dataPath(testbed), JSON.stringify({ data: testbed.data }));
+    printStep(
+      "database",
+      `${seeded ? "migrated" : `seeded with ${describeData(testbed.data)}`}, port ${testbed.databasePort}`
+    );
     const relay = testbed.yjs ? "pnpm --filter yjs-worker dev & " : "";
     stack = spawn("sh", ["-c", `${relay}pnpm offline`], {
       cwd: testbed.forkPath,
@@ -1608,14 +1647,19 @@ function ownLock(testbed) {
   }
   return lock;
 }
-async function withTestbed(forkPath, use, { fresh = false, destructive = false } = {}) {
-  const testbed = await resolveTestbed(forkPath);
+async function withTestbed(forkPath, use, { fresh = false, destructive = false, data = "seed" } = {}) {
+  const testbed = await resolveTestbed(forkPath, data);
   const lock = ownLock(testbed);
   if (lock && destructive) {
     throw new Error(
       `a testbed runs at ${lock.frontendUrl}: this command needs one of its own, so stop that one first (\`pnpm cella testbed stop\`)`
     );
   }
+  if (lock && (lock.data ?? "seed") !== data) {
+    throw new Error(
+      `a testbed with ${describeData(lock.data ?? "seed")} runs at ${lock.frontendUrl}: this command needs ${describeData(data)}, so stop that one first (\`pnpm cella testbed stop\`)`
+    );
+  }
   if (lock) {
     await untilAnswering(
       testbed,
@@ -1633,10 +1677,12 @@ async function withTestbed(forkPath, use, { fresh = false, destructive = false }
 }
 async function runTestbed(forkPath, options) {
   if (options.job === "stop") return stopTestbed(await resolveTestbed(forkPath));
+  if (options.showcase && !hasShowcase(forkPath)) throw new Error(`this app keeps no ${showcaseFile(forkPath)}`);
+  const data = options.showcase ? "showcase" : "seed";
   if (options.command.length > 0) {
-    return withTestbed(forkPath, (testbed2) => runCommand(forkPath, testbed2.env, options.command), options);
+    return withTestbed(forkPath, (testbed2) => runCommand(forkPath, testbed2.env, options.command), { ...options, data });
   }
-  const testbed = await resolveTestbed(forkPath);
+  const testbed = await resolveTestbed(forkPath, data);
   const lock = ownLock(testbed);
   if (lock) {
     throw new Error(
@@ -1664,7 +1710,10 @@ var testbedCommand = {
     ["start", "start it and hold it until ctrl-c"],
     ["stop", "stop the testbed that runs, or one left behind"]
   ],
-  options: [["--fresh", "start from an empty database: migrate and seed it again"]],
+  options: [
+    ["--fresh", "start from an empty database: migrate and seed it again"],
+    ["--showcase", "hold the showcase seed, which the screenshots shoot, for a review loop"]
+  ],
   passthrough: [
     "command",
     "after `--`: run it against the testbed (this checkout's running one, else one started for it and stopped after)"
@@ -1672,14 +1721,14 @@ var testbedCommand = {
   parse: ({ job = "start", opts, passthrough }) => {
     if (job !== "start" && job !== "stop") throw new Error(`unknown job '${job}'. expected one of: start, stop`);
     if (job === "stop" && passthrough.length > 0) throw new Error("stop takes no command");
-    return { job, fresh: opts.fresh === true, command: passthrough };
+    return { job, fresh: opts.fresh === true, showcase: opts.showcase === true, command: passthrough };
   },
   run: runTestbed
 };
 
 // src/tools/a11y/audit.ts
-import { mkdirSync as mkdirSync3, statSync, writeFileSync as writeFileSync4 } from "fs";
-import { join as join9 } from "path";
+import { mkdirSync as mkdirSync3, statSync, writeFileSync as writeFileSync5 } from "fs";
+import { join as join10 } from "path";
 
 // src/tools/a11y/axe-scan.ts
 import axe from "axe-core";
@@ -2349,8 +2398,97 @@ function recordDecisions(forkPath, decisions) {
 }
 
 // src/tools/a11y/probes/page-structure.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join8 } from "path";
+
+// src/tools/i18n/locales.ts
+import { existsSync as existsSync7, readdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { join as join7 } from "path";
+var localesDir = (forkPath) => movedPath(forkPath, "shared/locales", "locales");
+var MANIFEST = "namespaces.json";
+var SOURCE_LANGUAGE = "en";
+var entryPattern = /^(\s+)("(?:[^"\\]|\\.)*")\s*:\s*("(?:[^"\\]|\\.)*"),?\s*$/;
+function parseLocaleFile(path, text2) {
+  if (text2.trim() === "{}") return { path, indent: "  ", entries: [] };
+  const lines = text2.replace(/\n$/, "").split("\n");
+  if (lines[0] !== "{" || lines.at(-1) !== "}") return "not one JSON object with one entry per line";
+  const entries = [];
+  let indent = "  ";
+  for (const line of lines.slice(1, -1)) {
+    const match = entryPattern.exec(line);
+    if (!match) return `cannot read the line ${JSON.stringify(line.trim())}`;
+    indent = match[1];
+    entries.push({ key: JSON.parse(match[2]), value: JSON.parse(match[3]), raw: [match[2], match[3]] });
+  }
+  return { path, indent, entries };
+}
+function serializeLocaleFile(file) {
+  if (file.entries.length === 0) return "{}\n";
+  return `{
+${file.entries.map(({ raw }) => `${file.indent}${raw[0]}: ${raw[1]}`).join(",\n")}
+}
+`;
+}
+function writeLocaleFile(forkPath, file) {
+  writeFileSync3(join7(forkPath, file.path), serializeLocaleFile(file));
+}
+var textsOf = (file) => Object.fromEntries((file?.entries ?? []).map(({ key, value }) => [key, value]));
+var readJsonObject = (path) => {
+  const parsed2 = JSON.parse(readFileSync4(path, "utf8"));
+  if (!parsed2 || typeof parsed2 !== "object" || Array.isArray(parsed2)) throw new Error(`${path} is not a JSON object`);
+  return Object.fromEntries(Object.entries(parsed2));
+};
+function readLocales(forkPath) {
+  const localesPath = localesDir(forkPath);
+  const dir = join7(forkPath, localesPath);
+  if (!existsSync7(join7(dir, SOURCE_LANGUAGE))) throw new Error(`no ${localesPath}/${SOURCE_LANGUAGE}/ in ${forkPath}`);
+  const languages = readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name).sort((a, b) => a === SOURCE_LANGUAGE ? -1 : b === SOURCE_LANGUAGE ? 1 : a.localeCompare(b));
+  const files2 = /* @__PURE__ */ new Map();
+  for (const language2 of languages) {
+    for (const name of readdirSync(join7(dir, language2)).filter((name2) => name2.endsWith(".json"))) {
+      const path = `${localesPath}/${language2}/${name}`;
+      const parsed2 = parseLocaleFile(path, readFileSync4(join7(forkPath, path), "utf8"));
+      if (typeof parsed2 === "string") throw new Error(`${path}: ${parsed2}; pnpm lint:fix writes one entry per line`);
+      files2.set(`${language2}/${name.slice(0, -".json".length)}`, parsed2);
+    }
+  }
+  const manifestPath = join7(dir, MANIFEST);
+  if (!existsSync7(manifestPath)) throw new Error(`no ${localesPath}/${MANIFEST}: upgrade the app from cella first`);
+  const merged = readJsonObject(manifestPath);
+  const namespaces = /* @__PURE__ */ new Map();
+  for (const [namespace, sources] of Object.entries(merged)) {
+    if (!Array.isArray(sources) || !sources.every((source) => typeof source === "string")) {
+      throw new Error(`${localesPath}/${MANIFEST}: ${namespace} must list file names`);
+    }
+    namespaces.set(namespace, sources);
+  }
+  const mergedFiles = new Set([...namespaces.values()].flat());
+  const ownFiles = [...new Set([...files2.keys()].map((key) => key.split("/")[1]))].filter(
+    (file) => !mergedFiles.has(file)
+  );
+  for (const file of ownFiles.sort()) namespaces.set(file, [file]);
+  return { dir: localesPath, languages, namespaces, files: files2 };
+}
+function namespaceTexts(locales, language2, namespace) {
+  const sources = locales.namespaces.get(namespace) ?? [];
+  return Object.assign({}, ...sources.map((file) => textsOf(locales.files.get(`${language2}/${file}`))));
+}
+var lineOf = (file, key) => file.entries.findIndex((entry) => entry.key === key) + 2;
+var pluralSuffix = /_(ordinal_)?(zero|one|two|few|many|other)$/;
+function pluralForm(key) {
+  const match = pluralSuffix.exec(key);
+  if (!match) return void 0;
+  return { base: key.slice(0, match.index), category: match[2], ordinal: !!match[1] };
+}
+var withPluralForms = (key) => [
+  key,
+  ...["zero", "one", "two", "few", "many", "other"].flatMap((category) => [
+    `${key}_${category}`,
+    `${key}_ordinal_${category}`
+  ])
+];
+
+// src/tools/a11y/probes/page-structure.ts
 var titles = { criteria: ["2.4.2"], check: "probe:titles", what: "A distinct, descriptive page title" };
 var language = {
   criteria: ["3.1.1"],
@@ -2384,7 +2522,7 @@ var pageStructure = async (page, state, { app }) => {
 var languageSwitch = async (page, state, { app, forkPath }) => {
   if (state.open) return [];
   const names = JSON.parse(
-    readFileSync4(join7(forkPath, "locales", app.defaultLanguage, "common.json"), "utf8")
+    readFileSync5(join8(forkPath, localesDir(forkPath), app.defaultLanguage, "common.json"), "utf8")
   );
   const findings2 = [];
   for (const other of app.languages.filter((lng) => lng !== app.defaultLanguage)) {
@@ -2718,15 +2856,15 @@ var inputs = async (page, state) => {
 };
 
 // src/tools/a11y/review-packet.ts
-import { mkdirSync as mkdirSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
-import { join as join8 } from "path";
-var packetDir = (run, stateId) => join8(run.resultsDir, "review", stateId);
+import { mkdirSync as mkdirSync2, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { join as join9 } from "path";
+var packetDir = (run, stateId) => join9(run.resultsDir, "review", stateId);
 function writePacketFile(run, stateId, name, content) {
   mkdirSync2(packetDir(run, stateId), { recursive: true });
-  writeFileSync3(join8(packetDir(run, stateId), name), content);
+  writeFileSync4(join9(packetDir(run, stateId), name), content);
 }
 function removePacketFile(run, stateId, name) {
-  rmSync2(join8(packetDir(run, stateId), name), { force: true });
+  rmSync2(join9(packetDir(run, stateId), name), { force: true });
 }
 function pageFacts() {
   const text2 = (el) => (el?.textContent ?? "").trim().replace(/\s+/g, " ");
@@ -3187,7 +3325,7 @@ async function runAudit(run, scope, testbed, options) {
   const startedAt = Date.now();
   const email = options.email ?? testbed.env.ADMIN_EMAIL;
   if (!email) throw new Error("no audit user: pass --email, or set ADMIN_EMAIL in backend/.env");
-  const builtAt = statSync(join9(run.forkPath, "frontend/dist/index.html"), { throwIfNoEntry: false })?.mtime;
+  const builtAt = statSync(join10(run.forkPath, "frontend/dist/index.html"), { throwIfNoEntry: false })?.mtime;
   printStep("auditing", `${testbed.frontendUrl}, frontend build of ${builtAt?.toLocaleString() ?? "unknown date"}`);
   const states = options.states.length > 0 ? scope.states.filter((state) => options.states.includes(state.id)) : scope.states;
   const session = await startAudit(run.forkPath, scope, { email, env: testbed.env });
@@ -3227,12 +3365,12 @@ async function runAudit(run, scope, testbed, options) {
   mkdirSync3(run.resultsDir, { recursive: true });
   const axe2 = summarizeAxe(scans);
   for (const [id, items] of axe2.evidence) for (const item of items) evidence.add([id], item);
-  writeFileSync4(join9(run.resultsDir, "axe.json"), `${JSON.stringify({ ...axe2.report, errors }, null, 2)}
+  writeFileSync5(join10(run.resultsDir, "axe.json"), `${JSON.stringify({ ...axe2.report, errors }, null, 2)}
 `);
   evidence.addFindings(acrossStates(findings2));
   runCodeChecks(evidence, run, scope.sources);
   const skipped2 = Object.keys(errors).length;
-  const target = options.states.length > 0 || skipped2 ? join9(run.resultsDir, "ledger-partial.json") : join9(run.forkPath, ledgerFile);
+  const target = options.states.length > 0 || skipped2 ? join10(run.resultsDir, "ledger-partial.json") : join10(run.forkPath, ledgerFile);
   const ledger = writeLedger(
     run.forkPath,
     evidence.byCriterion,
@@ -3256,10 +3394,10 @@ async function runAudit(run, scope, testbed, options) {
 }
 
 // src/tools/a11y/decide.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { resolve as resolve4 } from "path";
 function runDecide(forkPath, { file, decision }) {
-  const input2 = file ? JSON.parse(readFileSync5(resolve4(file), "utf8")) : [decision];
+  const input2 = file ? JSON.parse(readFileSync6(resolve4(file), "utf8")) : [decision];
   if (!Array.isArray(input2)) throw new Error(`${file} holds no list of decisions`);
   const decisions = input2.map(parseDecision);
   const ledger = recordDecisions(forkPath, decisions);
@@ -3273,8 +3411,8 @@ function runDecide(forkPath, { file, decision }) {
 
 // src/tools/a11y/report.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { copyFileSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname4, join as join10 } from "path";
+import { copyFileSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
 var statusLabel = {
   supports: "Supports",
   "partially-supports": "Partially Supports",
@@ -3393,7 +3531,7 @@ Not evaluated.
 
 This report describes the product as tested on the report date. Accessibility can change as the product changes.
 `;
-  const tracked = spawnSync5("git", ["ls-files", "frontend/src", "backend/src", "locales"], {
+  const tracked = spawnSync5("git", ["ls-files", "frontend/src", "backend/src", "shared/locales", "locales"], {
     cwd: forkPath,
     encoding: "utf8"
   }).stdout.split("\n");
@@ -3420,7 +3558,7 @@ NVDA and Firefox on Windows, keyboard only, in light and dark mode.
 
 ## Confirm: decided by an agent (${byAgent.length})
 
-The agent judged these from the review packets in \`${join10(resultsDir, "review")}/\`. Check its evidence, then record your own
+The agent judged these from the review packets in \`${join11(resultsDir, "review")}/\`. Check its evidence, then record your own
 decision; a wrong Supports here ends up in the published report.
 
 ${byAgent.map((r) => {
@@ -3464,11 +3602,11 @@ ${failing.map((r) => {
   }).join("\n")}
 `;
   mkdirSync4(resultsDir, { recursive: true });
-  writeFileSync5(join10(resultsDir, "vpat-draft.md"), vpat);
-  writeFileSync5(join10(resultsDir, "manual-pass.md"), checklist);
+  writeFileSync6(join11(resultsDir, "vpat-draft.md"), vpat);
+  writeFileSync6(join11(resultsDir, "manual-pass.md"), checklist);
   const html = toHtml(vpat, `${app.name} Accessibility Conformance Report`);
-  const pdfPath = join10(resultsDir, "conformance-report.pdf");
-  writeFileSync5(join10(resultsDir, "conformance-report.html"), html);
+  const pdfPath = join11(resultsDir, "conformance-report.pdf");
+  writeFileSync6(join11(resultsDir, "conformance-report.html"), html);
   const { chromium } = await loadPlaywright(forkPath);
   const browser = await chromium.launch();
   try {
@@ -3488,12 +3626,12 @@ ${failing.map((r) => {
     if (unconfirmed && !draft) {
       const ids = [...open, ...byAgent].map((r) => r.id).join(", ");
       throw new Error(
-        `not published: ${open.length} criteria are open and ${byAgent.length} are decided by an agent only (${ids}). See ${join10(resultsDir, "manual-pass.md")}, or add --draft to publish it as a draft`
+        `not published: ${open.length} criteria are open and ${byAgent.length} are decided by an agent only (${ids}). See ${join11(resultsDir, "manual-pass.md")}, or add --draft to publish it as a draft`
       );
     }
     const publicPath = "frontend/public/static/common/accessibility-conformance-report.pdf";
-    mkdirSync4(dirname4(join10(forkPath, publicPath)), { recursive: true });
-    copyFileSync(pdfPath, join10(forkPath, publicPath));
+    mkdirSync4(dirname4(join11(forkPath, publicPath)), { recursive: true });
+    copyFileSync(pdfPath, join11(forkPath, publicPath));
     const count3 = (status) => ledger.criteria.filter((r) => r.status === status).length;
     const review = {
       standard: ledger.standard,
@@ -3600,8 +3738,8 @@ var a11yCommand = {
 };
 
 // src/tools/bench/command.ts
-import { existsSync as existsSync7, readdirSync } from "fs";
-import { basename, join as join11 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync2 } from "fs";
+import { basename, join as join12 } from "path";
 
 // src/tools/bench/request.ts
 var BENCH_REQUEST_ENV = "CELLA_BENCH";
@@ -3610,11 +3748,11 @@ var BENCH_REQUEST_ENV = "CELLA_BENCH";
 var BENCH_DIR = "backend/bench";
 var ENTRY_COMMAND = ["pnpm", "exec", "tsx", "--no-experimental-webstorage", "bench/run.ts"];
 async function runBench(forkPath, options) {
-  if (!existsSync7(join11(forkPath, BENCH_DIR, "run.ts"))) {
+  if (!existsSync8(join12(forkPath, BENCH_DIR, "run.ts"))) {
     throw new Error(`${BENCH_DIR}/run.ts is missing: upgrade the app from cella first`);
   }
-  const scenariosDir = join11(forkPath, BENCH_DIR, "scenarios");
-  const names = readdirSync(scenariosDir).filter((file) => file.endsWith(".ts")).map((file) => basename(file, ".ts")).sort();
+  const scenariosDir = join12(forkPath, BENCH_DIR, "scenarios");
+  const names = readdirSync2(scenariosDir).filter((file) => file.endsWith(".ts")).map((file) => basename(file, ".ts")).sort();
   if (options.scenario && !names.includes(options.scenario)) {
     throw new Error(`unknown scenario '${options.scenario}'. expected one of: ${names.join(", ")}`);
   }
@@ -3626,7 +3764,7 @@ async function runBench(forkPath, options) {
     scenariosDir,
     dataDir: toolDir(forkPath, "bench", "repository")
   };
-  const run = (env) => runCommand(join11(forkPath, "backend"), { ...env, [BENCH_REQUEST_ENV]: JSON.stringify(request) }, ENTRY_COMMAND);
+  const run = (env) => runCommand(join12(forkPath, "backend"), { ...env, [BENCH_REQUEST_ENV]: JSON.stringify(request) }, ENTRY_COMMAND);
   return options.isolated ? withTestbed(forkPath, (testbed) => run(testbed.env)) : run(getEnvSnapshot());
 }
 var benchCommand = {
@@ -3665,98 +3803,12 @@ import { spawnSync as spawnSync6 } from "child_process";
 import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
 import { join as join14 } from "path";
 
-// src/tools/i18n/locales.ts
-import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join12 } from "path";
-var LOCALES_DIR = "locales";
-var MANIFEST = "namespaces.json";
-var SOURCE_LANGUAGE = "en";
-var entryPattern = /^(\s+)("(?:[^"\\]|\\.)*")\s*:\s*("(?:[^"\\]|\\.)*"),?\s*$/;
-function parseLocaleFile(path, text2) {
-  if (text2.trim() === "{}") return { path, indent: "  ", entries: [] };
-  const lines = text2.replace(/\n$/, "").split("\n");
-  if (lines[0] !== "{" || lines.at(-1) !== "}") return "not one JSON object with one entry per line";
-  const entries = [];
-  let indent = "  ";
-  for (const line of lines.slice(1, -1)) {
-    const match = entryPattern.exec(line);
-    if (!match) return `cannot read the line ${JSON.stringify(line.trim())}`;
-    indent = match[1];
-    entries.push({ key: JSON.parse(match[2]), value: JSON.parse(match[3]), raw: [match[2], match[3]] });
-  }
-  return { path, indent, entries };
-}
-function serializeLocaleFile(file) {
-  if (file.entries.length === 0) return "{}\n";
-  return `{
-${file.entries.map(({ raw }) => `${file.indent}${raw[0]}: ${raw[1]}`).join(",\n")}
-}
-`;
-}
-function writeLocaleFile(forkPath, file) {
-  writeFileSync6(join12(forkPath, file.path), serializeLocaleFile(file));
-}
-var textsOf = (file) => Object.fromEntries((file?.entries ?? []).map(({ key, value }) => [key, value]));
-var readJsonObject = (path) => {
-  const parsed2 = JSON.parse(readFileSync6(path, "utf8"));
-  if (!parsed2 || typeof parsed2 !== "object" || Array.isArray(parsed2)) throw new Error(`${path} is not a JSON object`);
-  return Object.fromEntries(Object.entries(parsed2));
-};
-function readLocales(forkPath) {
-  const dir = join12(forkPath, LOCALES_DIR);
-  if (!existsSync8(join12(dir, SOURCE_LANGUAGE))) throw new Error(`no ${LOCALES_DIR}/${SOURCE_LANGUAGE}/ in ${forkPath}`);
-  const languages = readdirSync2(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name).sort((a, b) => a === SOURCE_LANGUAGE ? -1 : b === SOURCE_LANGUAGE ? 1 : a.localeCompare(b));
-  const files2 = /* @__PURE__ */ new Map();
-  for (const language2 of languages) {
-    for (const name of readdirSync2(join12(dir, language2)).filter((name2) => name2.endsWith(".json"))) {
-      const path = `${LOCALES_DIR}/${language2}/${name}`;
-      const parsed2 = parseLocaleFile(path, readFileSync6(join12(forkPath, path), "utf8"));
-      if (typeof parsed2 === "string") throw new Error(`${path}: ${parsed2}; pnpm lint:fix writes one entry per line`);
-      files2.set(`${language2}/${name.slice(0, -".json".length)}`, parsed2);
-    }
-  }
-  const manifestPath = join12(dir, MANIFEST);
-  if (!existsSync8(manifestPath)) throw new Error(`no ${LOCALES_DIR}/${MANIFEST}: upgrade the app from cella first`);
-  const merged = readJsonObject(manifestPath);
-  const namespaces = /* @__PURE__ */ new Map();
-  for (const [namespace, sources] of Object.entries(merged)) {
-    if (!Array.isArray(sources) || !sources.every((source) => typeof source === "string")) {
-      throw new Error(`${LOCALES_DIR}/${MANIFEST}: ${namespace} must list file names`);
-    }
-    namespaces.set(namespace, sources);
-  }
-  const mergedFiles = new Set([...namespaces.values()].flat());
-  const ownFiles = [...new Set([...files2.keys()].map((key) => key.split("/")[1]))].filter(
-    (file) => !mergedFiles.has(file)
-  );
-  for (const file of ownFiles.sort()) namespaces.set(file, [file]);
-  return { languages, namespaces, files: files2 };
-}
-function namespaceTexts(locales, language2, namespace) {
-  const sources = locales.namespaces.get(namespace) ?? [];
-  return Object.assign({}, ...sources.map((file) => textsOf(locales.files.get(`${language2}/${file}`))));
-}
-var lineOf = (file, key) => file.entries.findIndex((entry) => entry.key === key) + 2;
-var pluralSuffix = /_(ordinal_)?(zero|one|two|few|many|other)$/;
-function pluralForm(key) {
-  const match = pluralSuffix.exec(key);
-  if (!match) return void 0;
-  return { base: key.slice(0, match.index), category: match[2], ordinal: !!match[1] };
-}
-var withPluralForms = (key) => [
-  key,
-  ...["zero", "one", "two", "few", "many", "other"].flatMap((category) => [
-    `${key}_${category}`,
-    `${key}_ordinal_${category}`
-  ])
-];
-
 // src/tools/i18n/scan.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { readFileSync as readFileSync7, statSync as statSync2 } from "fs";
 import { dirname as dirname5, join as join13 } from "path";
 var codeFile = /\.(?:[cm]?[jt]sx?)$/;
-var skipped = (path) => path.endsWith(".d.ts") || path.startsWith("locales/") || path.startsWith("cella/alignments/") || path.split("/").some((segment) => segment === "node_modules" || segment === "gen" || segment.includes(".gen."));
+var skipped = (path) => path.endsWith(".d.ts") || path.startsWith("locales/") || path.startsWith("shared/locales/") || path.startsWith("cella/alignments/") || path.split("/").some((segment) => segment === "node_modules" || segment === "gen" || segment.includes(".gen."));
 var MAX_FILE_BYTES = 1e6;
 var MAX_COMBINATIONS = 500;
 var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -4173,10 +4225,10 @@ function printList(title, items) {
   console.info(`    ${colors_default.dim(`${items.slice(0, LIST_MAX).join(", ")}${more}`)}`);
 }
 var describe = ({ key, missing, extra }) => [key, ...missing.map((name) => `-${name}`), ...extra.map((name) => `+${name}`)].join(" ");
-function printStatus(report) {
+function printStatus(report, dir) {
   const label = ({ name, files: files2 }) => files2.length > 1 || files2[0] !== name ? `${name} (${files2.join(" + ")})` : name;
   console.info(
-    `${colors_default.bold(`${LOCALES_DIR}/`)} ${colors_default.dim(`${report.languages.join(", ")} \xB7 namespaces ${report.namespaces.map(label).join(", ")}`)}`
+    `${colors_default.bold(`${dir}/`)} ${colors_default.dim(`${report.languages.join(", ")} \xB7 namespaces ${report.namespaces.map(label).join(", ")}`)}`
   );
   console.info();
   console.info(colors_default.dim(row2(columns.map(([title]) => title))));
@@ -4248,9 +4300,10 @@ function printStatus(report) {
   console.info(`  ${colors_default.dim("missing and same-as-English keys: --json lists them \xB7 cella i18n unused")}`);
 }
 function runStatus(forkPath, json) {
-  const report = buildStatus(readLocales(forkPath));
+  const locales = readLocales(forkPath);
+  const report = buildStatus(locales);
   if (json) writeStdout(JSON.stringify(report, null, 2));
-  else printStatus(report);
+  else printStatus(report, locales.dir);
   return defectCount(report) === 0 ? 0 : 1;
 }
 
@@ -5270,7 +5323,7 @@ var pentestCommand = {
 
 // src/tools/screenshots/shoot.ts
 import { spawnSync as spawnSync9 } from "child_process";
-import { mkdirSync as mkdirSync7, mkdtempSync, rmSync as rmSync5, statSync as statSync3, writeFileSync as writeFileSync10 } from "fs";
+import { mkdirSync as mkdirSync7, mkdtempSync, readFileSync as readFileSync13, rmSync as rmSync5, statSync as statSync3, writeFileSync as writeFileSync10 } from "fs";
 import { tmpdir } from "os";
 import { basename as basename4, dirname as dirname7, join as join21, resolve as resolve7 } from "path";
 
@@ -5350,6 +5403,7 @@ async function spinnersGone(page, quiet = 1e3, cap = 45e3) {
     await page.waitForTimeout(100);
   }
 }
+var hasMfaScript = (forkPath) => Boolean(JSON.parse(readFileSync13(join21(forkPath, "backend/package.json"), "utf8")).scripts?.["showcase:mfa"]);
 async function shoot(forkPath, list2, testbed, options) {
   const email = options.email ?? testbed.env.ADMIN_EMAIL;
   if (!email) throw new Error("no shot user: pass --email, or set ADMIN_EMAIL in backend/.env");
@@ -5376,15 +5430,17 @@ async function shoot(forkPath, list2, testbed, options) {
     if (encoded.status !== 0) throw new Error(`cwebp could not write ${path}: ${encoded.stderr.trim()}`);
   };
   try {
-    const showcase = spawnSync9("pnpm", ["--silent", "--filter", "backend", "showcase:mfa", email], {
-      cwd: forkPath,
-      env: testbed.env,
-      encoding: "utf8"
-    });
-    if (showcase.status !== 0) throw new Error(`showcase:mfa failed:
+    if (testbed.data === "seed" && hasMfaScript(forkPath)) {
+      const showcase = spawnSync9("pnpm", ["--silent", "--filter", "backend", "showcase:mfa", email], {
+        cwd: forkPath,
+        env: testbed.env,
+        encoding: "utf8"
+      });
+      if (showcase.status !== 0) throw new Error(`showcase:mfa failed:
 ${showcase.stdout}
 ${showcase.stderr}`);
-    printStep("mfa", showcase.stdout.trim().split("\n").at(-1));
+      printStep("mfa", showcase.stdout.trim().split("\n").at(-1));
+    }
     for (const prepare of list2.prepare) await prepare(signedIn(user));
     const values = {};
     for (const [name, resolve12] of Object.entries(list2.placeholders)) values[name] = await resolve12(signedIn(user));
@@ -5468,7 +5524,8 @@ async function runScreenshots(forkPath, options) {
   }
   requireEncoder(list2.format);
   await requireChromium(forkPath);
-  return withTestbed(forkPath, (testbed) => shoot(forkPath, list2, testbed, options));
+  const data = hasShowcase(forkPath) ? "showcase" : "seed";
+  return withTestbed(forkPath, (testbed) => shoot(forkPath, list2, testbed, options), { data });
 }
 var screenshotsCommand = {
   name: "screenshots",
@@ -5478,7 +5535,7 @@ var screenshotsCommand = {
   operands: ["[ids...]", "the shots to take (default: all)"],
   options: [
     ["--out <dir>", "write into this folder, a trial run that leaves the working tree alone"],
-    ["--email <address>", "the shot user (default ADMIN_EMAIL in backend/.env)"]
+    ["--email <address>", "the shot user (default the showcase admin, else ADMIN_EMAIL in backend/.env)"]
   ],
   parse: ({ operands, opts }) => ({
     ids: operands,
@@ -5489,7 +5546,7 @@ var screenshotsCommand = {
 };
 
 // src/tools/style/index.ts
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 import { join as join27 } from "path";
 
 // src/utils/alignments.ts
@@ -5737,7 +5794,9 @@ var alignmentExempt = [
   "json/",
   "locales/",
   "sdk/gen",
-  "shared/config"
+  "shared/config",
+  "shared/json/",
+  "shared/locales/"
 ];
 function ownedPaths(configSource) {
   const lists = [...configSource.matchAll(/\b(?:ignored|pinned): \[([\s\S]*?)\n {4}\]/g)].map((match) => match[1]);
@@ -6042,7 +6101,7 @@ function docFindings(file, source) {
 }
 
 // src/tools/style/frontend-rules.ts
-import { existsSync as existsSync19, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync14 } from "fs";
 import { extname as extname4, join as join24 } from "path";
 function containsJsx(node) {
   return ts.isJsxElement(node) || ts.isJsxFragment(node) || ts.isJsxSelfClosingElement(node) || !!ts.forEachChild(node, containsJsx);
@@ -6214,7 +6273,7 @@ function inProductModule(file) {
   if (!folder) return false;
   const queryFile = join24(repoRoot, `${folder}query.ts`);
   if (!productModuleFolders.has(queryFile)) {
-    const source = existsSync19(queryFile) ? readFileSync13(queryFile, "utf8") : "";
+    const source = existsSync19(queryFile) ? readFileSync14(queryFile, "utf8") : "";
     productModuleFolders.set(
       queryFile,
       markCalls(ts.createSourceFile(queryFile, source, ts.ScriptTarget.Latest)).registersRangeFetch
@@ -6238,7 +6297,7 @@ function checkProductCacheWrite(file, sourceFile, report) {
 function frontendStores(files2) {
   const stores = /* @__PURE__ */ new Set();
   for (const file of files2.filter(isFrontendSource)) {
-    const source = readFileSync13(join24(repoRoot, file), "utf8");
+    const source = readFileSync14(join24(repoRoot, file), "utf8");
     if (source.includes("zustand")) collectStores(parseSource(file, source), stores);
   }
   return stores;
@@ -6324,7 +6383,7 @@ function stampFindings(file, source) {
 }
 
 // src/tools/style/tailwind-class-rules.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { dirname as dirname9, join as join25, relative as relative2 } from "path";
 
@@ -6392,11 +6451,11 @@ function addMatches(target, text2, pattern) {
 function usedClassNames(files2) {
   const names = /* @__PURE__ */ new Set();
   for (const file of files2.filter(isFrontendStylesheet)) {
-    const css = readFileSync14(join25(repoRoot, file), "utf8").replace(/\/\*[\s\S]*?\*\//g, "");
+    const css = readFileSync15(join25(repoRoot, file), "utf8").replace(/\/\*[\s\S]*?\*\//g, "");
     addMatches(names, css, /(?<!\\)\.(-?[_a-zA-Z][\w-]*)/g);
   }
   for (const file of files2.filter(isFrontendScript)) {
-    const source = readFileSync14(join25(repoRoot, file), "utf8");
+    const source = readFileSync15(join25(repoRoot, file), "utf8");
     for (const [chunk] of source.matchAll(/(?<![\w$)\]?.])\[[^\s'"`]*/g))
       addMatches(names, chunk, /(?<![a-zA-Z0-9$.)\]?!])\.(-?[_a-zA-Z][\w-]*)/g);
     for (const [, , text2] of source.matchAll(/(['"`])((?:\\.|(?!\1)[^\\\n])*)\1/g)) {
@@ -6412,14 +6471,14 @@ function usedClassNames(files2) {
   return names;
 }
 async function tailwindContext(files2, appMarkerClasses = {}) {
-  const entry = files2.filter(isFrontendStylesheet).find((file) => tailwindImport.test(readFileSync14(join25(repoRoot, file), "utf8")));
+  const entry = files2.filter(isFrontendStylesheet).find((file) => tailwindImport.test(readFileSync15(join25(repoRoot, file), "utf8")));
   if (!entry) return void 0;
   const path = join25(repoRoot, entry);
   const knownClasses = usedClassNames(files2);
   for (const name of Object.keys({ ...markerClasses, ...appMarkerClasses })) knownClasses.add(name);
   const context = { entry, knownClasses, compiles: /* @__PURE__ */ new Map() };
   try {
-    context.designSystem = await (await loadTailwindNode()).__unstable__loadDesignSystem(readFileSync14(path, "utf8"), {
+    context.designSystem = await (await loadTailwindNode()).__unstable__loadDesignSystem(readFileSync15(path, "utf8"), {
       base: dirname9(path)
     });
   } catch (error) {
@@ -6848,7 +6907,7 @@ async function runStyle(root, { paths }) {
   const files2 = repoFiles();
   const stores = frontendStores(files2);
   const tailwind = await tailwindContext(files2, allowlist.markerClasses);
-  const read = (file) => readFileSync15(join27(repoRoot, file), "utf8");
+  const read = (file) => readFileSync16(join27(repoRoot, file), "utf8");
   const requested = files2.filter((file) => isRequested(file, paths));
   const findings2 = paths.filter((path) => !files2.some((file) => isRequested(file, [path]))).map((path) => ({ file: path, rule: "path-argument", message: "no file matches this path" }));
   findings2.push(...alignmentFindings(requested, read));
@@ -6856,7 +6915,7 @@ async function runStyle(root, { paths }) {
     findings2.push(...owedAlignmentFindings(await branchChanges(), read("cella/cella.config.ts")));
   }
   for (const file of requested) {
-    const content = readFileSync15(join27(repoRoot, file));
+    const content = readFileSync16(join27(repoRoot, file));
     if (content.includes(0)) continue;
     const source = content.toString("utf8");
     const prose = allowlist.proseExclude?.some((prefix) => file.startsWith(prefix)) ? [] : [...docFindings(file, source), ...commentFindings(file, source)];
@@ -7573,8 +7632,9 @@ async function analyzeRefs(repoPath, localRef, incomingRef, mergeBaseRef, predic
       const forkModifiedOld = forkOldHash !== baseOldHash;
       const oldPathPinned = predicates.isPinned(oldPath);
       let upstreamChanged2;
-      if (fileIsPinned || oldPathPinned || predicates.isIgnored(oldPath)) {
+      if (fileIsPinned || fileIsIgnored || oldPathPinned || predicates.isIgnored(oldPath)) {
         status = "pinned";
+        if (oldPathInFork) renamedFrom = oldPath;
         if (forkModifiedOld && upstreamHash !== baseOldHash) {
           upstreamChanged2 = true;
           renamedProtected.add(filePath);
@@ -7730,9 +7790,11 @@ async function applyDirectMerge(forkPath, upstreamRef, mergeBaseRef, config, onP
   );
   const batchRestorePaths = [];
   const batchRemovePaths = [];
+  const movedProtected = [];
   for (const file of analyzedFiles) {
     if (file.status === "identical" || file.status === "ahead") continue;
-    if (file.isIgnored || file.isPinned && !file.renamedFrom) {
+    if (file.status === "pinned" && file.renamedFrom) movedProtected.push({ from: file.renamedFrom, to: file.path });
+    else if (file.isIgnored || file.isPinned) {
       (file.existsInFork ? batchRestorePaths : batchRemovePaths).push(file.path);
     }
   }
@@ -7749,6 +7811,10 @@ async function applyDirectMerge(forkPath, upstreamRef, mergeBaseRef, config, onP
       await removeFileFromWorktree(forkPath, filePath);
     }
   }
+  for (const { from, to } of movedProtected) {
+    onProgress?.(`\u2192 ${from} \u2192 ${to}: keeping your copy (moved in upstream)`);
+    await moveFromRef(forkPath, "HEAD", from, to);
+  }
   for (const file of analyzedFiles) {
     const { path: filePath, status, existsInFork } = file;
     if (status === "identical" || status === "ahead" || isProtectedFile(file)) continue;
@@ -8999,7 +9065,7 @@ function syncStep(result) {
 }
 
 // src/services/audit.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 import { basename as basename9, join as join35, relative as relative4 } from "path";
 import { checkbox, Separator } from "@inquirer/prompts";
 
@@ -9114,7 +9180,7 @@ import { delimiter, dirname as dirname13, join as join33, sep as sep2 } from "pa
 import { promisify as promisify3 } from "util";
 
 // src/utils/runtimes.ts
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 import { basename as basename8, dirname as dirname12, join as join32 } from "path";
 var DAY = 24 * 60 * 60 * 1e3;
 var FROZEN_AFTER = 180 * DAY;
@@ -9157,7 +9223,7 @@ function parseDockerfile(file, content) {
 async function readRuntimePins(forkPath) {
   let manifest = {};
   try {
-    manifest = JSON.parse(readFileSync16(join32(forkPath, "package.json"), "utf8"));
+    manifest = JSON.parse(readFileSync17(join32(forkPath, "package.json"), "utf8"));
   } catch {
   }
   const node = manifest.engines?.node?.trim() ?? "";
@@ -9168,7 +9234,7 @@ async function readRuntimePins(forkPath) {
   for (const file of tracked) {
     let content;
     try {
-      content = readFileSync16(join32(forkPath, file), "utf8");
+      content = readFileSync17(join32(forkPath, file), "utf8");
     } catch {
       continue;
     }
@@ -9684,14 +9750,14 @@ function writeAuditSettings(content, next) {
 
 // src/services/audit-security.ts
 import { spawnSync as spawnSync11 } from "child_process";
-import { cpSync, existsSync as existsSync25, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync2, readFileSync as readFileSync17, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "fs";
+import { cpSync, existsSync as existsSync25, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync2, readFileSync as readFileSync18, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import { dirname as dirname14, join as join34, relative as relative3 } from "path";
 import { confirm, select as select2 } from "@inquirer/prompts";
 var WORKSPACE_FILE = "pnpm-workspace.yaml";
 var LOCK_FILE = "pnpm-lock.yaml";
 var RESOLUTION_FILES = ["package.json", LOCK_FILE, ".npmrc", ".pnpmfile.cjs"];
-var readOr = (path, fallback = "") => existsSync25(path) ? readFileSync17(path, "utf8") : fallback;
+var readOr = (path, fallback = "") => existsSync25(path) ? readFileSync18(path, "utf8") : fallback;
 var count2 = (n, noun, plural2 = `${noun}s`) => `${n} ${n === 1 ? noun : plural2}`;
 var isBreaking = (item) => item.remedy.kind !== "none" && item.remedy.breaking;
 var needsDecision = (item) => item.standing === "new" && (item.remedy.kind !== "override" || item.remedy.breaking || item.direct);
@@ -10004,7 +10070,7 @@ function createDependentPkgReader() {
     let cached = cache.get(location);
     if (cached === void 0) {
       try {
-        cached = JSON.parse(readFileSync18(join35(location, "package.json"), "utf8"));
+        cached = JSON.parse(readFileSync19(join35(location, "package.json"), "utf8"));
       } catch {
         cached = null;
       }
@@ -10176,7 +10242,7 @@ function printOutdatedResults(rows, forkPath) {
 function printNotes(forkPath, unchecked) {
   let held = [];
   try {
-    const updateConfig = readTopLevel(readFileSync18(join35(forkPath, "pnpm-workspace.yaml"), "utf8"), "updateConfig");
+    const updateConfig = readTopLevel(readFileSync19(join35(forkPath, "pnpm-workspace.yaml"), "utf8"), "updateConfig");
     const ignored = updateConfig?.ignoreDependencies;
     held = Array.isArray(ignored) ? ignored.map(String) : [];
   } catch {
@@ -10300,7 +10366,7 @@ async function planEdits(forkPath, rows, selected, nodeImageSuffixes) {
   const summary = /* @__PURE__ */ new Map();
   const bumped = [];
   const edit = (file, label, item, resolves, change) => {
-    const entry = contents.get(file) ?? { content: readFileSync18(join35(forkPath, file), "utf8"), resolves: false };
+    const entry = contents.get(file) ?? { content: readFileSync19(join35(forkPath, file), "utf8"), resolves: false };
     const next = change(entry.content);
     if (next === entry.content) return;
     contents.set(file, { content: next, resolves: entry.resolves || resolves });
@@ -10836,11 +10902,11 @@ function closePr(cwd, ref) {
 }
 
 // src/services/packages.ts
-import { existsSync as existsSync27, readFileSync as readFileSync20, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync21, writeFileSync as writeFileSync13 } from "fs";
 import { join as join38 } from "path";
 
 // src/services/package-usage.ts
-import { existsSync as existsSync26, readFileSync as readFileSync19, statSync as statSync4 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync20, statSync as statSync4 } from "fs";
 import { join as join37 } from "path";
 var MAX_FILE_BYTES2 = 1024 * 1024;
 function escapeRegExp2(value) {
@@ -10849,7 +10915,7 @@ function escapeRegExp2(value) {
 function readSearchable(filePath) {
   try {
     if (statSync4(filePath).size > MAX_FILE_BYTES2) return "";
-    const text2 = readFileSync19(filePath, "utf8");
+    const text2 = readFileSync20(filePath, "utf8");
     return text2.includes("\0") ? "" : text2;
   } catch {
     return "";
@@ -10869,7 +10935,7 @@ async function readScriptsAtRef(forkPath, ref, path) {
 async function scriptSources(forkPath, upstreamRef, baseRef, path) {
   let forkScripts;
   try {
-    forkScripts = JSON.parse(readFileSync19(join37(forkPath, path), "utf8")).scripts ?? {};
+    forkScripts = JSON.parse(readFileSync20(join37(forkPath, path), "utf8")).scripts ?? {};
   } catch {
     return [];
   }
@@ -10883,7 +10949,7 @@ function binNames(forkPath, location, name) {
     const manifest = join37(dir, "node_modules", name, "package.json");
     if (!existsSync26(manifest)) continue;
     try {
-      const { bin } = JSON.parse(readFileSync19(manifest, "utf8"));
+      const { bin } = JSON.parse(readFileSync20(manifest, "utf8"));
       if (typeof bin === "string") return [bareName];
       return bin && typeof bin === "object" ? Object.keys(bin) : [];
     } catch {
@@ -11064,7 +11130,7 @@ function setTopLevelKey(pkg, key, value) {
 function readPackageJson(filePath) {
   if (!existsSync27(filePath)) return null;
   try {
-    return JSON.parse(readFileSync20(filePath, "utf8"));
+    return JSON.parse(readFileSync21(filePath, "utf8"));
   } catch (error) {
     throw new Error(`cannot parse ${filePath}: ${errorMessage(error)}`);
   }
@@ -11802,7 +11868,7 @@ import { readFile as readFile3 } from "fs/promises";
 import { join as join40 } from "path";
 
 // src/utils/coverage-utils.ts
-import { existsSync as existsSync28, readFileSync as readFileSync21, statSync as statSync5 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync22, statSync as statSync5 } from "fs";
 import { join as join39, relative as relative5, sep as sep3 } from "path";
 var STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
 function colorPct(pct) {
@@ -11828,7 +11894,7 @@ function printCoverageSummary(forkPath) {
   if (existsSync28(file)) {
     try {
       mtimeMs = statSync5(file).mtimeMs;
-      summary = JSON.parse(readFileSync21(file, "utf8"));
+      summary = JSON.parse(readFileSync22(file, "utf8"));
     } catch {
       problem2 = "could not read coverage-summary.json";
     }