modwright 0.1.1 → 0.1.3

package/dist/core/ownership/index.js

@@ -0,0 +1,364 @@
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+import { isDirectory, pathExists, walk } from "../fsutil.js";
+import { findMo2Instance, readMo2ModMeta, readMo2Modlist } from "../managers/mo2.js";
+import { readVortexManifests } from "../managers/vortex.js";
+import { listMods } from "../mods.js";
+const MANAGER_EVIDENCE = new Set(["mo2", "mo2-overwrite", "vortex"]);
+function isManagerBookkeeping(relative) {
+    const base = relative.slice(relative.lastIndexOf("/") + 1).toLowerCase();
+    return /^vortex\.deployment\.(?:[^.]+\.)?json$/.test(base) || base === "__folder_managed_by_vortex";
+}
+function keyOf(p) {
+    return p.toLowerCase();
+}
+function gamePath(install, abs) {
+    const rel = path.relative(install.root, abs);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel))
+        return abs.split(path.sep).join("/");
+    return rel.split(path.sep).join("/");
+}
+export async function buildOwnershipIndex(surface, install, options = {}) {
+    const perMod = options.fileLimitPerMod ?? 20000;
+    const index = {
+        install: install.root,
+        sources: [],
+        unattributedRoots: [],
+        looseRoots: [],
+        entries: new Map(),
+        physical: new Map(),
+    };
+    const add = (display, claim) => {
+        const key = keyOf(display);
+        let entry = index.entries.get(key);
+        if (!entry) {
+            entry = { path: display, claims: [] };
+            index.entries.set(key, entry);
+        }
+        entry.claims.push(claim);
+        if (claim.physicalPath)
+            index.physical.set(keyOf(claim.physicalPath), key);
+    };
+    const { mods, roots } = await listMods(surface, install, { fileLimit: perMod });
+    if (surface.looseUnitOf)
+        index.looseUnitOf = (rootId, rel) => surface.looseUnitOf(rootId, rel);
+    const rootById = new Map(roots.map((r) => [r.id, r]));
+    const modRootsReport = { id: "mod-roots", active: true, detail: "", mods: 0, files: 0 };
+    const flatRoots = [];
+    for (const mod of mods) {
+        const root = rootById.get(mod.rootId);
+        if (!root)
+            continue;
+        if (root.layout === "flat") {
+            flatRoots.push({ rootId: root.id, path: root.path, files: mod.files });
+            if (surface.looseUnitOf) {
+                index.looseRoots.push({ rootId: root.id, path: root.path });
+                for (const file of mod.files) {
+                    const unit = surface.looseUnitOf(root.id, file);
+                    if (!unit)
+                        continue;
+                    add(gamePath(install, path.join(root.path, file)), { mod: unit, modId: `${root.id}:${unit}`, enabled: true, evidence: "loose-unit" });
+                    modRootsReport.files++;
+                }
+            }
+            continue;
+        }
+        modRootsReport.mods++;
+        if (mod.warnings?.some((w) => w.includes("truncated")))
+            modRootsReport.truncated = true;
+        const base = { mod: mod.name, modId: mod.id, enabled: true };
+        if (mod.manifest?.version)
+            base.version = mod.manifest.version;
+        if (root.layout === "file") {
+            add(gamePath(install, mod.path), { ...base, evidence: "mod-file" });
+            modRootsReport.files++;
+            continue;
+        }
+        for (const file of mod.files) {
+            add(gamePath(install, path.join(mod.path, file)), { ...base, evidence: "mod-folder" });
+            modRootsReport.files++;
+        }
+    }
+    modRootsReport.detail =
+        `${modRootsReport.mods} mod(s) in ${surface.name}'s own mod roots: a mod folder owns the files under it, ` +
+            "and in a file-per-mod root the file is the mod.";
+    index.sources.push(modRootsReport);
+    let mo2Covered = false;
+    if (surface.managedDataDir !== undefined) {
+        const report = { id: "mo2", active: false, detail: "", mods: 0, files: 0 };
+        const findOptions = {};
+        if (options.mo2Instance)
+            findOptions.instancePath = options.mo2Instance;
+        if (options.mo2InstancesRoot)
+            findOptions.instancesRoot = options.mo2InstancesRoot;
+        const instance = await findMo2Instance(install, findOptions);
+        if (!instance) {
+            report.detail = options.mo2Instance
+                ? `No ModOrganizer.ini at ${options.mo2Instance}.`
+                : "No global Mod Organizer 2 instance manages this install. A portable instance is only found " +
+                    "when named (mo2Instance).";
+        }
+        else {
+            const modlist = await readMo2Modlist(instance.profileDir);
+            if (!modlist) {
+                report.detail = `MO2 instance ${instance.instanceDir} found, but profile "${instance.profileName}" has no readable modlist.txt.`;
+            }
+            else {
+                report.active = true;
+                mo2Covered = true;
+                const problems = [];
+                const dataDir = path.join(install.root, surface.managedDataDir);
+                let budget = options.totalFileLimit ?? 400000;
+                const walkInto = async (dir, claim) => {
+                    const result = await walk(dir, { limit: Math.min(perMod, Math.max(budget, 0)) });
+                    if (result.truncated)
+                        report.truncated = true;
+                    let count = 0;
+                    for (const file of result.files) {
+                        if (file.toLowerCase() === "meta.ini")
+                            continue;
+                        add(gamePath(install, path.join(dataDir, file)), { ...claim, physicalPath: path.join(dir, file) });
+                        count++;
+                    }
+                    budget -= result.files.length;
+                    report.files += count;
+                    return count;
+                };
+                for (const entry of modlist) {
+                    if (entry.foreign || entry.separator)
+                        continue;
+                    if (budget <= 0) {
+                        report.truncated = true;
+                        break;
+                    }
+                    const modDir = path.join(instance.modsDir, entry.name);
+                    if (!(await isDirectory(modDir))) {
+                        problems.push(`"${entry.name}" is in modlist.txt but has no folder in ${instance.modsDir}.`);
+                        continue;
+                    }
+                    const meta = await readMo2ModMeta(modDir);
+                    const claim = {
+                        mod: entry.name,
+                        modId: `mo2:${entry.name}`,
+                        evidence: "mo2",
+                        enabled: entry.enabled,
+                        priority: entry.priority,
+                    };
+                    if (meta.nexusModId !== undefined)
+                        claim.nexusModId = meta.nexusModId;
+                    if (meta.version)
+                        claim.version = meta.version;
+                    await walkInto(modDir, claim);
+                    report.mods++;
+                }
+                if (await pathExists(instance.overwriteDir)) {
+                    const top = modlist.reduce((max, e) => Math.max(max, e.priority), 0) + 1;
+                    await walkInto(instance.overwriteDir, {
+                        mod: "Overwrite",
+                        modId: "mo2:Overwrite",
+                        evidence: "mo2-overwrite",
+                        enabled: true,
+                        priority: top,
+                    });
+                }
+                report.detail =
+                    `MO2 ${instance.portable ? "portable" : "global"} instance ${instance.instanceDir}, profile ` +
+                        `"${instance.profileName}": ${report.mods} mod folder(s) mapped onto ${surface.managedDataDir}/ in ` +
+                        "modlist.txt priority order (top line wins; Overwrite above all). The real game folder under MO2 " +
+                        "holds only the base game and files MO2 does not manage.";
+                if (problems.length > 0)
+                    report.problems = problems.slice(0, 25);
+            }
+        }
+        index.sources.push(report);
+    }
+    const vortexDirs = [install.root];
+    if (surface.managedDataDir)
+        vortexDirs.push(path.join(install.root, surface.managedDataDir));
+    const vortex = { id: "vortex", active: false, detail: "", mods: 0, files: 0 };
+    const vortexMods = new Set();
+    const vortexProblems = [];
+    const manifestNames = [];
+    for (const dir of [...new Set(vortexDirs)]) {
+        const { manifests, unreadable } = await readVortexManifests(dir);
+        for (const bad of unreadable)
+            vortexProblems.push(`${bad.file}: ${bad.error}`);
+        for (const manifest of manifests) {
+            manifestNames.push(gamePath(install, manifest.file));
+            for (const file of manifest.files) {
+                const targetDir = file.target
+                    ? path.isAbsolute(file.target)
+                        ? file.target
+                        : path.join(manifest.deployDir, file.target)
+                    : manifest.deployDir;
+                const claim = { mod: file.source, modId: `vortex:${file.source}`, evidence: "vortex", enabled: true };
+                if (manifest.stagingPath)
+                    claim.physicalPath = path.join(manifest.stagingPath, file.source, file.relPath);
+                if (file.merged?.length)
+                    claim.merged = file.merged;
+                add(gamePath(install, path.join(targetDir, file.relPath)), claim);
+                vortexMods.add(file.source);
+                vortex.files++;
+            }
+        }
+    }
+    vortex.mods = vortexMods.size;
+    if (manifestNames.length > 0) {
+        vortex.active = true;
+        vortex.detail =
+            `Vortex deployment manifest(s) ${manifestNames.join(", ")}: each deployed file with the mod it came ` +
+                "from. Vortex resolved conflicts before deploying, so a manifest names the winner only.";
+    }
+    else {
+        vortex.detail = "No Vortex deployment manifest in the game folder.";
+    }
+    if (vortexProblems.length > 0)
+        vortex.problems = vortexProblems;
+    index.sources.push(vortex);
+    if (!mo2Covered) {
+        for (const root of flatRoots) {
+            const unclaimed = root.files.filter((f) => !isManagerBookkeeping(f) && !index.entries.has(keyOf(gamePath(install, path.join(root.path, f)))));
+            if (unclaimed.length > 0)
+                index.unattributedRoots.push({ rootId: root.rootId, path: root.path, files: unclaimed.length });
+        }
+    }
+    return index;
+}
+export function verdictFor(entry) {
+    const claims = entry.claims;
+    const mo2 = claims.filter((c) => c.evidence === "mo2" || c.evidence === "mo2-overwrite");
+    const vortex = claims.filter((c) => c.evidence === "vortex");
+    const local = claims.filter((c) => !MANAGER_EVIDENCE.has(c.evidence));
+    const inactive = claims.filter((c) => !c.enabled);
+    if (mo2.length > 0) {
+        const enabled = mo2.filter((c) => c.enabled).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+        const winner = enabled[0];
+        const overridden = winner ? [...enabled.slice(1), ...local] : [];
+        const verdict = {
+            path: entry.path,
+            overridden,
+            inactive,
+            contested: enabled.length + local.length > 1,
+            basis: winner
+                ? "MO2 priority: the highest enabled mod in the profile's modlist.txt wins (Overwrite above all), and every mod folder overrides the real game folder."
+                : "Only disabled MO2 mods provide this path; the game sees " +
+                    (local.length > 0 ? "the real game folder's copy." : "no file here."),
+        };
+        if (winner)
+            verdict.winner = winner;
+        else if (local.length === 1)
+            verdict.winner = local[0];
+        return verdict;
+    }
+    if (vortex.length > 0) {
+        const verdict = {
+            path: entry.path,
+            winner: vortex[vortex.length - 1],
+            overridden: [],
+            inactive,
+            contested: new Set(vortex.map((c) => c.modId)).size > 1,
+            basis: "Vortex deployment manifest: this is the copy Vortex deployed. Mods that lost the conflict are not recorded there" +
+                (vortex.some((c) => c.merged?.length) ? "; the file was merged from the mods in `merged`." : "."),
+        };
+        return verdict;
+    }
+    const distinct = new Set(local.map((c) => c.modId));
+    if (distinct.size <= 1) {
+        const verdict = {
+            path: entry.path,
+            overridden: [],
+            inactive,
+            contested: false,
+            basis: local[0]?.evidence === "mod-file"
+                ? "The file is itself the mod (a file-per-mod root)."
+                : local[0]?.evidence === "loose-unit"
+                    ? "The unpacked mod whose own folder in the loose-file root holds this path (e.g. BG3's Data/Mods/<Mod>); no manager deployed it."
+                    : "The only mod whose folder holds this path.",
+        };
+        if (local[0])
+            verdict.winner = local[0];
+        return verdict;
+    }
+    return {
+        path: entry.path,
+        overridden: [],
+        inactive,
+        contested: true,
+        basis: "Several mods provide this path and ModWright does not model which one the game reads here.",
+    };
+}
+function looseFallback(index, query, q) {
+    if (!index.looseUnitOf)
+        return undefined;
+    const absolute = path.isAbsolute(query) || /^[a-z]:\//i.test(q);
+    for (const root of index.looseRoots) {
+        const candidates = absolute ? [path.resolve(query)] : [path.resolve(index.install, q), path.resolve(root.path, q)];
+        for (const abs of candidates) {
+            const rel = path.relative(root.path, abs);
+            if (rel.startsWith("..") || path.isAbsolute(rel) || !existsSync(abs))
+                continue;
+            const unit = index.looseUnitOf(root.rootId, rel.split(path.sep).join("/"));
+            if (!unit)
+                continue;
+            const display = path.relative(index.install, abs).split(path.sep).join("/");
+            return verdictFor({ path: display, claims: [{ mod: unit, modId: `${root.rootId}:${unit}`, enabled: true, evidence: "loose-unit" }] });
+        }
+    }
+    return undefined;
+}
+export function lookupOwnership(index, query, limit = 20) {
+    const q = query.trim().replace(/\\/g, "/");
+    const found = (matchedBy, keys) => {
+        const results = keys.slice(0, limit).map((k) => verdictFor(index.entries.get(k)));
+        const out = { query, matchedBy, results };
+        if (keys.length > limit)
+            out.omitted = keys.length - limit;
+        return out;
+    };
+    if (path.isAbsolute(query) || /^[a-z]:\//i.test(q)) {
+        const physicalKey = index.physical.get(keyOf(path.resolve(query)));
+        if (physicalKey)
+            return found("physical", [physicalKey]);
+        const rel = path.relative(index.install, path.resolve(query));
+        const key = keyOf(!rel.startsWith("..") && !path.isAbsolute(rel) ? rel.split(path.sep).join("/") : q);
+        if (index.entries.has(key))
+            return found("path", [key]);
+    }
+    else {
+        const key = keyOf(q.replace(/^\.?\//, ""));
+        if (index.entries.has(key))
+            return found("path", [key]);
+        if (key.includes("/")) {
+            const suffix = `/${key}`;
+            const keys = [...index.entries.keys()].filter((k) => k.endsWith(suffix));
+            if (keys.length > 0)
+                return found("suffix", keys);
+        }
+        else {
+            const keys = [...index.entries.keys()].filter((k) => k.slice(k.lastIndexOf("/") + 1) === key);
+            if (keys.length > 0)
+                return found("basename", keys);
+        }
+    }
+    const loose = looseFallback(index, query, q);
+    if (loose)
+        return { query, matchedBy: "path", results: [loose] };
+    return {
+        query,
+        matchedBy: "none",
+        results: [],
+        note: "No mod claims this path. It is a base-game file, was placed by hand into a loose-file folder with " +
+            "no manager (see unattributedRoots), sits inside a packed archive (not indexed yet), or the path is misspelled.",
+    };
+}
+export function managerConflicts(index, limit = 100) {
+    const contested = [];
+    for (const entry of index.entries.values()) {
+        const enabledMo2 = entry.claims.filter((c) => (c.evidence === "mo2" || c.evidence === "mo2-overwrite") && c.enabled);
+        if (enabledMo2.length < 2)
+            continue;
+        contested.push(verdictFor(entry));
+    }
+    contested.sort((a, b) => b.overridden.length - a.overridden.length || a.path.localeCompare(b.path));
+    return { total: contested.length, conflicts: contested.slice(0, limit) };
+}

package/dist/core/project/index.js

@@ -1,5 +1,6 @@
 export * from "./types.js";
 export { modProjectSchema, parseProject } from "./schema.js";
-export { findProjectFile, loadProject } from "./load.js";
+export { findProjectFile, loadProject, locateProjectFile } from "./load.js";
+export { escapesRoot, outsideRootPaths } from "./outside-root.js";
 export { describeProject } from "./describe.js";
 export { defaultArtifactName, normalizeBuildSteps } from "./build-steps.js";

package/dist/core/project/load.js

@@ -4,6 +4,7 @@ import { isDirectory, pathExists } from "../fsutil.js";
 import { getSurface, surfaceIds } from "../../surfaces/index.js";
 import { parseProject } from "./schema.js";
 import { PROJECT_FILE } from "./types.js";
+import { looksAbsolute, outsideRootPaths } from "./outside-root.js";
 export async function findProjectFile(startDir) {
     let dir = path.resolve(startDir);
     for (;;) {
@@ -16,8 +17,10 @@ export async function findProjectFile(startDir) {
         dir = parent;
     }
 }
-function looksAbsolute(p) {
-    return path.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p) || p.startsWith("\\\\");
+export async function locateProjectFile(start) {
+    if (start.toLowerCase().endsWith(".json"))
+        return (await pathExists(start)) ? start : undefined;
+    return findProjectFile(start);
 }
 function isWithin(parent, child) {
     const rel = path.relative(parent, child);
@@ -115,29 +118,8 @@ export async function loadProject(fileOrDir) {
             }
         }
     }
-    const escapes = (p) => p !== undefined && (looksAbsolute(p) || p.split(/[\\/]/).includes(".."));
-    for (const target of project.deploy?.targets ?? []) {
-        if (escapes(target.into)) {
-            warnings.push(`deploy target "${target.from}": into "${target.into}" leaves the "${target.rootId}" root (absolute or "..")`);
-        }
-    }
-    for (const junction of project.deploy?.junctions ?? []) {
-        if (escapes(junction.linkPath)) {
-            warnings.push(`junction linkPath "${junction.linkPath}" leaves the "${junction.rootId}" root (absolute or "..")`);
-        }
-    }
-    for (const step of project.build?.steps ?? []) {
-        if (typeof step !== "object" || step === null)
-            continue;
-        const s = step;
-        if ((s.step === "wolvenkit-pack" || s.step === "divine-create-package") && escapes(s.out)) {
-            warnings.push(`build step ${s.step}: out "${s.out}" leaves build.outDir (absolute or "..")`);
-        }
-        if (s.step === "zip" && escapes(s.name))
-            warnings.push(`build step zip: name "${s.name}" leaves build.outDir (absolute or "..")`);
-        if (s.step === "exec" && s.cwd !== undefined && !s.cwd.includes("${stage}") && escapes(s.cwd)) {
-            warnings.push(`build step exec: cwd "${s.cwd}" leaves the project (absolute or "..")`);
-        }
+    for (const entry of outsideRootPaths(project)) {
+        warnings.push(entry.allowed ? `${entry.message} — allowed by allowOutsideRoot` : `${entry.message}; build and deploy refuse it unless the entry sets "allowOutsideRoot": true`);
     }
     const toolchain = project.toolchain
         ? Object.fromEntries(Object.entries(project.toolchain).map(([id, p]) => [id, looksAbsolute(p) ? p : resolveFromRoot(p)]))

package/dist/core/project/outside-root.js

@@ -0,0 +1,36 @@
+import * as path from "node:path";
+export function looksAbsolute(p) {
+    return path.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p) || p.startsWith("\\\\");
+}
+export function escapesRoot(p) {
+    return p !== undefined && (looksAbsolute(p) || p.split(/[\\/]/).includes(".."));
+}
+export function outsideRootPaths(project, steps = project.build?.steps) {
+    const found = [];
+    for (const target of project.deploy?.targets ?? []) {
+        if (escapesRoot(target.into)) {
+            found.push({ kind: "deploy-target", value: target.into, allowed: target.allowOutsideRoot === true, message: `deploy target "${target.from}": into "${target.into}" leaves the "${target.rootId}" root (absolute or "..")` });
+        }
+    }
+    for (const junction of project.deploy?.junctions ?? []) {
+        if (escapesRoot(junction.linkPath)) {
+            found.push({ kind: "junction", value: junction.linkPath, allowed: junction.allowOutsideRoot === true, message: `junction linkPath "${junction.linkPath}" leaves the "${junction.rootId}" root (absolute or "..")` });
+        }
+    }
+    for (const step of steps ?? []) {
+        if (typeof step !== "object" || step === null)
+            continue;
+        const s = step;
+        const label = `build step ${s.id ? `"${s.id}" (${s.step})` : s.step}`;
+        const allowed = s.allowOutsideRoot === true;
+        if ((s.step === "wolvenkit-pack" || s.step === "divine-create-package") && escapesRoot(s.out)) {
+            found.push({ kind: "build-step", value: s.out, allowed, message: `${label}: out "${s.out}" leaves build.outDir (absolute or "..")` });
+        }
+        if (s.step === "zip" && escapesRoot(s.name))
+            found.push({ kind: "build-step", value: s.name, allowed, message: `${label}: name "${s.name}" leaves build.outDir (absolute or "..")` });
+        if (s.step === "exec" && s.cwd !== undefined && !s.cwd.includes("${stage}") && escapesRoot(s.cwd)) {
+            found.push({ kind: "build-step", value: s.cwd, allowed, message: `${label}: cwd "${s.cwd}" leaves the project (absolute or "..")` });
+        }
+    }
+    return found;
+}

package/dist/core/project/schema.js

@@ -68,6 +68,7 @@ const buildStepSchema = z.discriminatedUnion("step", [
         .object({
         ...stepBase,
         step: z.literal("zip"),
+        allowOutsideRoot: z.boolean().optional(),
         from: z.string(),
         name: z.string(),
     })
@@ -94,6 +95,7 @@ const buildStepSchema = z.discriminatedUnion("step", [
         .object({
         ...stepBase,
         step: z.literal("wolvenkit-pack"),
+        allowOutsideRoot: z.boolean().optional(),
         from: z.string(),
         out: z.string(),
         verbosity: z.enum(["Minimal", "Normal", "Diagnostic"]).default("Minimal"),
@@ -120,6 +122,7 @@ const buildStepSchema = z.discriminatedUnion("step", [
         .object({
         ...stepBase,
         step: z.literal("divine-create-package"),
+        allowOutsideRoot: z.boolean().optional(),
         from: z.string(),
         out: z.string(),
     })
@@ -137,6 +140,7 @@ const buildStepSchema = z.discriminatedUnion("step", [
         .object({
         ...stepBase,
         step: z.literal("exec"),
+        allowOutsideRoot: z.boolean().optional(),
         command: z.string(),
         args: z.array(z.string()).default([]),
         cwd: z.string().optional(),
@@ -166,6 +170,7 @@ const deployTargetSchema = z
     .object({
     rootId: z.string().min(1),
     from: z.string().min(1),
+    allowOutsideRoot: z.boolean().optional(),
     into: z.string().optional(),
     waitForGameExit: z.boolean().optional(),
     backup: z.boolean().optional(),
@@ -179,6 +184,7 @@ const deployTargetSchema = z
 const junctionSchema = z
     .object({
     linkPath: z.string().min(1),
+    allowOutsideRoot: z.boolean().optional(),
     rootId: z.string().min(1),
     target: z.string().min(1),
 })
@@ -240,6 +246,37 @@ export const modProjectSchema = z
     testPlans: z.array(z.string().min(1)).optional(),
 })
     .strict();
+function checkVariantGates(doc, ctx) {
+    const build = doc.build;
+    if (!build?.steps)
+        return;
+    const known = Object.keys(build.variants ?? {});
+    const knownText = known.length > 0 ? `declared build.variants: ${known.join(", ")}` : "build.variants declares none";
+    build.steps.forEach((step, i) => {
+        if (typeof step === "string")
+            return;
+        const label = step.id ? `"${step.id}"` : `#${i} (${step.step})`;
+        if (step.variant !== undefined && !known.includes(step.variant)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["build", "steps", i, "variant"],
+                message: `step ${label} is gated on variant "${step.variant}", which no build.variants entry declares (${knownText}); it could never run`,
+            });
+        }
+        if (step.step !== "stage")
+            return;
+        step.sources.forEach((entry, j) => {
+            if (typeof entry === "string" || entry.variant === undefined || known.includes(entry.variant))
+                return;
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["build", "steps", i, "sources", j, "variant"],
+                message: `stage step ${label} source entry "${entry.source ?? entry.output}" is gated on variant "${entry.variant}", which no build.variants entry declares (${knownText}); it could never be staged`,
+            });
+        });
+    });
+}
+const modProjectSchemaChecked = modProjectSchema.superRefine((doc, ctx) => checkVariantGates(doc, ctx));
 function formatPath(segments) {
     if (segments.length === 0)
         return "(root)";
@@ -255,7 +292,7 @@ function formatPath(segments) {
     return out;
 }
 export function parseProject(json) {
-    const result = modProjectSchema.safeParse(json);
+    const result = modProjectSchemaChecked.safeParse(json);
     if (!result.success) {
         const lines = result.error.issues.map((issue) => `${formatPath(issue.path)}: ${issue.message}`);
         throw new Error(`Invalid modwright.json:\n${lines.join("\n")}`);

package/dist/core/safety/backup.js

@@ -113,7 +113,7 @@ export class ManifestWriter {
     async addFile(originalAbsPath) {
         const dest = backupDestFor(this.backupDir, originalAbsPath);
         await copyFilePreservingMtime(originalAbsPath, dest);
-        const { sha256, sizeBytes } = await sha256File(originalAbsPath);
+        const { sha256, sizeBytes } = await sha256File(dest);
         const backupPath = path.relative(this.backupDir, dest).split(path.sep).join("/");
         this.entries.push({ originalPath: originalAbsPath, backupPath, sizeBytes, sha256 });
     }
@@ -159,7 +159,7 @@ export class ManifestWriter {
     }
     async flush(now) {
         const manifest = { purpose: this.purpose, time: now.toISOString(), entries: this.entries };
-        await fs.writeFile(path.join(this.backupDir, MANIFEST_FILE), JSON.stringify(manifest, null, 2), "utf8");
+        await writeFileAtomic(path.join(this.backupDir, MANIFEST_FILE), JSON.stringify(manifest, null, 2));
     }
 }
 export async function readManifest(backupDir) {

package/dist/core/safety/execute.js

@@ -1,6 +1,5 @@
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
-import { pathExists } from "../fsutil.js";
 import { userDataDir } from "../home.js";
 import { normalizePlan } from "./plan.js";
 import { isLockError } from "./restore.js";
@@ -41,7 +40,7 @@ async function applyOp(nop, ensureBackup) {
             if (nop.skipEligible)
                 return { op, status: "skipped" };
             let backedUpTo;
-            if (await pathExists(op.to)) {
+            if (await lstatExists(op.to)) {
                 backedUpTo = await (await ensureBackup()).addPath(op.to);
             }
             await copyTreePreservingMtime(op.from, op.to);
@@ -157,8 +156,14 @@ export async function executePlan(plan, options) {
             results.push({ op, status: "failed", error: errorMessage(err) });
         }
     }
+    let manifestError;
     if (manifestWriter?.hasEntries) {
-        await manifestWriter.flush(now());
+        try {
+            await manifestWriter.flush(now());
+        }
+        catch (err) {
+            manifestError = errorMessage(err);
+        }
     }
     else if (backupDir) {
         await fs.rm(backupDir, { recursive: true, force: true }).catch(() => { });
@@ -183,6 +188,9 @@ export async function executePlan(plan, options) {
         operations: results,
         backupDir,
         confidence: options.confidence,
-        next,
+        next: manifestError
+            ? `The operations above ran, but the backup's manifest could not be written (${manifestError}). The replaced files are under ${backupDir}; rollback cannot restore them without a manifest.${next ? ` ${next}` : ""}`
+            : next,
+        ...(manifestError ? { manifestError } : {}),
     };
 }