modwright 0.1.2 → 0.1.3

package/dist/core/managers/vortex.js

@@ -0,0 +1,52 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+const MANIFEST = /^vortex\.deployment\.(?:(?<type>[^.]+)\.)?json$/i;
+export async function readVortexManifests(dir) {
+    const manifests = [];
+    const unreadable = [];
+    let names;
+    try {
+        names = await fs.readdir(dir);
+    }
+    catch {
+        return { manifests, unreadable };
+    }
+    for (const name of names.sort()) {
+        const match = MANIFEST.exec(name);
+        if (!match)
+            continue;
+        const file = path.join(dir, name);
+        try {
+            const raw = JSON.parse(await fs.readFile(file, "utf8"));
+            if (!Array.isArray(raw.files))
+                throw new Error("no files array");
+            const files = [];
+            for (const entry of raw.files) {
+                if (typeof entry?.relPath !== "string" || typeof entry.source !== "string")
+                    continue;
+                const deployed = { relPath: entry.relPath, source: entry.source };
+                if (Array.isArray(entry.merged))
+                    deployed.merged = entry.merged.filter((m) => typeof m === "string");
+                if (typeof entry.target === "string" && entry.target)
+                    deployed.target = entry.target;
+                if (typeof entry.time === "number")
+                    deployed.time = entry.time;
+                files.push(deployed);
+            }
+            const manifest = { file, deployDir: dir, modType: match.groups?.type ?? "", files };
+            if (typeof raw.gameId === "string")
+                manifest.gameId = raw.gameId;
+            if (typeof raw.deploymentMethod === "string")
+                manifest.deploymentMethod = raw.deploymentMethod;
+            if (typeof raw.deploymentTime === "number")
+                manifest.deploymentTime = raw.deploymentTime;
+            if (typeof raw.stagingPath === "string")
+                manifest.stagingPath = raw.stagingPath;
+            manifests.push(manifest);
+        }
+        catch (error) {
+            unreadable.push({ file, error: error.message });
+        }
+    }
+    return { manifests, unreadable };
+}

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,6 +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

@@ -17,6 +17,11 @@ export async function findProjectFile(startDir) {
         dir = parent;
     }
 }
+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);
     return rel === "" || (!(rel === ".." || rel.startsWith(`..${path.sep}`)) && !path.isAbsolute(rel));

package/dist/core/testplan/registry.js

@@ -262,7 +262,11 @@ const CP2077_PROBES = [
         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.",
+        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. " +
+            "RTTI (rayshader/cp2077-nativedb b5d29af, game 2.31): both calls are declared on entEntity itself — " +
+            "GetWorldPosition() -> Vector4, GetWorldOrientation() -> Quaternion — and a loot-container prop's entity class " +
+            "(LootContainerObjectAnimatedByTransform) reaches entEntity through gameLootContainerBase/gameObject/entGameEntity, " +
+            "so such a prop has both methods by inheritance. The methods were never in doubt; getting a handle to the prop is.",
     },
     {
         kind: "cp2077.entity.appearance",
@@ -273,6 +277,12 @@ const CP2077_PROBES = [
         summary: "Acceptance regression, differential: did the sector node's appearanceName resolve?",
         citation: "cp2077.entity.appearance",
         paramsSchema: z.object({ tag: str(), baselineId: str() }).strict(),
+        evidence: "Composite of cp2077.entity.tagged + .components + .transform against a baseline; blocked the same way " +
+            "cp2077.entity.tagged is for a sector-placed prop (its first step). RTTI (rayshader/cp2077-nativedb " +
+            "b5d29af, game 2.31): entEntity::GetCurrentAppearanceName() -> CName exists, inherited by loot-container " +
+            "props, and entIComponent::GetAppearanceName() -> CName exists per component. That is a direct read of the " +
+            "question this row asks (did appearanceName resolve?) and a smaller call than the composite, but no CET mod " +
+            "or wiki page calls it from Lua, so it is a candidate for the next live run, not a redesign of this row.",
     },
     {
         kind: "cp2077.tweakdb.record",
@@ -302,9 +312,48 @@ const CP2077_PROBES = [
         context: "cet",
         effect: "read",
         status: "unverified",
-        summary: "An interaction component is on the entity. The component name is not attested anywhere on disk.",
+        summary: "An interaction component is on the entity. The component name is per-entity: a loot-container template " +
+            "names it \"interactions\" (class gameinteractionsComponent); nothing calls it from Lua yet.",
         citation: "cp2077.interaction.present",
         paramsSchema: z.object({ entityRef: str() }).strict(),
+        evidence: "A loot-container entity template's components list { $type: gameinteractionsComponent, name: \"interactions\" } " +
+            "alongside inventory, scanning, workspotMapper, root, audioSound, vision, UI_Slots, GameplayRole, state_fxes and " +
+            "targeting. RTTI (rayshader/cp2077-nativedb b5d29af): gameinteractionsComponent -> entIPlacedComponent -> " +
+            "entIComponent; entEntity::FindComponentByName(componentName: CName) -> ref<entIComponent>; no generic " +
+            "enumerate-by-class call exists on entEntity/gameObject, so exact names stay the only path. A design-time " +
+            "template field is not an in-engine observation that the component resolves on the streamed instance: stays unverified.",
+    },
+    {
+        kind: "cp2077.entity.nearby",
+        game: "cyberpunk2077",
+        context: "cet",
+        effect: "read",
+        status: "unverified",
+        summary: "Entities within a radius of an anchor entity (the player by default). filter \"npc\" (default) asks " +
+            "GetNPCsAroundObject; filter \"objects\" asks GetEntitiesAroundObject with an Obj_*-wide target search " +
+            "filter, the shape that could find a placed static prop.",
+        citation: "cp2077.entity.nearby",
+        paramsSchema: z
+            .object({
+            radius: z.number().positive(),
+            filter: z.enum(["npc", "objects"]).optional(),
+            entityRef: str().optional(),
+            tag: str().optional(),
+            index: z.number().int().positive().optional(),
+        })
+            .strict(),
+        evidence: "rayshader/cp2077-nativedb at b5d29af (v2.1.0, game 2.31; RTTI dumped by WopsS/RED4.RTTIDumper) classes.json: " +
+            "gameObject (parent entGameEntity) carries GetNPCsAroundObject(range: Float) -> array<ref<NPCPuppet>> and " +
+            "GetEntitiesAroundObject(range: Float, searchFilter: gameTargetSearchFilter) -> array<ref<entEntity>>; " +
+            "globals.json lists the filter constructors TSF_All/TSF_Any/TSF_Not/TSF_And/TSF_Or/TSF_NPC/TSF_EnemyNPC/" +
+            "TSF_Quickhackable and enums.json the mask members (TSFMV). No shipped CET mod or wiki page calls any of it, " +
+            "but CET's own source (yamashi/CyberEngineTweaks 9a8522f; knowledge facts cp2077.cet.*) pins the Lua side: " +
+            "globals are exposed bare and via Game.*, a returned struct passes back as a parameter, an undeclared enum value " +
+            "is coerced to 0 silently (so the handler builds the filter from declared members via Enum.new and TSF_Or, never " +
+            "an ORed mask), and array returns are 1-based tables with nil holes for null handles. What no source can supply " +
+            "is the live result: TSF_Any/TSF_Or semantics, whether a sector-placed prop is in the targeting set (a " +
+            "loot-container template does carry a gameTargetingComponent), and whether the game marks TSF_* isExec. Never " +
+            "run in game; stays unverified until a live run exercises it.",
     },
 ];
 export const PROBE_CATALOG = [...BG3_PROBES, ...CP2077_PROBES];