@askrjs/cli 0.0.2 → 0.0.4

package/dist/templates/startkit/package.json

@@ -6,7 +6,7 @@
     "dev": "vp dev",
     "build": "vp build",
     "preview": "vp preview",
-    "test": "vp test run",
+    "test": "vp test run -c ./vitest.config.ts",
     "test:watch": "vp test --watch",
     "typecheck": "tsc --noEmit",
     "lint": "vp lint .",
@@ -24,7 +24,7 @@
   },
   "devDependencies": {
     "@askrjs/vite": ">=0.0.6 <0.1.0",
-    "@types/node": "^26.0.0",
+    "@types/node": "^20.19.0",
     "jsdom": "^29.1.1",
     "typescript": "^6.0.3",
     "vite-plus": "^0.2.4"

package/dist/templates/startkit/src/lib/mock-data.ts

@@ -173,43 +173,32 @@ function wait(signal?: AbortSignal, delay = 220): Promise<void> {
   });
 }
 
-function readStorage(key: string): string | null {
-  const fallback = storageFallback.get(key) ?? null;
-
-  if (typeof window === 'undefined') {
-    return fallback;
+function browserStorage(): Storage | undefined {
+  const globalDescriptor = Object.getOwnPropertyDescriptor(
+    globalThis,
+    'localStorage'
+  );
+  if (globalDescriptor?.get && globalDescriptor.enumerable === false) {
+    return undefined;
   }
-
+  if (typeof document === 'undefined') return undefined;
   try {
-    const storage = window.localStorage as {
-      getItem?: (storageKey: string) => string | null;
-    };
-    if (typeof storage.getItem !== 'function') {
-      return fallback;
-    }
-
-    return storage.getItem(key) ?? fallback;
+    return document.defaultView?.localStorage;
   } catch {
-    return fallback;
+    return undefined;
   }
 }
 
+function readStorage(key: string): string | null {
+  const fallback = storageFallback.get(key) ?? null;
+  return browserStorage()?.getItem(key) ?? fallback;
+}
+
 function writeStorage(key: string, value: string) {
   storageFallback.set(key, value);
 
-  if (typeof window === 'undefined') {
-    return;
-  }
-
   try {
-    const storage = window.localStorage as {
-      setItem?: (storageKey: string, storageValue: string) => void;
-    };
-    if (typeof storage.setItem !== 'function') {
-      return;
-    }
-
-    storage.setItem(key, value);
+    browserStorage()?.setItem(key, value);
   } catch {
     // Ignore storage write failures in non-browser or restricted test envs.
   }
@@ -218,19 +207,8 @@ function writeStorage(key: string, value: string) {
 function removeStorage(key: string) {
   storageFallback.delete(key);
 
-  if (typeof window === 'undefined') {
-    return;
-  }
-
   try {
-    const storage = window.localStorage as {
-      removeItem?: (storageKey: string) => void;
-    };
-    if (typeof storage.removeItem !== 'function') {
-      return;
-    }
-
-    storage.removeItem(key);
+    browserStorage()?.removeItem(key);
   } catch {
     // Ignore storage delete failures in non-browser or restricted test envs.
   }

package/dist/templates/startkit/tsconfig.json

@@ -13,7 +13,8 @@
     "isolatedModules": true,
     "noEmit": true,
     "jsx": "preserve",
-    "jsxImportSource": "@askrjs/askr"
+    "jsxImportSource": "@askrjs/askr",
+    "types": ["@askrjs/themes"]
   },
   "include": ["src"],
   "references": [{ "path": "./tsconfig.node.json" }]

package/dist/update.d.ts

@@ -0,0 +1,41 @@
+//#region src/update/types.d.ts
+declare const DEPENDENCY_SECTIONS: readonly ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
+type DependencySection = (typeof DEPENDENCY_SECTIONS)[number];
+interface Packument {
+  "dist-tags"?: Record<string, unknown>;
+  versions?: Record<string, unknown>;
+}
+interface ManifestValueEdit {
+  manifestPath: string;
+  section: DependencySection;
+  package: string;
+  currentSpecification: string;
+  proposedSpecification: string;
+}
+//#endregion
+//#region src/update/writer.d.ts
+interface WriterOptions {
+  replace?: (temporaryPath: string, manifestPath: string) => Promise<void>;
+}
+declare function writeManifestEdits(edits: ManifestValueEdit[], options?: WriterOptions): Promise<number>;
+//#endregion
+//#region src/update/registry.d.ts
+interface RegistryRequirements {
+  specifications?: ReadonlyMap<string, readonly string[]>;
+}
+interface PackumentResults {
+  packuments: Map<string, Packument>;
+  failures: Map<string, string>;
+}
+//#endregion
+//#region src/bin/update.d.ts
+type CliIo = Pick<Console, "error" | "log">;
+interface UpdateRuntime {
+  registry?: (root: string, packageNames: string[], requirements?: RegistryRequirements) => Promise<PackumentResults>;
+  writer?: typeof writeManifestEdits;
+}
+declare const runUpdateCli: (args: string[], io?: CliIo, runtime?: UpdateRuntime) => Promise<number>;
+declare const runUpgradeCli: (args: string[], io?: CliIo, runtime?: UpdateRuntime) => Promise<number>;
+declare const runOutdatedCli: (args: string[], io?: CliIo, runtime?: UpdateRuntime) => Promise<number>;
+//#endregion
+export { runOutdatedCli, runUpdateCli, runUpgradeCli };

package/dist/update.js

@@ -1,3 +1,283 @@
 #!/usr/bin/env node
-import { t as runUpdateCli } from "./update-DyW1na5V.js";
-export { runUpdateCli };
+import { t as isDirectExecution } from "./is-direct-execution-Cdlr-ZUl.js";
+import path from "node:path";
+//#region src/bin/update.ts
+function helpText(command) {
+	return [
+		`askr ${command} - ${command === "outdated" ? "List available dependency updates" : command === "update" ? "Apply safe dependency updates" : "Apply latest peer-compatible dependency upgrades"}`,
+		"",
+		"Usage:",
+		`  askr ${command} [packages...] [options]`,
+		"",
+		"Options:",
+		"  --cwd <dir>             Resolve a project from another directory",
+		"  --workspace <glob>      Select workspace names (repeatable)",
+		"  --tag <tag>             Use one registry dist-tag for selected packages",
+		"  --json                  Emit one deterministic JSON object on stdout",
+		"  --help, -h              Show this help message",
+		"",
+		"Notes:",
+		"  Package arguments are minimatch patterns and override persistent ignores.",
+		command === "outdated" ? "  This command reports only and never writes files." : "  The command changes package.json files only.",
+		"  Lockfiles, installs, and lifecycle scripts are never touched."
+	].join("\n");
+}
+function optionValue(args, index, option, errors) {
+	if (index + 1 >= args.length || args[index + 1].startsWith("-")) {
+		errors.push(`Missing value for ${option}`);
+		return null;
+	}
+	return args[index + 1];
+}
+function parseArgs(args) {
+	const parsed = {
+		cwd: process.cwd(),
+		help: false,
+		json: false,
+		packagePatterns: [],
+		workspacePatterns: [],
+		errors: []
+	};
+	let positionalOnly = false;
+	for (let index = 0; index < args.length; index += 1) {
+		const argument = args[index];
+		if (positionalOnly) parsed.packagePatterns.push(argument);
+		else if (argument === "--") positionalOnly = true;
+		else if (argument === "--help" || argument === "-h") parsed.help = true;
+		else if (argument === "--json") parsed.json = true;
+		else if (argument === "--cwd") {
+			const value = optionValue(args, index, "--cwd", parsed.errors);
+			if (value !== null) {
+				parsed.cwd = path.resolve(value);
+				index += 1;
+			}
+		} else if (argument.startsWith("--cwd=")) parsed.cwd = path.resolve(argument.slice(6));
+		else if (argument === "--workspace") {
+			const value = optionValue(args, index, "--workspace", parsed.errors);
+			if (value !== null) {
+				parsed.workspacePatterns.push(value);
+				index += 1;
+			}
+		} else if (argument.startsWith("--workspace=")) parsed.workspacePatterns.push(argument.slice(12));
+		else if (argument === "--tag") {
+			const value = optionValue(args, index, "--tag", parsed.errors);
+			if (value !== null) {
+				parsed.tag = value;
+				index += 1;
+			}
+		} else if (argument.startsWith("--tag=")) parsed.tag = argument.slice(6);
+		else if (argument.startsWith("-")) parsed.errors.push(`Unknown option: ${argument}`);
+		else parsed.packagePatterns.push(argument);
+	}
+	if (parsed.tag !== void 0 && (!parsed.tag || /\s/.test(parsed.tag))) parsed.errors.push("--tag must be a non-empty dist-tag without whitespace");
+	if (parsed.workspacePatterns.some((pattern) => !pattern)) parsed.errors.push("--workspace patterns must not be empty");
+	if (parsed.packagePatterns.some((pattern) => !pattern)) parsed.errors.push("Package patterns must not be empty");
+	return parsed;
+}
+function emptySummary() {
+	return {
+		packages: 0,
+		occurrences: 0,
+		changedOccurrences: 0,
+		current: 0,
+		safe: 0,
+		breaking: 0,
+		local: 0,
+		manual: 0,
+		error: 0
+	};
+}
+function serializableDecision(decision) {
+	return {
+		package: decision.package,
+		selectedTag: decision.selectedTag,
+		targetVersion: decision.targetVersion,
+		status: decision.status,
+		reason: decision.reason,
+		occurrences: decision.occurrences.map((occurrence) => ({
+			workspace: occurrence.workspace,
+			manifest: occurrence.relativeManifestPath,
+			section: occurrence.section,
+			currentSpecification: occurrence.currentSpecification,
+			proposedSpecification: occurrence.proposedSpecification,
+			allowedVersion: occurrence.allowedVersion,
+			status: occurrence.status,
+			reason: occurrence.reason
+		}))
+	};
+}
+function selectedWorkspaceJson(root, workspaces) {
+	return workspaces.map((workspace) => ({
+		name: workspace.name,
+		path: path.relative(root, workspace.directory).split(path.sep).join("/") || ".",
+		manifest: workspace.relativeManifestPath
+	}));
+}
+function emitJson(io, options) {
+	io.log(JSON.stringify({
+		root: options.root,
+		workspaces: options.workspaces,
+		summary: options.summary,
+		decisions: options.decisions.map(serializableDecision),
+		applied: { occurrences: options.applied },
+		errors: options.errors
+	}, null, 2));
+}
+function rangeText(occurrence, command) {
+	if (occurrence.proposedSpecification) return `${occurrence.currentSpecification} → ${occurrence.proposedSpecification}`;
+	if (occurrence.status === "breaking") return command === "upgrade" ? `${occurrence.currentSpecification} (${occurrence.reason})` : `${occurrence.currentSpecification} (available via askr upgrade)`;
+	return `${occurrence.currentSpecification} (${occurrence.reason})`;
+}
+function renderTable(rows) {
+	const headings = [
+		"Package",
+		"Allowed",
+		"Latest",
+		"Status",
+		"Range"
+	];
+	const widths = headings.map((heading, column) => Math.max(heading.length, ...rows.map((row) => row[column].length)));
+	return [headings, ...rows].map((row) => row.map((value, column) => column === row.length - 1 ? value : value.padEnd(widths[column])).join("  "));
+}
+function emitHuman(io, decisions, summary, applied, command) {
+	const byWorkspace = /* @__PURE__ */ new Map();
+	for (const decision of decisions) for (const occurrence of decision.occurrences) {
+		if (occurrence.status === "current") continue;
+		const rows = byWorkspace.get(occurrence.workspace) ?? [];
+		const row = [
+			decision.package,
+			occurrence.allowedVersion ?? "-",
+			decision.targetVersion ?? "-",
+			occurrence.status,
+			rangeText(occurrence, command)
+		];
+		if (!rows.some((existing) => existing.every((value, index) => value === row[index]))) rows.push(row);
+		byWorkspace.set(occurrence.workspace, rows);
+	}
+	if (byWorkspace.size === 0) io.log("All selected dependencies are current.");
+	else {
+		let first = true;
+		for (const [workspace, rows] of byWorkspace) {
+			if (!first) io.log("");
+			first = false;
+			io.log(workspace);
+			for (const line of renderTable(rows)) io.log(line);
+		}
+	}
+	const counts = [
+		"safe",
+		"breaking",
+		"current",
+		"manual",
+		"local",
+		"error"
+	].filter((status) => summary[status] > 0).map((status) => `${summary[status]} ${status}`).join(", ");
+	io.log("");
+	io.log(`Scanned ${summary.packages} package${summary.packages === 1 ? "" : "s"}${counts ? `: ${counts}` : "."}`);
+	if (command !== "outdated") io.log(`Updated ${applied} manifest occurrence${applied === 1 ? "" : "s"}.`);
+}
+function collectEdits(decisions) {
+	return decisions.flatMap((decision) => decision.occurrences.flatMap((occurrence) => occurrence.proposedSpecification ? [{
+		manifestPath: occurrence.manifestPath,
+		section: occurrence.section,
+		package: decision.package,
+		currentSpecification: occurrence.currentSpecification,
+		proposedSpecification: occurrence.proposedSpecification
+	}] : []));
+}
+async function defaultRegistry(root, packageNames, requirements) {
+	const { fetchPackuments, loadNpmConfiguration } = await import("./registry-CyrRHRG5.js");
+	return fetchPackuments(packageNames, await loadNpmConfiguration(root), { requirements });
+}
+async function runDependencyCli(command, args, io = console, runtime = {}) {
+	const parsed = parseArgs(args);
+	if (parsed.help && parsed.errors.length === 0) {
+		io.log(helpText(command));
+		return 0;
+	}
+	if (parsed.errors.length > 0) {
+		for (const error of parsed.errors) io.error(`askr ${command}: ${error}`);
+		if (parsed.json) emitJson(io, {
+			root: null,
+			workspaces: [],
+			summary: emptySummary(),
+			decisions: [],
+			applied: 0,
+			errors: parsed.errors
+		});
+		return 1;
+	}
+	let root = null;
+	let selectedWorkspaces = [];
+	try {
+		const [{ discoverProject }, { planUpdates }] = await Promise.all([import("./discovery-Difb7Y4G.js"), import("./planner-VAj7qlxr.js")]);
+		const project = await discoverProject({
+			cwd: parsed.cwd,
+			packagePatterns: parsed.packagePatterns,
+			workspacePatterns: parsed.workspacePatterns
+		});
+		root = project.root;
+		selectedWorkspaces = project.selectedWorkspaces;
+		const lookupNames = project.occurrences.some((occurrence) => occurrence.kind === "fetch") ? project.contextOccurrences.filter((occurrence) => occurrence.registryManaged).map((occurrence) => occurrence.package) : [];
+		const registry = runtime.registry ?? defaultRegistry;
+		const specifications = /* @__PURE__ */ new Map();
+		for (const occurrence of project.contextOccurrences) {
+			const entries = specifications.get(occurrence.package) ?? [];
+			if (!entries.includes(occurrence.currentSpecification)) entries.push(occurrence.currentSpecification);
+			specifications.set(occurrence.package, entries);
+		}
+		const results = lookupNames.length > 0 ? await registry(project.root, lookupNames, { specifications }) : {
+			packuments: /* @__PURE__ */ new Map(),
+			failures: /* @__PURE__ */ new Map()
+		};
+		const plan = planUpdates({
+			occurrences: project.occurrences,
+			contextOccurrences: project.contextOccurrences,
+			packuments: results.packuments,
+			failures: results.failures,
+			tags: project.policy.tags,
+			cliTag: parsed.tag,
+			force: command === "upgrade"
+		});
+		let applied = 0;
+		const errors = [];
+		if (!plan.hasErrors && command !== "outdated") try {
+			applied = await (runtime.writer ?? (await import("./writer-D8qe_7ud.js")).writeManifestEdits)(collectEdits(plan.decisions));
+		} catch {
+			errors.push("Unable to replace package manifests; completed replacements were rolled back when possible.");
+		}
+		if (plan.hasErrors) errors.push("One or more registry lookups or package plans failed.");
+		if (parsed.json) emitJson(io, {
+			root: project.root,
+			workspaces: selectedWorkspaceJson(project.root, project.selectedWorkspaces),
+			summary: plan.summary,
+			decisions: plan.decisions,
+			applied,
+			errors
+		});
+		else emitHuman(io, plan.decisions, plan.summary, applied, command);
+		for (const error of errors) io.error(`askr ${command}: ${error}`);
+		return errors.length > 0 ? 1 : 0;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Update failed.";
+		io.error(`askr ${command}: ${message}`);
+		if (parsed.json) emitJson(io, {
+			root,
+			workspaces: root ? selectedWorkspaceJson(root, selectedWorkspaces) : [],
+			summary: emptySummary(),
+			decisions: [],
+			applied: 0,
+			errors: [message]
+		});
+		return 1;
+	}
+}
+const runUpdateCli = (args, io = console, runtime = {}) => runDependencyCli("update", args, io, runtime);
+const runUpgradeCli = (args, io = console, runtime = {}) => runDependencyCli("upgrade", args, io, runtime);
+const runOutdatedCli = (args, io = console, runtime = {}) => runDependencyCli("outdated", args, io, runtime);
+async function main() {
+	process.exit(await runUpdateCli(process.argv.slice(2)));
+}
+if (isDirectExecution(import.meta.url)) main();
+//#endregion
+export { runOutdatedCli, runUpdateCli, runUpgradeCli };

package/dist/writer-D8qe_7ud.js

@@ -0,0 +1,226 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+//#region src/update/writer.ts
+function groupEdits(edits) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const edit of edits) {
+		const entries = grouped.get(edit.manifestPath) ?? [];
+		entries.push(edit);
+		grouped.set(edit.manifestPath, entries);
+	}
+	for (const entries of grouped.values()) entries.sort((left, right) => left.section.localeCompare(right.section) || left.package.localeCompare(right.package));
+	return new Map([...grouped].sort(([left], [right]) => left.localeCompare(right)));
+}
+var JsonTreeParser = class {
+	source;
+	index = 0;
+	constructor(source) {
+		this.source = source;
+		if (source.charCodeAt(0) === 65279) this.index = 1;
+	}
+	parse() {
+		const node = this.parseValue();
+		this.skipWhitespace();
+		if (this.index !== this.source.length) throw new Error("Unexpected content after JSON value");
+		return node;
+	}
+	skipWhitespace() {
+		while (/[ \t\r\n]/.test(this.source[this.index] ?? "")) this.index += 1;
+	}
+	parseValue() {
+		this.skipWhitespace();
+		const token = this.source[this.index];
+		if (token === "{") return this.parseObject();
+		if (token === "[") return this.parseArray();
+		if (token === "\"") return this.parseString();
+		return this.parsePrimitive();
+	}
+	parseString() {
+		const start = this.index;
+		this.index += 1;
+		while (this.index < this.source.length) {
+			const token = this.source[this.index];
+			if (token === "\\") {
+				this.index += 2;
+				continue;
+			}
+			this.index += 1;
+			if (token === "\"") {
+				const raw = this.source.slice(start, this.index);
+				const value = JSON.parse(raw);
+				if (typeof value !== "string") throw new Error("Invalid JSON string");
+				return {
+					end: this.index,
+					kind: "string",
+					start,
+					value
+				};
+			}
+		}
+		throw new Error("Unterminated JSON string");
+	}
+	parseObject() {
+		const start = this.index;
+		const properties = /* @__PURE__ */ new Map();
+		this.index += 1;
+		this.skipWhitespace();
+		if (this.source[this.index] === "}") {
+			this.index += 1;
+			return {
+				end: this.index,
+				kind: "object",
+				properties,
+				start
+			};
+		}
+		while (this.index < this.source.length) {
+			this.skipWhitespace();
+			if (this.source[this.index] !== "\"") throw new Error("Expected a JSON object key");
+			const key = this.parseString().value;
+			this.skipWhitespace();
+			if (this.source[this.index] !== ":") throw new Error("Expected ':' after JSON object key");
+			this.index += 1;
+			properties.set(key, this.parseValue());
+			this.skipWhitespace();
+			if (this.source[this.index] === "}") {
+				this.index += 1;
+				return {
+					end: this.index,
+					kind: "object",
+					properties,
+					start
+				};
+			}
+			if (this.source[this.index] !== ",") throw new Error("Expected ',' in JSON object");
+			this.index += 1;
+		}
+		throw new Error("Unterminated JSON object");
+	}
+	parseArray() {
+		const start = this.index;
+		this.index += 1;
+		this.skipWhitespace();
+		if (this.source[this.index] === "]") {
+			this.index += 1;
+			return {
+				end: this.index,
+				kind: "array",
+				start
+			};
+		}
+		while (this.index < this.source.length) {
+			this.parseValue();
+			this.skipWhitespace();
+			if (this.source[this.index] === "]") {
+				this.index += 1;
+				return {
+					end: this.index,
+					kind: "array",
+					start
+				};
+			}
+			if (this.source[this.index] !== ",") throw new Error("Expected ',' in JSON array");
+			this.index += 1;
+		}
+		throw new Error("Unterminated JSON array");
+	}
+	parsePrimitive() {
+		const start = this.index;
+		while (this.index < this.source.length && !/[ \t\r\n,\]}]/.test(this.source[this.index])) this.index += 1;
+		if (start === this.index) throw new Error("Expected a JSON value");
+		JSON.parse(this.source.slice(start, this.index));
+		return {
+			end: this.index,
+			kind: "other",
+			start
+		};
+	}
+};
+function renderReplacement(source, edits) {
+	let manifest;
+	try {
+		manifest = new JsonTreeParser(source).parse();
+	} catch {
+		throw new Error("Manifest changed to invalid JSON before writing.");
+	}
+	if (manifest.kind !== "object") throw new Error("Manifest changed to invalid JSON before writing.");
+	const replacements = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const edit of edits) {
+		const key = `${edit.section}\u0000${edit.package}`;
+		if (seen.has(key)) throw new Error(`Duplicate manifest edit: ${edit.manifestPath}`);
+		seen.add(key);
+		const current = (manifest.properties?.get(edit.section))?.properties?.get(edit.package);
+		if (current?.kind !== "string" || current.value !== edit.currentSpecification) throw new Error(`Manifest changed before writing: ${edit.manifestPath}`);
+		replacements.push({
+			start: current.start,
+			end: current.end,
+			value: JSON.stringify(edit.proposedSpecification)
+		});
+	}
+	let result = source;
+	replacements.sort((left, right) => right.start - left.start);
+	for (const replacement of replacements) result = `${result.slice(0, replacement.start)}${replacement.value}${result.slice(replacement.end)}`;
+	return result;
+}
+async function cleanup(paths) {
+	await Promise.all(paths.map((filePath) => fs.rm(filePath, { force: true }).catch(() => void 0)));
+}
+async function rollback(replaced) {
+	let complete = true;
+	for (const staged of [...replaced].reverse()) {
+		const rollbackPath = path.join(path.dirname(staged.manifestPath), `.${path.basename(staged.manifestPath)}.askr-rollback-${randomUUID()}`);
+		try {
+			await fs.writeFile(rollbackPath, staged.original, {
+				flag: "wx",
+				mode: staged.mode
+			});
+			await fs.rename(rollbackPath, staged.manifestPath);
+		} catch {
+			complete = false;
+			await fs.rm(rollbackPath, { force: true }).catch(() => void 0);
+		}
+	}
+	return complete;
+}
+async function writeManifestEdits(edits, options = {}) {
+	if (edits.length === 0) return 0;
+	const staged = [];
+	const replace = options.replace ?? fs.rename;
+	try {
+		for (const [manifestPath, manifestEdits] of groupEdits(edits)) {
+			const [original, stat] = await Promise.all([fs.readFile(manifestPath), fs.stat(manifestPath)]);
+			const replacement = renderReplacement(original.toString("utf8"), manifestEdits);
+			const temporaryPath = path.join(path.dirname(manifestPath), `.${path.basename(manifestPath)}.askr-update-${randomUUID()}`);
+			await fs.writeFile(temporaryPath, replacement, {
+				flag: "wx",
+				mode: stat.mode
+			});
+			staged.push({
+				manifestPath,
+				original,
+				replacement,
+				temporaryPath,
+				mode: stat.mode
+			});
+		}
+	} catch (error) {
+		await cleanup(staged.map((entry) => entry.temporaryPath));
+		throw error;
+	}
+	const replaced = [];
+	try {
+		for (const manifest of staged) {
+			await replace(manifest.temporaryPath, manifest.manifestPath);
+			replaced.push(manifest);
+		}
+	} catch {
+		const rollbackComplete = await rollback(replaced);
+		await cleanup(staged.map((entry) => entry.temporaryPath));
+		throw new Error(rollbackComplete ? "Manifest replacement failed; completed replacements were rolled back." : "Manifest replacement failed and rollback was incomplete.");
+	}
+	return edits.length;
+}
+//#endregion
+export { writeManifestEdits };