modwright 0.1.0

package/dist/core/deploy/reload.js

@@ -0,0 +1,358 @@
+import * as path from "node:path";
+import { promises as fs } from "node:fs";
+import { globToRegExp } from "../validate/index.js";
+const CP2077_TABLE = [
+    {
+        match: "r6/tweaks/**",
+        action: "hot",
+        via: 'TweakXL.Reload() via cp2077.lua.eval (verified to re-apply a changed flat)',
+        caveat: "The .hot-tweaks sentinel is consumed by RHT but did NOT drive a reload in RHT 1.3.0.33690 (verified fact " +
+            "hot-tweaks-consumed-without-reload-1.3.0), so the reliable path is TweakXL.Reload() through the bridge. " +
+            "Reload adds and changes records but does not unload a record whose file was removed (verified fact " +
+            "reload-does-not-unload-removed-records): after deleting a tweak file the record stays in TweakDB until restart. " +
+            "Read-back: a cp2077.tweakdb.flat probe on the changed flat (TweakXL.log's \"Import completed.\" line after the reload corroborates).",
+    },
+    {
+        match: "r6/scripts/**",
+        action: "hot",
+        via: "the .hot-scripts sentinel (RHT ScriptWatcher deletes it and runs ScriptLoader::ReloadScripts())",
+        caveat: "Diff-aware: downgrades to save-reload when the diff adds a ScriptableSystem request handler, adds a struct field or " +
+            "retypes one — struct fields are not reinitialised and a new handler needs a session reload. deploy runs the scc precheck first; " +
+            "a compile error surfaces as an RHT message box on the game window. Read-back: a cp2077.lua.eval of <Mod>Dev.BuildStamp(). " +
+            "Without Red Hot Tools present and watching this launch, a .reds is inert until a restart (redscript compiles at launch).",
+    },
+    {
+        match: "archive/pc/mod/*.archive",
+        action: "hot",
+        via: "the archive/pc/hot folder (RHT ArchiveWatcher unloads, moves it into archive/pc/mod, reloads, invalidates the cache, calls ArchiveXL.Reload())",
+        caveat: "Non-mesh archives only: an archive carrying a mounted mesh stays cold and needs a restart (knowledge fact " +
+            "cp2077.process.assetbuild.rht-hot-folder-banned-for-whole-mesh-archives). Already-spawned instances keep the old resource — pair " +
+            "with a despawn/respawn or unequip/re-equip. Read-back: \"Archives reload completed\" in RedHotTools.log. " +
+            "Without Red Hot Tools present and watching this launch, the .archive is locked while the game runs; restart.",
+    },
+    {
+        match: "archive/pc/mod/*.xl",
+        action: "hot",
+        via: 'ArchiveXL.Reload() via cp2077.lua.eval, or the RHT overlay "Reload extensions"',
+        caveat: "Read-back: ArchiveXL.log's discovery lines. An .archive dropped alongside already reloads extensions; this row is the .xl-only case.",
+    },
+    {
+        match: "bin/x64/plugins/cyber_engine_tweaks/mods/**",
+        action: "hot",
+        via: 'the CET overlay\'s "Reload all mods" button',
+        caveat: "Manual: CET's registered globals have no reload entry and there is no autoexec (verified negative in CET source), so this cannot " +
+            "be triggered from a file. For the mod's own dev loop, scaffold a dofile-based module reload, kept author-only.",
+    },
+    {
+        match: "red4ext/plugins/**",
+        action: "restart",
+        caveat: "Version-locked to the game build; no hot path.",
+    },
+    {
+        match: "r6/input/**",
+        action: "restart",
+        caveat: "Input Loader merges its XML into the input contexts at launch; no reload path is known.",
+    },
+];
+const BG3_TABLE = [
+    {
+        match: "Mods/*/ScriptExtender/Lua/**",
+        action: "hot",
+        via: "Ext.Debug.Reset(true, false) via bg3.lua.eval (needs DeveloperMode), which fires ResetCompleted",
+        caveat: "Hot only when the SE Lua is loose under Data/Mods/<Folder> (the wiki's reset scope); Lua that ships only inside the pak needs a " +
+            "restart until a hot-overrides layer has mirrored it loose, because the pak is locked for the process lifetime. Reset " +
+            "reloads the Lua state but may degrade Osiris; a save reload is the clean fix. Read-back: the bridge's " +
+            "ResetCompleted handler increments resetCount in the heartbeat.",
+    },
+    {
+        match: "Public/*/Stats/Generated/**",
+        action: "restart",
+        via: "Ext.Stats.Get(name):SetRawAttribute(...):Sync() per changed entry (session-mirrored)",
+        caveat: "No API reloads the .txt from disk. Until a stats mirror sends the equivalent Ext.Stats sync through bg3.lua.eval, restart. " +
+            "A functor-only change stays unknown until tested in game (StatsFunctors unsupported as of v29). The file still ships in the next pak.",
+    },
+    {
+        match: "Public/*/RootTemplates/**",
+        action: "restart",
+        caveat: "RootTemplates are read at session load only (no runtime bank reload); a restart is needed for existing and new instances alike.",
+    },
+    {
+        match: "**/*.lsx",
+        action: "save-reload",
+        caveat: "Progressions/ClassDescriptions changes apply to newly created instances; existing saves keep old data. Ext.StaticData.SyncResourceBank " +
+            "exists but its live effect is unverified (restart until it is tested in game). A respec makes that test cheap.",
+    },
+    { match: "**/*.pak", action: "restart", caveat: "Locked for the process lifetime, at the menu and after deactivation (verified 2026-09-13); a full exit is the only release." },
+    { match: "Mods/*/Localization/**", action: "restart", caveat: ".loca is read at load." },
+];
+const STARDEW_TABLE = [
+    {
+        match: "Mods/**/manifest.json",
+        action: "restart",
+        caveat: "SMAPI reads every manifest once at launch (ModScanner); a new, renamed or re-versioned mod is not seen until then.",
+    },
+    {
+        match: "Mods/**/config.json",
+        action: "restart",
+        caveat: "A mod's config.json is read when the mod loads; the player guide says to edit it with the game closed 'or your changes might not take effect'. A Content Patcher pack's config values are tokens, and `patch reload` does not reload config schema.",
+    },
+    {
+        match: "Mods/**/*.dll",
+        action: "restart",
+        caveat: "A loaded assembly cannot be replaced; SMAPI loads C# mods once at launch.",
+    },
+    {
+        match: "Mods/**/i18n/*.json",
+        action: "hot",
+        via: "reload_i18n in the SMAPI console",
+        caveat: "SMAPI's own command: \"Reload translation files for all mods\", with the wiki's own note that if a mod caches the text \"it may show the old version until it updates\".",
+    },
+    {
+        match: "Mods/**/content.json",
+        action: "hot",
+        via: 'patch reload "<pack id>" in the SMAPI console',
+        caveat: "Content Patcher's command re-reads the pack's patches; its own guide says non-patch content like ConfigSchema and DynamicTokens is not reloaded, so a change to those is a restart. ModWright never sends the command.",
+    },
+    {
+        match: "Mods/**/assets/**",
+        action: "hot",
+        via: 'patch reload "<pack id>" in the SMAPI console',
+        caveat: "The files a pack's patches load; the reload re-applies the patches that name them. A file no patch names yet needs its patch first, and an asset a C# mod loads for itself is that mod's business, so restart to be sure.",
+    },
+    {
+        match: "Mods/**/*.json",
+        action: "hot",
+        via: 'patch reload "<pack id>" in the SMAPI console',
+        caveat: "Only for a JSON file a Content Patcher pack includes (an Include patch's FromFile); a JSON a C# mod reads for itself is that mod's business, so restart to be sure.",
+    },
+];
+const SURFACE_TABLES = {
+    cyberpunk2077: CP2077_TABLE,
+    baldursgate3: BG3_TABLE,
+    stardewvalley: STARDEW_TABLE,
+};
+const RED_HOT_TOOLS_SURFACE = "cyberpunk2077";
+const RHT_DEPENDENT_ROWS = new Set(["archive/pc/mod/*.archive", "r6/scripts/**"]);
+const RANK = {
+    hot: 0,
+    "hot-degraded": 1,
+    "save-reload": 2,
+    restart: 3,
+};
+const UNKNOWN_NOTE = "not classified — restart to be sure";
+function toPosix(p) {
+    return p.split(path.sep).join("/");
+}
+function matchesPath(glob, absPath) {
+    const re = globToRegExp(glob);
+    const segments = toPosix(absPath).split("/").filter((s) => s.length > 0);
+    for (let i = 0; i < segments.length; i++) {
+        if (re.test(segments.slice(i).join("/")))
+            return true;
+    }
+    return false;
+}
+function firstMatch(rules, absPath) {
+    return rules.find((rule) => matchesPath(rule.match, absPath));
+}
+export function redHotToolsDir(install) {
+    return path.join(install.root, "red4ext", "plugins", "RedHotTools");
+}
+export const ARCHIVE_WATCHER_LINE = "[ArchiveWatcher] Watching";
+export const REAL_FS_FOR_APPLY = {
+    pathExists: async (p) => {
+        try {
+            await fs.access(p);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    readDir: (p) => fs.readdir(p),
+    readFile: (p) => fs.readFile(p, "utf8"),
+    mtimeMs: async (p) => (await fs.stat(p)).mtimeMs,
+};
+const REAL_FS = REAL_FS_FOR_APPLY;
+export async function detectRedHotTools(install, compat, deps = REAL_FS) {
+    const version = compat?.components.find((c) => c.id === "redhottools")?.version;
+    if (!install) {
+        return { present: false, watching: false, hotAvailable: false, version, reason: "no install was supplied, so Red Hot Tools presence could not be checked" };
+    }
+    const dir = redHotToolsDir(install);
+    const dllPath = path.join(dir, "RedHotTools.dll");
+    const present = await deps.pathExists(dllPath);
+    if (!present) {
+        return { present: false, watching: false, hotAvailable: false, version, dllPath, reason: `Red Hot Tools is not installed (${dllPath} not found)` };
+    }
+    let logPath;
+    try {
+        const entries = (await deps.readDir(dir)).filter((n) => /^RedHotTools.*\.log$/i.test(n));
+        let newestMtime = -1;
+        for (const name of entries) {
+            const full = path.join(dir, name);
+            const m = await deps.mtimeMs(full).catch(() => -1);
+            if (m > newestMtime) {
+                newestMtime = m;
+                logPath = full;
+            }
+        }
+    }
+    catch {
+    }
+    if (!logPath) {
+        return { present: true, watching: false, hotAvailable: false, version, dllPath, reason: "Red Hot Tools is installed but no RedHotTools*.log was found — launch the game once so the ArchiveWatcher arms" };
+    }
+    const log = await deps.readFile(logPath).catch(() => "");
+    const watching = log.includes(ARCHIVE_WATCHER_LINE);
+    return {
+        present: true,
+        watching,
+        hotAvailable: watching,
+        version,
+        dllPath,
+        logPath,
+        reason: watching
+            ? `Red Hot Tools ${version ?? "(version unknown)"} is installed and the ArchiveWatcher is watching (newest log ${path.basename(logPath)})`
+            : `Red Hot Tools is installed but the newest log (${path.basename(logPath)}) has no "${ARCHIVE_WATCHER_LINE}" line — the watcher is not armed this launch`,
+    };
+}
+export function redscriptChangeAction(before, after) {
+    if (before === undefined) {
+        return { action: "hot", reason: "a newly added script has no prior version to diff; the reload rebinds it" };
+    }
+    const addsRequestHandler = hasNewRequestHandler(before, after);
+    if (addsRequestHandler) {
+        return { action: "save-reload", reason: "the diff adds a ScriptableSystem request handler, which is not registered on a script reload (needs a session reload)" };
+    }
+    const structField = addsOrRetypesStructField(before, after);
+    if (structField) {
+        return { action: "save-reload", reason: structField };
+    }
+    return { action: "hot", reason: "no struct-field or request-handler change; the reload rebinds value-holder props of unchanged type" };
+}
+function hasNewRequestHandler(before, after) {
+    const re = /func\s+On[A-Za-z0-9_]*\s*\([^)]*:\s*ref<[A-Za-z0-9_]*Request>\s*\)/g;
+    const beforeSet = new Set(before.match(re) ?? []);
+    for (const m of after.match(re) ?? []) {
+        if (!beforeSet.has(m))
+            return true;
+    }
+    return false;
+}
+function addsOrRetypesStructField(before, after) {
+    const beforeStructs = structFields(before);
+    const afterStructs = structFields(after);
+    for (const [name, afterFields] of afterStructs) {
+        const beforeFields = beforeStructs.get(name);
+        if (!beforeFields)
+            continue;
+        for (const [field, type] of afterFields) {
+            const prev = beforeFields.get(field);
+            if (prev === undefined)
+                return `the diff adds field "${field}" to struct ${name}; struct fields are not reinitialised on a script reload`;
+            if (prev !== type)
+                return `the diff retypes field "${field}" of struct ${name} (${prev} -> ${type}); a live instance would carry the old layout`;
+        }
+    }
+    return undefined;
+}
+function structFields(text) {
+    const out = new Map();
+    const structRe = /struct\s+([A-Za-z0-9_]+)\s*\{([^}]*)\}/g;
+    let m;
+    while ((m = structRe.exec(text)) !== null) {
+        const name = m[1];
+        const body = m[2];
+        const fields = new Map();
+        const fieldRe = /let\s+([A-Za-z0-9_]+)\s*:\s*([^;=]+)\s*[;=]/g;
+        let f;
+        while ((f = fieldRe.exec(body)) !== null) {
+            fields.set(f[1], f[2].trim());
+        }
+        out.set(name, fields);
+    }
+    return out;
+}
+export function classifyReload(surfaceId, project, writtenPaths, options = {}) {
+    const projectRules = project.reload?.rules ?? [];
+    const table = SURFACE_TABLES[surfaceId];
+    const rht = options.redHotTools;
+    const scriptDiffs = options.scriptDiffs ?? {};
+    const classifications = writtenPaths.map((p) => {
+        const projectRule = firstMatch(projectRules, p);
+        if (projectRule) {
+            return {
+                path: p,
+                action: projectRule.action,
+                via: projectRule.via,
+                caveat: projectRule.caveat,
+                source: "project-rule",
+                matched: projectRule.match,
+            };
+        }
+        const row = table ? firstMatch(table, p) : undefined;
+        if (!row) {
+            return { path: p, action: "unknown", caveat: UNKNOWN_NOTE, source: "unmatched" };
+        }
+        if (surfaceId === RED_HOT_TOOLS_SURFACE && RHT_DEPENDENT_ROWS.has(row.match) && !rht?.hotAvailable) {
+            return {
+                path: p,
+                action: "restart",
+                via: undefined,
+                caveat: `${row.caveat ?? ""} Red Hot Tools' hot path is unavailable (${rht?.reason ?? "no presence check was run"}), so this needs a restart.`.trim(),
+                source: "red-hot-tools",
+                matched: row.match,
+            };
+        }
+        if (surfaceId === RED_HOT_TOOLS_SURFACE && row.match === "r6/scripts/**" && scriptDiffs[p] && scriptDiffs[p] !== "hot") {
+            return {
+                path: p,
+                action: scriptDiffs[p],
+                via: undefined,
+                caveat: `${row.caveat ?? ""} This diff cannot hot-reload cleanly, so it is downgraded to ${scriptDiffs[p]}.`.trim(),
+                source: "red-hot-tools",
+                matched: row.match,
+            };
+        }
+        return { path: p, action: row.action, via: row.via, caveat: row.caveat, source: "surface-table", matched: row.match };
+    });
+    const groups = [];
+    for (const c of classifications) {
+        const existing = groups.find((g) => g.action === c.action && g.via === c.via && g.caveat === c.caveat);
+        if (existing)
+            existing.paths.push(c.path);
+        else
+            groups.push({ action: c.action, via: c.via, caveat: c.caveat, paths: [c.path] });
+    }
+    const unclassified = classifications.filter((c) => c.action === "unknown").map((c) => c.path);
+    const ranked = classifications
+        .filter((c) => c.action !== "unknown")
+        .map((c) => RANK[c.action]);
+    if (unclassified.length > 0)
+        ranked.push(RANK.restart);
+    const overall = ranked.length === 0
+        ? "unknown"
+        : Object.keys(RANK).find((a) => RANK[a] === Math.max(...ranked));
+    const notes = [];
+    if (writtenPaths.length === 0) {
+        notes.push("nothing was written, so there is nothing to reload");
+    }
+    else if (!table && projectRules.length === 0) {
+        notes.push(`no reload table exists for "${surfaceId}" and the project declares no reload.rules — every path is ${UNKNOWN_NOTE}`);
+    }
+    if (unclassified.length > 0) {
+        notes.push(`${unclassified.length} path(s) ${UNKNOWN_NOTE}`);
+    }
+    if (rht)
+        notes.push(rht.reason);
+    notes.push("The never-launch / never-reload rule is retired in favour of the capability policy; a hot reload is confirmed by its read-back, not assumed.");
+    return {
+        overall,
+        groups,
+        unclassified,
+        classifications,
+        note: notes.join(". "),
+        redHotTools: rht ?? (surfaceId === RED_HOT_TOOLS_SURFACE ? { present: false, watching: false, hotAvailable: false, reason: "no Red Hot Tools presence check was run", version: options.compat?.components.find((c) => c.id === "redhottools")?.version } : undefined),
+    };
+}

package/dist/core/deploy/sources.js

@@ -0,0 +1,169 @@
+import * as path from "node:path";
+import { pathExists } from "../fsutil.js";
+import { normalizeBuildSteps } from "../project/build-steps.js";
+import { resolveOutDirPath, resolveSourceOrStagePath, stageStepOutputDir } from "../build/paths.js";
+import { looksLikePath } from "../build/steps/core.js";
+import { normalizeForCompare } from "./guards.js";
+const PACK_STEPS = new Set(["wolvenkit-pack", "divine-create-package", "zip"]);
+function isWithin(parent, child) {
+    const rel = path.relative(normalizeForCompare(parent), normalizeForCompare(child));
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+function same(a, b) {
+    return normalizeForCompare(a) === normalizeForCompare(b);
+}
+function stepLabel(step, index) {
+    return step.id ? `${step.step} (${step.id})` : `${step.step}#${index}`;
+}
+function allSteps(project) {
+    let steps;
+    try {
+        steps = normalizeBuildSteps(project.project);
+    }
+    catch {
+        return [];
+    }
+    const variants = Object.values(project.project.build?.variants ?? {});
+    const addSources = variants.flatMap((v) => v.addSources ?? []);
+    if (addSources.length > 0) {
+        steps = steps.map((s) => (s.step === "stage" ? { ...s, sources: [...s.sources, ...addSources] } : s));
+    }
+    return [...steps, ...variants.flatMap((v) => v.addSteps ?? [])];
+}
+async function execInputs(step, outputs, ctx) {
+    if (step.inputs && step.inputs.length > 0)
+        return step.inputs.map((p) => resolveSourceOrStagePath(p, ctx));
+    const found = [];
+    for (const raw of step.args) {
+        if (!looksLikePath(raw))
+            continue;
+        const abs = resolveSourceOrStagePath(raw, ctx);
+        if (!isWithin(ctx.projectRoot, abs))
+            continue;
+        if (outputs.some((o) => isWithin(abs, o)))
+            continue;
+        if (!raw.includes("${stage}") && !(await pathExists(abs)))
+            continue;
+        found.push(abs);
+    }
+    return found;
+}
+function stageInputs(sources, project, ctx) {
+    const out = [];
+    for (const entry of sources) {
+        if (typeof entry !== "string" && entry.output !== undefined) {
+            out.push(resolveOutDirPath(entry.output, ctx));
+            continue;
+        }
+        const id = typeof entry === "string" ? entry : entry.source;
+        const source = project.sources.find((s) => s.id === id);
+        if (source)
+            out.push(source.absPath);
+    }
+    return out;
+}
+export async function buildSourceGraph(project, outDirAbs) {
+    const stageRoot = path.join(project.root, ".modwright", "cache", "build", "<deploy-trace>");
+    const ctx = {
+        projectRoot: project.root,
+        stageRoot,
+        outDirAbs: outDirAbs ?? project.build?.absOutDir ?? project.root,
+        version: project.project.version ?? "0.0.0",
+    };
+    const nodes = [];
+    const steps = allSteps(project);
+    for (let index = 0; index < steps.length; index++) {
+        const step = steps[index];
+        const label = stepLabel(step, index);
+        let outputs = [];
+        let inputs = [];
+        switch (step.step) {
+            case "stage":
+                outputs = [stageStepOutputDir(stageRoot, step.id ?? `stage-${index}`, step.into)];
+                inputs = stageInputs(step.sources, project, ctx);
+                break;
+            case "wolvenkit-pack":
+            case "divine-create-package":
+                outputs = [resolveOutDirPath(step.out, ctx)];
+                inputs = [resolveSourceOrStagePath(step.from, ctx)];
+                break;
+            case "zip":
+                outputs = [resolveOutDirPath(step.name, ctx)];
+                inputs = [resolveSourceOrStagePath(step.from, ctx)];
+                break;
+            case "blender-export":
+                outputs = [resolveSourceOrStagePath(step.out, ctx)];
+                inputs = [resolveSourceOrStagePath(step.blend, ctx), resolveSourceOrStagePath(step.script, ctx)];
+                break;
+            case "wolvenkit-import":
+                outputs = [resolveSourceOrStagePath(step.outDir, ctx)];
+                inputs = [resolveSourceOrStagePath(step.glb, ctx), resolveSourceOrStagePath(step.base, ctx)];
+                break;
+            case "exec":
+                outputs = step.expectOutputs.map((p) => resolveSourceOrStagePath(p, ctx));
+                inputs = await execInputs(step, outputs, ctx);
+                break;
+            default:
+                continue;
+        }
+        nodes.push({ label, kind: step.step, outputs, inputs });
+    }
+    return { project, stageRoot, nodes };
+}
+function trace(graph, producers) {
+    const leaves = new Map();
+    const visited = new Set(producers);
+    const queue = [...producers];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        for (const input of node.inputs) {
+            if (!isWithin(graph.stageRoot, input))
+                leaves.set(normalizeForCompare(input), input);
+            for (const other of graph.nodes) {
+                if (visited.has(other))
+                    continue;
+                if (other.outputs.some((o) => same(o, input) || isWithin(input, o) || isWithin(o, input))) {
+                    visited.add(other);
+                    queue.push(other);
+                }
+            }
+        }
+    }
+    return [...leaves.values()];
+}
+function projectSources(project) {
+    return project.sources.filter((s) => s.exists).map((s) => s.absPath);
+}
+export function artifactSources(graph, builtArtifact, options = {}) {
+    if (options.fromSourcePath) {
+        return { paths: [options.fromSourcePath], via: "the project source it deploys", known: true };
+    }
+    const producers = graph.nodes.filter((n) => n.outputs.some((o) => same(o, builtArtifact) || isWithin(o, builtArtifact)));
+    if (producers.length > 0) {
+        const labels = producers.map((p) => p.label).join(", ");
+        const leaves = trace(graph, producers);
+        if (leaves.length > 0) {
+            return { paths: leaves, via: `the inputs of the build step that produces it (${labels})`, known: true };
+        }
+        if (producers.some((p) => PACK_STEPS.has(p.kind))) {
+            return { paths: projectSources(graph.project), via: `the project's own sources (${labels} packs them; no narrower input traced)`, known: true };
+        }
+        return { paths: [], via: `nothing traceable: ${labels} declares no input inside the project`, known: false };
+    }
+    const recorded = options.recorded;
+    if (recorded) {
+        const label = recorded.id ? `${recorded.step} (${recorded.id})` : recorded.step;
+        if (recorded.inputs.length > 0) {
+            return { paths: [...new Set(recorded.inputs)], via: `the inputs the build manifest records for ${label}`, known: true };
+        }
+        if (PACK_STEPS.has(recorded.step)) {
+            return { paths: projectSources(graph.project), via: `the project's own sources (${label} packs them)`, known: true };
+        }
+        return { paths: [], via: `nothing traceable: the build manifest records no input for ${label}`, known: false };
+    }
+    const container = graph.project.sources.find((s) => s.exists && isWithin(s.absPath, builtArtifact));
+    if (container) {
+        return { paths: [container.absPath], via: `the project source that contains it (${container.id})`, known: true };
+    }
+    return { paths: [], via: "nothing traceable: no declared build step produces it", known: false };
+}

package/dist/core/deploy/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/epic.js

@@ -0,0 +1,54 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { pathExists } from "./fsutil.js";
+import { readRegistryValue } from "./registry.js";
+export const EPIC_LAUNCHER_REGISTRY_KEYS = [String.raw `HKLM\Software\Epic Games\EpicGamesLauncher`, String.raw `HKLM\Software\WOW6432Node\Epic Games\EpicGamesLauncher`];
+export const EPIC_LAUNCHER_REGISTRY_VALUE = "AppDataPath";
+export async function epicManifestsDir() {
+    const override = process.env.MODWRIGHT_EPIC_MANIFESTS;
+    if (override && (await pathExists(override)))
+        return override;
+    const fromRegistry = await readRegistryValue(EPIC_LAUNCHER_REGISTRY_KEYS, EPIC_LAUNCHER_REGISTRY_VALUE);
+    if (fromRegistry?.value)
+        return path.join(fromRegistry.value, "Manifests");
+    const programData = process.env.ProgramData ?? process.env.PROGRAMDATA;
+    if (!programData)
+        return undefined;
+    return path.join(programData, "Epic", "EpicGamesLauncher", "Data", "Manifests");
+}
+export async function readEpicManifests(dir) {
+    let names;
+    try {
+        names = (await fs.readdir(dir)).filter((n) => n.toLowerCase().endsWith(".item")).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        const file = path.join(dir, name);
+        try {
+            const doc = JSON.parse(await fs.readFile(file, "utf8"));
+            if (typeof doc.AppName !== "string" || typeof doc.InstallLocation !== "string")
+                continue;
+            out.push({ file, appName: doc.AppName, installLocation: doc.InstallLocation, ...(typeof doc.DisplayName === "string" ? { displayName: doc.DisplayName } : {}) });
+        }
+        catch {
+        }
+    }
+    return out;
+}
+export async function findInEpic(appNames, dir) {
+    const manifestsDir = dir ?? (await epicManifestsDir());
+    if (!manifestsDir || !(await pathExists(manifestsDir)))
+        return [];
+    const wanted = new Set(appNames.map((a) => a.toLowerCase()));
+    const roots = [];
+    for (const m of await readEpicManifests(manifestsDir)) {
+        if (!m.installLocation)
+            continue;
+        if (wanted.has(m.appName.toLowerCase()) && !roots.includes(m.installLocation))
+            roots.push(m.installLocation);
+    }
+    return roots;
+}