modwright 0.1.0

package/dist/core/steam.js

@@ -0,0 +1,63 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { firstExisting, pathExists, readTextIfExists } from "./fsutil.js";
+export function steamRootCandidates(platform = process.platform, env = process.env, home = os.homedir()) {
+    if (platform === "win32") {
+        return [
+            "C:/Program Files (x86)/Steam",
+            "C:/Program Files/Steam",
+            ...(env.LOCALAPPDATA ? [path.win32.join(env.LOCALAPPDATA, "..", "Steam")] : []),
+        ];
+    }
+    if (!home)
+        return [];
+    if (platform === "darwin")
+        return [path.posix.join(home, "Library", "Application Support", "Steam")];
+    return [
+        path.posix.join(home, ".steam", "steam"),
+        path.posix.join(home, ".local", "share", "Steam"),
+        path.posix.join(home, ".var", "app", "com.valvesoftware.Steam", ".local", "share", "Steam"),
+    ];
+}
+export async function findSteamRoot() {
+    if (process.env.MODWRIGHT_STEAM_ROOT) {
+        const override = process.env.MODWRIGHT_STEAM_ROOT;
+        if (await pathExists(override))
+            return override;
+    }
+    return firstExisting(steamRootCandidates());
+}
+export async function steamLibraries() {
+    const root = await findSteamRoot();
+    if (!root)
+        return [];
+    const libraries = new Map();
+    const add = (dir) => {
+        const common = path.join(dir, "steamapps", "common");
+        const key = process.platform === "win32" ? path.resolve(common).toLowerCase() : path.resolve(common);
+        if (!libraries.has(key))
+            libraries.set(key, common);
+    };
+    add(root);
+    const vdf = await readTextIfExists(path.join(root, "steamapps", "libraryfolders.vdf"));
+    if (vdf) {
+        for (const match of vdf.matchAll(/"path"\s+"([^"]+)"/g)) {
+            const raw = match[1];
+            if (!raw)
+                continue;
+            add(raw.replace(/\\\\/g, "\\"));
+        }
+    }
+    return [...libraries.values()];
+}
+export async function findInSteam(folderNames) {
+    const found = [];
+    for (const library of await steamLibraries()) {
+        for (const name of folderNames) {
+            const candidate = path.join(library, name);
+            if (await pathExists(candidate))
+                found.push(candidate);
+        }
+    }
+    return found;
+}

package/dist/core/surfaceutil.js

@@ -0,0 +1,36 @@
+import { pathExists, resolveCandidate } from "./fsutil.js";
+export function roots(specs) {
+    return specs.map((spec) => ({ ...spec, exists: false }));
+}
+export function logs(specs) {
+    return specs.map((spec) => {
+        const candidates = [...(spec.path ? [spec.path] : []), ...(spec.candidates ?? [])];
+        const { path: _path, candidates: _candidates, ...rest } = spec;
+        return { ...rest, path: candidates[0] ?? "", candidates, exists: false };
+    });
+}
+export async function resolveRoots(surface, install) {
+    return Promise.all(surface.modRoots(install).map(async (root) => ({
+        ...root,
+        exists: await pathExists(root.path),
+    })));
+}
+export async function resolveLogs(surface, install) {
+    const declared = surface.logs?.(install) ?? [];
+    return Promise.all(declared.map(async (log) => {
+        const hit = await resolveCandidate(log.candidates);
+        return hit
+            ? { ...log, path: hit.path, resolvedFrom: hit.candidate, exists: true }
+            : { ...log, exists: false };
+    }));
+}
+export function dedupeByRoot(installs) {
+    const seen = new Set();
+    return installs.filter((install) => {
+        const key = install.root.toLowerCase();
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/core/testplan/check.js

@@ -0,0 +1,67 @@
+import { lookupProbe } from "./registry.js";
+export function checkRowProbes(row, game, lookup = lookupProbe) {
+    const toCheck = [...(row.setup ?? []), ...(row.probe?.probes ?? [])];
+    if (toCheck.length === 0)
+        return [];
+    const refusals = [];
+    for (const probe of toCheck) {
+        const entry = lookup(probe.kind);
+        if (!entry) {
+            refusals.push({
+                probeId: probe.id,
+                kind: probe.kind,
+                reason: `unknown probe kind "${probe.kind}" — not in ModWright's probe catalogue; the row is refused rather than run against something no bridge implements.`,
+            });
+            continue;
+        }
+        if (entry.game !== game) {
+            refusals.push({
+                probeId: probe.id,
+                kind: probe.kind,
+                reason: `probe "${probe.kind}" is a ${entry.game} probe, but this plan's game is ${game}.`,
+            });
+            continue;
+        }
+        if (entry.status === "contradicted") {
+            refusals.push({
+                probeId: probe.id,
+                kind: probe.kind,
+                reason: `probe "${probe.kind}" is marked contradicted in the catalogue and is refused rather than run.`,
+            });
+            continue;
+        }
+        if (probe.effect !== entry.effect) {
+            refusals.push({
+                probeId: probe.id,
+                kind: probe.kind,
+                reason: `probe "${probe.kind}" is an effect "${entry.effect}" kind in the catalogue but the row sends it as "${probe.effect}"; the effect is the catalogue's to choose, and a mutate kind sent as a read would bypass the bridge's allowMutate gate.`,
+            });
+            continue;
+        }
+        const parsed = entry.paramsSchema.safeParse(probe.params);
+        if (!parsed.success) {
+            refusals.push({
+                probeId: probe.id,
+                kind: probe.kind,
+                reason: `params for "${probe.kind}" do not match its catalogue schema: ${parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`,
+            });
+        }
+    }
+    return refusals;
+}
+export function worstAttestation(kinds, lookup = lookupProbe) {
+    let worst;
+    for (const kind of kinds) {
+        const entry = lookup(kind);
+        if (!entry)
+            continue;
+        if (entry.status === "unverified")
+            worst = "unverified";
+        else if (worst === undefined)
+            worst = entry.status;
+    }
+    return worst;
+}
+export function rowProbeKinds(row) {
+    return row.probe?.probes.map((p) => p.kind) ?? [];
+}

package/dist/core/testplan/index.js

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export { PROBE_ATTESTATIONS, PROBE_CATALOG, lookupProbe, probesForGame } from "./registry.js";
+export { checkRowProbes, rowProbeKinds, worstAttestation } from "./check.js";
+export { DEFAULT_TEST_PLAN_GLOBS, loadTestPlanFile, loadTestPlans, resolveTestPlan, resolveTestPlanFiles, saveTestPlan, } from "./load.js";
+export { runTestPlan } from "./run.js";

package/dist/core/testplan/load.js

@@ -0,0 +1,100 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { globToRegExp } from "../validate/index.js";
+import { pathExists } from "../fsutil.js";
+import { executePlan, planFile } from "../safety/index.js";
+import { stringifyPreserving } from "../yamledit.js";
+import { parseTestPlan } from "./types.js";
+export const DEFAULT_TEST_PLAN_GLOBS = ["tests/*.yaml"];
+function toPosix(p) {
+    return p.split(path.sep).join("/");
+}
+async function expandGlob(root, pattern) {
+    const posix = toPosix(pattern);
+    const slash = posix.lastIndexOf("/");
+    const dirPart = slash === -1 ? "" : posix.slice(0, slash);
+    const filePart = slash === -1 ? posix : posix.slice(slash + 1);
+    const dirAbs = dirPart ? path.join(root, dirPart) : root;
+    let entries;
+    try {
+        entries = await fs.readdir(dirAbs);
+    }
+    catch {
+        return [];
+    }
+    const re = globToRegExp(filePart);
+    return entries
+        .filter((name) => re.test(name))
+        .sort()
+        .map((name) => path.join(dirAbs, name));
+}
+export async function resolveTestPlanFiles(project) {
+    const globs = project.project.testPlans ?? DEFAULT_TEST_PLAN_GLOBS;
+    const found = [];
+    for (const glob of globs) {
+        found.push(...(await expandGlob(project.root, glob)));
+    }
+    return [...new Set(found)];
+}
+export async function loadTestPlanFile(absPath) {
+    let text;
+    try {
+        text = await fs.readFile(absPath, "utf8");
+    }
+    catch (err) {
+        return { path: absPath, problems: [`${absPath}: cannot read file: ${err.message}`] };
+    }
+    let raw;
+    try {
+        raw = parseYaml(text);
+    }
+    catch (err) {
+        return { path: absPath, problems: [`${absPath}: YAML parse error: ${err.message}`] };
+    }
+    try {
+        return { path: absPath, plan: parseTestPlan(raw), problems: [] };
+    }
+    catch (err) {
+        return { path: absPath, problems: [`${absPath}: ${err.message}`] };
+    }
+}
+export async function loadTestPlans(project) {
+    const files = await resolveTestPlanFiles(project);
+    const plans = [];
+    const problems = [];
+    for (const file of files) {
+        const result = await loadTestPlanFile(file);
+        if (result.plan)
+            plans.push({ path: file, plan: result.plan });
+        problems.push(...result.problems);
+    }
+    return { plans, problems };
+}
+export async function resolveTestPlan(project, planRef) {
+    const candidate = path.isAbsolute(planRef) ? planRef : path.join(project.root, planRef);
+    if (await pathExists(candidate)) {
+        const result = await loadTestPlanFile(candidate);
+        if (result.plan)
+            return { path: candidate, plan: result.plan };
+        throw new Error(result.problems.join("\n"));
+    }
+    const { plans, problems } = await loadTestPlans(project);
+    if (problems.length > 0 && plans.every((p) => p.plan.planId !== planRef)) {
+        throw new Error(`No test plan "${planRef}" loaded, and ${problems.length} plan file(s) had problems:\n${problems.join("\n")}`);
+    }
+    return plans.find((p) => p.plan.planId === planRef);
+}
+export async function saveTestPlan(filePath, plan, options = {}) {
+    const content = stringifyPreserving(await fs.readFile(filePath, "utf8").catch(() => undefined), plan, { lineWidth: 0 });
+    const writePlan = {
+        purpose: `write results back to ${path.basename(filePath)}`,
+        operations: [planFile(filePath, content)],
+        backupRoot: options.backupRoot,
+    };
+    return executePlan(writePlan, {
+        mode: options.mode ?? "dry-run",
+        now: options.now,
+        confidence: { level: "high", assumptions: [], verifiedBy: ["bridge result"] },
+    });
+}

package/dist/core/testplan/registry.js

@@ -0,0 +1,317 @@
+import { z } from "zod";
+export const PROBE_ATTESTATIONS = ["attested", "unverified", "contradicted"];
+const str = () => z.string().min(1);
+const record = () => z.record(z.unknown());
+const BG3_PROBES = [
+    {
+        kind: "bg3.stat.exists",
+        game: "baldursgate3",
+        context: "server",
+        effect: "read",
+        status: "attested",
+        summary: "A stats entry loaded under this name.",
+        citation: "bg3.stat.exists",
+        paramsSchema: z.object({ name: str() }).strict(),
+    },
+    {
+        kind: "bg3.stat.fields",
+        game: "baldursgate3",
+        context: "server",
+        effect: "read",
+        status: "attested",
+        summary: "Named fields match expected raw text.",
+        citation: "bg3.stat.fields",
+        paramsSchema: z.object({ name: str(), fields: z.array(str()).min(1) }).strict(),
+    },
+    {
+        kind: "bg3.template.exists",
+        game: "baldursgate3",
+        context: "server",
+        effect: "read",
+        status: "attested",
+        summary: "A RootTemplate resolves in the engine (Ext.Template.GetTemplate), not just its stats entry.",
+        citation: "bg3.template.exists; attested(engine) 2026-09-10",
+        paramsSchema: z.object({ mapKey: str() }).strict(),
+        evidence: "Verified live at the console (2026-09-10): Ext.Template.GetTemplate(mapKey) — nil for a loose Public/<Mod>/RootTemplates/*.lsx, the full template object once the same node was converted to a sibling .lsf. The bridge handler itself was then exercised the same day (request req-mtvpgcjk-e514f0bc, extender runtime 32): the vanilla CONT_GEN_Chest_Heavy_A MapKey 0b90bf9d-66fd-4741-be1f-39181efca97a → pass with name, templateType item and fileName .../Public/Shared/RootTemplates/_merged.lsf; a bogus MapKey → fail with present:false; no errors. See also knowledge fact bg3.items.roottemplates.loose-lsx-in-roottemplates-is-not-loaded-a-separate-lsf-is.",
+    },
+    {
+        kind: "bg3.lua.eval",
+        game: "baldursgate3",
+        context: "server",
+        effect: "mutate",
+        status: "attested",
+        summary: "Evaluate one Lua expression or chunk in the server Lua state and return its value, the way a pasted _D(...) console line would. Always effect mutate: the bridge cannot know what a chunk does, so it never runs one the request did not opt into with allowMutate.",
+        citation: "bg3.lua.eval; added 2026-09-11 so console lines pasted by hand run through ModWright",
+        paramsSchema: z.object({ code: str(), maxBytes: z.number().int().positive().max(65536).optional() }).strict(),
+        evidence: "Verified live (2026-09-11, extender runtime 32): the first request errored with `bad argument #2 to 'loader' (table expected, got string)` — the extender's loader takes the code alone (its optional second argument is an environment table), so the chunk name was dropped; after a console `reset` the next request (req-mtx6wdoe-008d3beb) passed `1 + 1` → 2, `Ext.Mod.GetMod(uuid).Info.Directory` → the test mod's folder name, `Ext.Stats.Get(...).SpellType` → \"Projectile\", `Osi.DB_Players:Get(nil)` → one row, a two-value chunk → [1, \"two\"], `error(\"deliberate\")` → status error, and an `Ext.Entity.Get(host).Health` read → the coerced component; on a fresh session (req-mtx6ywlv-8535fcd9) `Osi.TemplateAddTo` ran (returnCount 0) and `maxBytes: 16` truncated the Health read to a 16-byte prefix with truncated: true. A read-labelled eval was skipped by the handler, as designed."
+    },
+    {
+        kind: "bg3.mod.active",
+        game: "baldursgate3",
+        context: "server",
+        effect: "read",
+        status: "attested",
+        summary: "The module is loaded, and its version.",
+        citation: "bg3.mod.active",
+        paramsSchema: z.object({ uuid: str() }).strict(),
+    },
+    {
+        kind: "bg3.entity.components",
+        game: "baldursgate3",
+        context: "server",
+        effect: "read",
+        status: "attested",
+        summary: "Which components an entity carries.",
+        citation: "bg3.entity.components",
+        paramsSchema: z.object({ guid: str() }).strict(),
+    },
+    {
+        kind: "bg3.entity.status",
+        game: "baldursgate3",
+        context: "server",
+        effect: "read",
+        status: "attested",
+        summary: "Entity has an active status.",
+        citation: "bg3.entity.status",
+        paramsSchema: z.object({ guid: str(), status: str() }).strict(),
+    },
+    {
+        kind: "bg3.entity.passive",
+        game: "baldursgate3",
+        context: "server",
+        effect: "read",
+        status: "attested",
+        summary: "Passive present in the container.",
+        citation: "bg3.entity.passive",
+        paramsSchema: z.object({ guid: str(), passive: str() }).strict(),
+    },
+    {
+        kind: "bg3.entity.class",
+        game: "baldursgate3",
+        context: "server",
+        effect: "read",
+        status: "attested",
+        summary: "Class / subclass / level.",
+        citation: "bg3.entity.class",
+        paramsSchema: z.object({ guid: str() }).strict(),
+    },
+    {
+        kind: "bg3.entity.resource",
+        game: "baldursgate3",
+        context: "server",
+        effect: "read",
+        status: "attested",
+        summary: "Action-resource amounts (spell slots). Shape observed in game: { Resources: { <ResourceUUID>: [{ Amount, Level, MaxAmount, ReplenishType, ResourceUUID }] } }.",
+        citation: "bg3.entity.resource",
+        paramsSchema: z.object({ guid: str(), resource: str() }).strict(),
+        evidence: "attested(engine) in game (2026-09-08) for the component shape above, captured whole via bridge arm/poll on $host. The SpellSlot ResourceUUID (d136c5d9-0ff0-43da-acce-a74a07f8d6bf) was identified only by corroboration (a Bard L1 host's single entry, a custom-class L5 host's three-entry table matching a caster's real slot table) — that UUID itself stays inferred, not attested, since ActionResourceDefinitions.lsx was not yet in the index at the time.",
+    },
+    {
+        kind: "bg3.boost.freecast",
+        game: "baldursgate3",
+        context: "server",
+        effect: "observe",
+        status: "unverified",
+        summary: "Acceptance regression: is the Overclock slot-replacement boost live? Depends on bg3.entity.resource.",
+        citation: "bg3.boost.freecast",
+        paramsSchema: z.object({ guid: str(), resource: str(), status: str() }).strict(),
+        evidence: "Exercised in game (2026-09-08) with a free-cast status toggled on and one leveled cast — behaved correctly, no slot consumed, even under a deliberately broken BoostContext. Stays unverified rather than promoted: it still depends on the SpellSlot ResourceUUID under bg3.entity.resource, which is inferred by corroboration, not attested.",
+    },
+    {
+        kind: "bg3.event.watch",
+        game: "baldursgate3",
+        context: "server",
+        effect: "observe",
+        status: "attested",
+        summary: "An Osiris event fired in the window.",
+        citation: "bg3.event.watch",
+        paramsSchema: z.object({ name: str(), arity: z.number().int().nonnegative(), match: record().default({}) }).strict(),
+    },
+    {
+        kind: "bg3.event.damage",
+        game: "baldursgate3",
+        context: "server",
+        effect: "observe",
+        status: "unverified",
+        summary: "Damage amounts and types from an engine event. Field paths inside the event are not pinned.",
+        citation: "bg3.event.damage",
+        paramsSchema: z.object({ window: z.number().nonnegative().optional(), filter: record().default({}) }).strict(),
+    },
+    {
+        kind: "bg3.osiris.health",
+        game: "baldursgate3",
+        context: "server",
+        effect: "read",
+        status: "attested",
+        summary: "Is Osiris degraded after a console reset?",
+        citation: "bg3.osiris.health",
+        paramsSchema: z.object({}).strict(),
+    },
+    {
+        kind: "bg3.precondition.report",
+        game: "baldursgate3",
+        context: "server",
+        effect: "read",
+        status: "attested",
+        summary: "Report, do not assume, the fixture state.",
+        citation: "bg3.precondition.report",
+        paramsSchema: z.object({}).strict(),
+    },
+    {
+        kind: "bg3.client.loaded",
+        game: "baldursgate3",
+        context: "client",
+        effect: "read",
+        status: "attested",
+        summary: "The mod enumerated at the main menu.",
+        citation: "bg3.client.loaded",
+        paramsSchema: z.object({}).strict(),
+    },
+];
+const CP2077_PROBES = [
+    {
+        kind: "cp2077.bridge.io",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "attested",
+        summary: "Where can the bridge write? The mod sandbox provides io relative to the mod folder; the first candidate (the mod folder itself) is the write root.",
+        citation: "cp2077.bridge.io",
+        paramsSchema: z.object({}).strict(),
+        evidence: "Observed in game (2026-09-08, CET v1.37.1): the deployed bridge's heartbeat reported capabilities io:true, json:true, os:true, transport file, writeRoot modwright_hb.json, and a cp2077.mod.loaded arm/poll round trip completed in 11 ms through the file transport. " +
+            "An earlier console io.open failure was the console sandbox by design (CET changelog 1.10), and the bridge's earlier log-only fallback was its own _G-based probe (CET source: no _G in a mod environment), fixed in 921da79.",
+    },
+    {
+        kind: "cp2077.mod.loaded",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "attested",
+        summary: "The bridge mod is loaded and console-reachable.",
+        citation: "cp2077.mod.loaded",
+        paramsSchema: z.object({}).strict(),
+        evidence: "Reconfirmed at the CET console: `print(tostring(GetMod(\"ModWrightBridge\")))` returned `table: 0x01e978f3edf8`.",
+    },
+    {
+        kind: "cp2077.player.present",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "attested",
+        summary: "A player exists (i.e. in a save, not the menu).",
+        citation: "cp2077.player.present",
+        paramsSchema: z.object({}).strict(),
+    },
+    {
+        kind: "cp2077.item.equipped",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "attested",
+        summary: "Which TweakDB item is in a slot.",
+        citation: "cp2077.item.equipped",
+        paramsSchema: z.object({ slot: str() }).strict(),
+    },
+    {
+        kind: "cp2077.inventory.add",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "mutate",
+        status: "attested",
+        summary: "Give an item. Return value undocumented; success is never read from it.",
+        citation: "cp2077.inventory.add",
+        paramsSchema: z.object({ item: str(), qty: z.union([z.string(), z.number()]) }).strict(),
+    },
+    {
+        kind: "cp2077.lua.eval",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "mutate",
+        status: "attested",
+        summary: "Evaluate one Lua expression or chunk in the CET mod's Lua state and return its value, the way a pasted console line would (Game.AddToInventory(...), TweakDB:GetRecord(...)). Always effect mutate, gated by allowMutate like cp2077.inventory.add.",
+        citation: "cp2077.lua.eval; added 2026-09-11",
+        paramsSchema: z.object({ code: str(), maxBytes: z.number().int().positive().max(65536).optional() }).strict(),
+        evidence: "Verified live (Cyberpunk, 2026-09-11, CET file transport): request req-mtx7lhpv-b35c7106 passed `1 + 1` → 2, `TweakXL.Version()` → \"1.11.4\", a `TweakDB:GetFlat` LocKey read, a two-value chunk → [1, \"two\"], `error(\"deliberate\")` → status error, and `Game.GetPlayer():GetWorldPosition()` with maxBytes 16 → a 16-byte prefix with truncated: true; request req-mtx7m7q0-d4c566c0 ran `Game.AddToInventory(\"<a scratch test item>\", 1)` (returnCount 0) and the added items were counted in the inventory by hand. CET's loader accepted the code-only call at once. A `GetItemQuantity`/`HasItem` read by bare TweakDB id returned 0/false for the spawned weapon (weapons carry a per-instance seed in their ItemID), so that read is not a count."
+    },
+    {
+        kind: "cp2077.entity.tagged",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "attested",
+        summary: "Find dynamic entities by tag.",
+        citation: "cp2077.entity.tagged",
+        paramsSchema: z.object({ tag: str() }).strict(),
+    },
+    {
+        kind: "cp2077.entity.components",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "attested",
+        summary: "Which named component an entity has. The call is attested; the names to ask for are per-case and unverified.",
+        citation: "cp2077.entity.components",
+        paramsSchema: z.object({ entityRef: str(), names: z.array(str()).min(1) }).strict(),
+    },
+    {
+        kind: "cp2077.entity.transform",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "unverified",
+        summary: "Where an entity is. Attested for item objects; unverified for a sector-placed prop.",
+        citation: "cp2077.entity.transform",
+        paramsSchema: z.object({ entityRef: str() }).strict(),
+        evidence: "Observed in game: a test mod's own init.lua comment says its tag \"removes legacy dynamic cases from older experiments\" and the real case is a static sector prop, so GetTaggedIDs on it returned 0 twice at two locations — not a location miss. That tag marks legacy dev spawns only and is the wrong entry point for a sector-placed prop; a sector-placed prop needs a different probe mechanism, not just a re-run of this one. Stays unverified.",
+    },
+    {
+        kind: "cp2077.entity.appearance",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "unverified",
+        summary: "Acceptance regression, differential: did the sector node's appearanceName resolve?",
+        citation: "cp2077.entity.appearance",
+        paramsSchema: z.object({ tag: str(), baselineId: str() }).strict(),
+    },
+    {
+        kind: "cp2077.tweakdb.record",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "attested",
+        summary: "A TweakDB record exists.",
+        citation: "cp2077.tweakdb.record",
+        paramsSchema: z.object({ id: str() }).strict(),
+        evidence: 'Verified at the CET console: `print(tostring(TweakDB:GetRecord("Items.<a mod\'s weapon preset>")))` returned `userdata: 0x01e8a556bf60`.',
+    },
+    {
+        kind: "cp2077.tweakdb.flat",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "attested",
+        summary: "A flat's value.",
+        citation: "cp2077.tweakdb.flat",
+        paramsSchema: z.object({ id: str() }).strict(),
+        evidence: 'Verified at the CET console: `print(tostring(TweakDB:GetFlat("Items.<a mod\'s weapon preset>.displayName")))` returned `LocKey(15107614351950282319ull)`.',
+    },
+    {
+        kind: "cp2077.interaction.present",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "unverified",
+        summary: "An interaction component is on the entity. The component name is not attested anywhere on disk.",
+        citation: "cp2077.interaction.present",
+        paramsSchema: z.object({ entityRef: str() }).strict(),
+    },
+];
+export const PROBE_CATALOG = [...BG3_PROBES, ...CP2077_PROBES];
+const BY_KIND = new Map(PROBE_CATALOG.map((entry) => [entry.kind, entry]));
+export function lookupProbe(kind) {
+    return BY_KIND.get(kind);
+}
+export function probesForGame(game) {
+    return PROBE_CATALOG.filter((entry) => entry.game === game);
+}