@skyramp/mcp 0.4.1 → 0.4.2-rc.1

package/build/utils/testDependencyPolicy.js

@@ -0,0 +1,788 @@
+import { execFile } from "child_process";
+import { access, readFile } from "fs/promises";
+import * as path from "path";
+import { parse as parseToml } from "smol-toml";
+import { promisify } from "util";
+import fg from "fast-glob";
+import { canonicalJson as canonical, isPlainObject as isObject, } from "./canonicalJson.js";
+import { listChangedFiles } from "./reportVerification.js";
+const execFileAsync = promisify(execFile);
+export const NPM_TEST_PACKAGES = new Set([
+    "@playwright/test",
+    "@skyramp/skyramp",
+    "@testing-library/dom",
+    "@testing-library/jest-dom",
+    "@testing-library/react",
+    "@testing-library/user-event",
+    "@types/chai",
+    "@types/jest",
+    "@types/mocha",
+    "@types/supertest",
+    "chai",
+    "cypress",
+    "jest",
+    "mocha",
+    "playwright",
+    "supertest",
+    "ts-jest",
+    "ts-node",
+    "tsx",
+    "typescript",
+    "vitest",
+]);
+export const PYTHON_TEST_PACKAGES = new Set([
+    "coverage",
+    "hypothesis",
+    "playwright",
+    "pytest",
+    "pytest-cov",
+    "pytest-playwright",
+    "robotframework",
+    "skyramp",
+]);
+export const JAVA_TEST_PACKAGES = new Set([
+    "io.rest-assured:rest-assured",
+    "org.assertj:assertj-core",
+    "org.awaitility:awaitility",
+    "org.junit.jupiter:junit-jupiter",
+    "org.junit.platform:junit-platform-console-standalone",
+    "org.mockito:mockito-core",
+    "org.testng:testng",
+]);
+const DEPENDENCY_FILES = {
+    javascript: {
+        manifests: ["package.json"],
+        lockfiles: [
+            "package-lock.json",
+            "npm-shrinkwrap.json",
+            "yarn.lock",
+            "pnpm-lock.yaml",
+        ],
+    },
+    python: {
+        manifests: ["pyproject.toml", "requirements-dev.txt", "requirements.txt"],
+        lockfiles: ["poetry.lock", "uv.lock"],
+    },
+    java: {
+        manifests: ["pom.xml", "build.gradle", "build.gradle.kts"],
+        lockfiles: ["gradle.lockfile"],
+    },
+};
+const MANIFEST_NAMES = new Set(Object.values(DEPENDENCY_FILES).flatMap(({ manifests }) => manifests));
+const LOCKFILE_NAMES = new Set(Object.values(DEPENDENCY_FILES).flatMap(({ lockfiles }) => lockfiles));
+export async function verifyTestDependencyChanges(repositoryPath) {
+    const changedFiles = await listChangedFiles(repositoryPath);
+    const dependencyFiles = changedFiles.filter((file) => {
+        const name = path.posix.basename(file);
+        return MANIFEST_NAMES.has(name) || LOCKFILE_NAMES.has(name);
+    });
+    const violations = [];
+    const validManifests = new Set();
+    for (const file of dependencyFiles) {
+        const name = path.posix.basename(file);
+        if (LOCKFILE_NAMES.has(name)) {
+            if (await baselineFileExists(repositoryPath, file)) {
+                try {
+                    await access(path.join(repositoryPath, file));
+                }
+                catch {
+                    violations.push(`${file}: Deleting a lockfile is not allowed.`);
+                }
+            }
+            continue;
+        }
+        const committedBaseline = await baselineFile(repositoryPath, file);
+        const baseline = committedBaseline ??
+            (await baselineForNewManifest(repositoryPath, file, name, violations));
+        if (baseline === undefined)
+            continue;
+        let current;
+        try {
+            current = await readFile(path.join(repositoryPath, file), "utf8");
+        }
+        catch {
+            violations.push(`${file}: Deleting a dependency manifest is not allowed.`);
+            continue;
+        }
+        const beforeCount = violations.length;
+        const dependencyChanged = verifyManifest(file, name, baseline, current, violations);
+        if (committedBaseline === undefined && !dependencyChanged) {
+            violations.push(`${file}: A new dependency manifest must add at least one approved development/test dependency.`);
+        }
+        if (violations.length === beforeCount && dependencyChanged)
+            validManifests.add(file);
+    }
+    for (const file of dependencyFiles) {
+        const name = path.posix.basename(file);
+        if (!LOCKFILE_NAMES.has(name))
+            continue;
+        const paired = await correspondingManifests(repositoryPath, file, name);
+        if (!paired.some((manifest) => validManifests.has(manifest))) {
+            violations.push(`${file}: A lockfile may change only with a corresponding manifest that has a valid development/test dependency change.`);
+            continue;
+        }
+        await verifyLockfile(repositoryPath, file, name, paired, validManifests, violations);
+    }
+    return {
+        ok: violations.length === 0,
+        checkedFiles: dependencyFiles.sort(),
+        violations,
+    };
+}
+async function baselineForNewManifest(repositoryPath, file, name, violations) {
+    const dir = path.posix.dirname(file);
+    const at = (candidate) => dir === "." ? candidate : `${dir}/${candidate}`;
+    let competitors = [];
+    let baseline;
+    if (name === "package.json") {
+        baseline = "{}\n";
+    }
+    else if (name === "requirements-dev.txt") {
+        competitors = ["pyproject.toml"];
+        baseline = "";
+    }
+    else if (name === "pom.xml") {
+        competitors = ["build.gradle", "build.gradle.kts"];
+        baseline = [
+            '<project xmlns="http://maven.apache.org/POM/4.0.0">',
+            "<modelVersion>4.0.0</modelVersion>",
+            "<groupId>dev.skyramp.generated</groupId>",
+            "<artifactId>generated-tests</artifactId>",
+            "<version>1.0-SNAPSHOT</version>",
+            "<dependencies>",
+            "</dependencies>",
+            "</project>",
+        ].join("\n");
+    }
+    else if (name === "build.gradle" || name === "build.gradle.kts") {
+        competitors = ["pom.xml", "build.gradle", "build.gradle.kts"].filter((candidate) => candidate !== name);
+        baseline =
+            name === "build.gradle.kts"
+                ? "plugins { java }\nrepositories { mavenCentral() }\ndependencies {\n}\n"
+                : "plugins { id 'java' }\nrepositories { mavenCentral() }\ndependencies {\n}\n";
+    }
+    else {
+        violations.push(`${file}: Create requirements-dev.txt instead of synthesizing a new Python project manifest.`);
+        return undefined;
+    }
+    for (const competitor of competitors) {
+        if (await baselineFileExists(repositoryPath, at(competitor))) {
+            violations.push(`${file}: Cannot create a competing dependency manifest while ${at(competitor)} already exists.`);
+            return undefined;
+        }
+    }
+    return baseline;
+}
+function verifyManifest(file, name, baseline, current, violations) {
+    if (DEPENDENCY_FILES.javascript.manifests.includes(name))
+        return verifyJavascriptManifest(file, name, baseline, current, violations);
+    if (DEPENDENCY_FILES.python.manifests.includes(name))
+        return verifyPythonManifest(file, name, baseline, current, violations);
+    return verifyJavaManifest(file, name, baseline, current, violations);
+}
+function verifyJavascriptManifest(file, name, baseline, current, violations) {
+    if (name !== "package.json")
+        return false;
+    return verifyPackageJson(file, baseline, current, violations);
+}
+function verifyPythonManifest(file, name, baseline, current, violations) {
+    if (name === "pyproject.toml")
+        return verifyPyproject(file, baseline, current, violations);
+    if (name === "requirements-dev.txt")
+        return verifyRequirementsDev(file, baseline, current, violations);
+    violations.push(`${file}: Python test packages may be changed only in requirements-dev.txt or an approved pyproject.toml development dependency group.`);
+    return false;
+}
+function verifyJavaManifest(file, name, baseline, current, violations) {
+    if (name === "pom.xml")
+        return verifyMaven(file, baseline, current, violations);
+    return verifyGradle(file, baseline, current, violations);
+}
+async function baselineFile(repositoryPath, file) {
+    try {
+        const { stdout } = await execFileAsync("git", ["show", `HEAD:${file}`], {
+            cwd: repositoryPath,
+            encoding: "utf8",
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return stdout;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function baselineFileExists(repositoryPath, file) {
+    try {
+        await execFileAsync("git", ["cat-file", "-e", `HEAD:${file}`], {
+            cwd: repositoryPath,
+            encoding: "utf8",
+            maxBuffer: 1024,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function verifyPackageJson(file, beforeRaw, afterRaw, violations) {
+    let before;
+    let after;
+    try {
+        before = JSON.parse(beforeRaw);
+        after = JSON.parse(afterRaw);
+    }
+    catch (error) {
+        violations.push(`${file}: Touched package.json must remain valid JSON: ${error.message}`);
+        return false;
+    }
+    for (const scope of ["dependencies", "devDependencies"]) {
+        if ((Object.prototype.hasOwnProperty.call(before, scope) &&
+            !isStringRecord(before[scope])) ||
+            (Object.prototype.hasOwnProperty.call(after, scope) &&
+                !isStringRecord(after[scope]))) {
+            violations.push(`${file}: ${scope} must be an object whose values are version strings.`);
+            return false;
+        }
+    }
+    const beforeRuntime = stringMap(before.dependencies);
+    const afterRuntime = stringMap(after.dependencies);
+    const beforeDev = stringMap(before.devDependencies);
+    const afterDev = stringMap(after.devDependencies);
+    const beforeRest = { ...before };
+    const afterRest = { ...after };
+    delete beforeRest.dependencies;
+    delete beforeRest.devDependencies;
+    delete afterRest.dependencies;
+    delete afterRest.devDependencies;
+    if (canonical(beforeRest) !== canonical(afterRest)) {
+        violations.push(`${file}: Only dependencies/devDependencies may change while fixing test imports; unrelated package.json fields changed.`);
+    }
+    for (const name of unionKeys(beforeRuntime, afterRuntime)) {
+        if (beforeRuntime[name] === afterRuntime[name])
+            continue;
+        const movedToDev = afterRuntime[name] === undefined && afterDev[name] !== undefined;
+        if (!movedToDev || !NPM_TEST_PACKAGES.has(name)) {
+            violations.push(`${file}: ${name} changed under dependencies; approved test packages must be restricted to devDependencies.`);
+        }
+    }
+    for (const name of unionKeys(beforeDev, afterDev)) {
+        if (beforeDev[name] === afterDev[name])
+            continue;
+        if (afterDev[name] === undefined) {
+            violations.push(`${file}: Removing ${name} from devDependencies is outside the fix-errors dependency policy.`);
+        }
+        else if (!NPM_TEST_PACKAGES.has(name)) {
+            violations.push(`${file}: ${name} is not on the approved test-package allowlist.`);
+        }
+        else if (!isSafeNpmSpecifier(afterDev[name])) {
+            violations.push(`${file}: ${name} must use a registry version, not an alias, URL, git, or local package source.`);
+        }
+    }
+    return (canonical(beforeRuntime) !== canonical(afterRuntime) ||
+        canonical(beforeDev) !== canonical(afterDev));
+}
+function verifyPyproject(file, beforeRaw, afterRaw, violations) {
+    const before = pythonDevView(beforeRaw);
+    const after = pythonDevView(afterRaw);
+    if (before.error || after.error) {
+        violations.push(`${file}: Touched pyproject.toml uses an unsupported or unparsable development dependency shape: ${after.error ?? before.error}`);
+        return false;
+    }
+    if (canonical(before.remainder) !== canonical(after.remainder)) {
+        violations.push(`${file}: Python dependency edits must be restricted to an approved development dependency group: dependency-groups.dev or tool.poetry.group.dev.dependencies.`);
+    }
+    verifyNamedDevelopmentChanges(file, before.dependencies, after.dependencies, PYTHON_TEST_PACKAGES, violations, "Python");
+    return canonical(before.dependencies) !== canonical(after.dependencies);
+}
+function pythonDevView(raw) {
+    const dependencies = {};
+    let remainder;
+    try {
+        remainder = parseToml(raw);
+    }
+    catch (error) {
+        return {
+            dependencies,
+            remainder: {},
+            error: error.message,
+        };
+    }
+    const poetryValue = nestedValue(remainder, "tool", "poetry", "group", "dev", "dependencies");
+    if (poetryValue !== undefined && !isObject(poetryValue))
+        return {
+            dependencies,
+            remainder,
+            error: "Poetry development dependencies must be a table of registry version strings.",
+        };
+    const poetry = isObject(poetryValue) ? poetryValue : undefined;
+    if (poetry) {
+        for (const [rawName, value] of Object.entries(poetry)) {
+            const name = normalizePythonName(rawName);
+            if (typeof value !== "string" || !isSafePythonRequirement(value))
+                return {
+                    dependencies,
+                    remainder,
+                    error: `Poetry dependency ${name} must use a registry version string, not a URL, VCS, or local package source.`,
+                };
+            dependencies[name] = value;
+        }
+    }
+    deleteNestedAndPrune(remainder, "tool", "poetry", "group", "dev", "dependencies");
+    const dependencyGroups = nestedObject(remainder, "dependency-groups");
+    const dev = dependencyGroups?.dev;
+    if (dev !== undefined) {
+        if (!Array.isArray(dev) || dev.some((value) => typeof value !== "string"))
+            return {
+                dependencies,
+                remainder,
+                error: "dependency-groups.dev supports only direct requirement strings.",
+            };
+        for (const value of dev) {
+            const requirement = value;
+            const name = normalizePythonName(requirement.match(/^[A-Za-z0-9_.-]+/)?.[0] ?? "");
+            if (!name || !isSafePythonRequirement(requirement))
+                return {
+                    dependencies,
+                    remainder,
+                    error: `${name || requirement} must use a registry version, not a URL, VCS, or local package source.`,
+                };
+            dependencies[name] = requirement;
+        }
+    }
+    deleteNestedAndPrune(remainder, "dependency-groups", "dev");
+    return { dependencies, remainder };
+}
+function verifyRequirementsDev(file, beforeRaw, afterRaw, violations) {
+    const before = requirementsMap(beforeRaw);
+    const after = requirementsMap(afterRaw);
+    if (before.error || after.error) {
+        violations.push(`${file}: ${after.error ?? before.error}`);
+        return false;
+    }
+    verifyNamedDevelopmentChanges(file, before.dependencies, after.dependencies, PYTHON_TEST_PACKAGES, violations, "Python");
+    return canonical(before.dependencies) !== canonical(after.dependencies);
+}
+function requirementsMap(raw) {
+    const dependencies = {};
+    for (const line of raw.replace(/\r\n/g, "\n").split("\n")) {
+        const trimmed = line.replace(/\s+#.*$/, "").trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const name = normalizePythonName(trimmed.match(/^[A-Za-z0-9_.-]+/)?.[0] ?? "");
+        if (!name)
+            return {
+                dependencies,
+                error: `Unsupported requirements-dev.txt entry: ${trimmed}`,
+            };
+        if (!isSafePythonRequirement(trimmed))
+            return {
+                dependencies,
+                error: `${name} must use a registry version, not a URL, VCS, or local package source.`,
+            };
+        dependencies[name] = trimmed;
+    }
+    return { dependencies };
+}
+function verifyMaven(file, beforeRaw, afterRaw, violations) {
+    const before = mavenView(beforeRaw);
+    const after = mavenView(afterRaw);
+    if (before.error || after.error) {
+        violations.push(`${file}: ${after.error ?? before.error}`);
+        return false;
+    }
+    if (normalizeText(before.remainder) !== normalizeText(after.remainder)) {
+        violations.push(`${file}: Only allowlisted Maven dependency blocks may change while fixing test imports.`);
+    }
+    for (const coordinate of unionKeys(before.dependencies, after.dependencies)) {
+        const prior = before.dependencies[coordinate];
+        const current = after.dependencies[coordinate];
+        if (canonical(prior) === canonical(current))
+            continue;
+        if (current === undefined) {
+            violations.push(`${file}: Removing ${coordinate} is outside the fix-errors dependency policy.`);
+        }
+        else if (!JAVA_TEST_PACKAGES.has(coordinate)) {
+            violations.push(`${file}: ${coordinate} is not on the approved Java test-package allowlist.`);
+        }
+        else {
+            for (const block of current) {
+                const validation = mavenDependency(block);
+                if (validation.error) {
+                    violations.push(`${file}: ${coordinate} ${validation.error}`);
+                }
+            }
+        }
+    }
+    return canonical(before.dependencies) !== canonical(after.dependencies);
+}
+function mavenView(raw) {
+    const dependencies = {};
+    let error;
+    const remainder = raw.replace(/<dependency>\s*[\s\S]*?<\/dependency>/g, (block) => {
+        const parsed = mavenDependency(block);
+        if (!parsed.coordinate)
+            error = parsed.error;
+        else
+            (dependencies[parsed.coordinate] ??= []).push(normalizeText(block));
+        return "";
+    });
+    return { dependencies, remainder, error };
+}
+function mavenDependency(block) {
+    const uncommented = block.replace(/<!--[\s\S]*?-->/g, "");
+    const group = singleXmlTag(uncommented, "groupId");
+    const artifact = singleXmlTag(uncommented, "artifactId");
+    if (!group || !artifact)
+        return {
+            error: "is missing exactly one groupId or artifactId.",
+        };
+    const coordinate = `${group}:${artifact}`;
+    const scopes = xmlTagValues(uncommented, "scope");
+    if (scopes.length !== 1 || scopes[0] !== "test")
+        return {
+            coordinate,
+            error: "must contain exactly one effective <scope>test</scope>.",
+        };
+    if (xmlTagValues(uncommented, "systemPath").length)
+        return {
+            coordinate,
+            error: "must not use a systemPath or another local package source.",
+        };
+    return { coordinate };
+}
+function xmlTagValues(block, tag) {
+    const values = [];
+    const expression = new RegExp(`<${tag}\\s*>\\s*([^<]+?)\\s*</${tag}\\s*>`, "g");
+    for (const match of block.matchAll(expression))
+        values.push(match[1].trim());
+    return values;
+}
+function singleXmlTag(block, tag) {
+    const values = xmlTagValues(block, tag);
+    return values.length === 1 ? values[0] : undefined;
+}
+function verifyGradle(file, beforeRaw, afterRaw, violations) {
+    const before = gradleView(beforeRaw);
+    const after = gradleView(afterRaw);
+    if (normalizeText(before.remainder) !== normalizeText(after.remainder)) {
+        violations.push(`${file}: Only simple allowlisted Gradle dependency declarations may change while fixing test imports.`);
+    }
+    for (const coordinate of unionKeys(before.dependencies, after.dependencies)) {
+        const prior = before.dependencies[coordinate];
+        const current = after.dependencies[coordinate];
+        if (canonical(prior) === canonical(current))
+            continue;
+        if (current === undefined) {
+            violations.push(`${file}: Removing ${coordinate} is outside the fix-errors dependency policy.`);
+            continue;
+        }
+        if (!JAVA_TEST_PACKAGES.has(coordinate)) {
+            violations.push(`${file}: ${coordinate} is not on the approved Java test-package allowlist.`);
+        }
+        else {
+            for (const declaration of current) {
+                const [configuration] = declaration.split("\0");
+                if (configuration !== "testImplementation" &&
+                    configuration !== "testRuntimeOnly")
+                    violations.push(`${file}: ${coordinate} must use testImplementation or testRuntimeOnly.`);
+            }
+        }
+    }
+    return canonical(before.dependencies) !== canonical(after.dependencies);
+}
+function gradleView(raw) {
+    const dependencies = {};
+    const remainder = raw.replace(/^\s*(\w+)\s*(?:\(\s*)?["']([^"']+)["']\s*\)?\s*$/gm, (line, configuration, value) => {
+        const parts = value.split(":");
+        if (parts.length < 2)
+            return line;
+        const coordinate = `${parts[0]}:${parts[1]}`;
+        (dependencies[coordinate] ??= []).push(`${configuration}\0${value}`);
+        return "";
+    });
+    return { dependencies, remainder };
+}
+function verifyNamedDevelopmentChanges(file, before, after, allowlist, violations, ecosystem) {
+    for (const name of unionKeys(before, after)) {
+        if (before[name] === after[name])
+            continue;
+        if (after[name] === undefined)
+            violations.push(`${file}: Removing ${name} is outside the fix-errors dependency policy.`);
+        else if (!allowlist.has(name))
+            violations.push(`${file}: ${name} is not on the approved ${ecosystem} test-package allowlist.`);
+    }
+}
+async function correspondingManifests(repositoryPath, file, lockName) {
+    const dir = path.posix.dirname(file);
+    const at = (name) => (dir === "." ? name : `${dir}/${name}`);
+    if (lockName === "package-lock.json" || lockName === "npm-shrinkwrap.json") {
+        const rootManifest = at("package.json");
+        // Membership comes from the committed root manifest, not the edited lockfile.
+        // A workspace addition is an unrelated manifest edit and remains disallowed.
+        const baseline = await baselineFile(repositoryPath, rootManifest);
+        if (baseline === undefined)
+            return [rootManifest];
+        const manifest = JSON.parse(baseline);
+        const workspaces = manifest.workspaces;
+        if (workspaces === undefined)
+            return [rootManifest];
+        if (!Array.isArray(workspaces) ||
+            !workspaces.every((item) => typeof item === "string")) {
+            throw new Error(`${rootManifest}: Cannot resolve workspace declarations.`);
+        }
+        for (const pattern of workspaces) {
+            if (!pattern ||
+                path.posix.isAbsolute(pattern) ||
+                path.win32.isAbsolute(pattern) ||
+                pattern.includes("\\") ||
+                pattern.split("/").includes("..")) {
+                throw new Error(`${rootManifest}: Workspace paths must stay within the project.`);
+            }
+        }
+        const workspaceManifests = await fg(workspaces.map((pattern) => `${pattern.replace(/\/$/, "")}/package.json`), {
+            cwd: path.join(repositoryPath, dir),
+            onlyFiles: true,
+            followSymbolicLinks: false,
+            ignore: ["**/node_modules/**", "**/.git/**"],
+        });
+        return [...new Set([rootManifest, ...workspaceManifests.sort().map(at)])];
+    }
+    for (const ecosystem of Object.values(DEPENDENCY_FILES)) {
+        if (ecosystem.lockfiles.some((candidate) => candidate === lockName))
+            return ecosystem.manifests.map(at);
+    }
+    return [];
+}
+async function verifyLockfile(repositoryPath, file, name, pairedManifests, validManifests, violations) {
+    const committedBaseline = await baselineFile(repositoryPath, file);
+    const baseline = committedBaseline ?? '{"packages":{}}\n';
+    let current;
+    try {
+        current = await readFile(path.join(repositoryPath, file), "utf8");
+    }
+    catch {
+        return;
+    }
+    const unsafeSource = addedUnsafeLockSource(baseline, current);
+    if (unsafeSource)
+        violations.push(`${file}: Lockfile source ${unsafeSource} is not an approved registry source.`);
+    if (name !== "package-lock.json" && name !== "npm-shrinkwrap.json")
+        return;
+    const manifests = new Map();
+    for (const [index, manifest] of pairedManifests.entries()) {
+        if (!(await baselineFileExists(repositoryPath, manifest))) {
+            const isNewRootManifest = index === 0 && validManifests.has(manifest);
+            if (!isNewRootManifest) {
+                violations.push(`${manifest}: Creating a new workspace manifest is not allowed.`);
+                continue;
+            }
+        }
+        const manifestRaw = await readFile(path.join(repositoryPath, manifest), "utf8");
+        const relativeDirectory = path.posix.relative(path.posix.dirname(file), path.posix.dirname(manifest));
+        manifests.set(relativeDirectory, JSON.parse(manifestRaw));
+    }
+    verifyPackageLock(file, baseline, current, manifests, violations);
+}
+function verifyPackageLock(file, beforeRaw, afterRaw, manifests, violations) {
+    let before;
+    let after;
+    try {
+        before = JSON.parse(beforeRaw);
+        after = JSON.parse(afterRaw);
+    }
+    catch (error) {
+        violations.push(`${file}: Changed npm lockfile must remain valid JSON: ${error.message}`);
+        return;
+    }
+    const beforePackages = objectMap(before.packages);
+    const afterPackages = objectMap(after.packages);
+    // Check every workspace, including unchanged ones, so a lockfile cannot hide
+    // new dependencies under a sibling app while another app authorizes the edit.
+    for (const [directory, manifest] of manifests) {
+        const entry = objectMap(afterPackages[directory]);
+        if (directory && !isObject(afterPackages[directory])) {
+            violations.push(`${file}: Missing workspace entry ${directory}.`);
+        }
+        if (directory) {
+            const linkPath = `node_modules/${manifest.name}`;
+            const link = objectMap(afterPackages[linkPath]);
+            if (link.link !== true || link.resolved !== directory) {
+                violations.push(`${file}: ${linkPath} must link to its declared workspace ${directory}.`);
+            }
+        }
+        for (const scope of [
+            "dependencies",
+            "devDependencies",
+            "optionalDependencies",
+            "peerDependencies",
+        ]) {
+            if (entry[scope] !== undefined && !isStringRecord(entry[scope])) {
+                violations.push(`${file}: ${directory || "Root"} ${scope} must be an object of version strings.`);
+            }
+            if (canonical(stringMap(entry[scope])) !==
+                canonical(stringMap(manifest[scope]))) {
+                violations.push(`${file}: ${directory || "Root"} ${scope} must match package.json exactly.`);
+            }
+        }
+    }
+    const reachable = reachablePackageLockEntries(afterPackages, manifests);
+    for (const packagePath of Object.keys(afterPackages)) {
+        const entry = objectMap(afterPackages[packagePath]);
+        if (entry.link === true &&
+            canonical(beforePackages[packagePath]) !== canonical(entry)) {
+            const target = typeof entry.resolved === "string"
+                ? manifests.get(entry.resolved)
+                : undefined;
+            if (!entry.resolved ||
+                !target ||
+                packagePath !== `node_modules/${target.name}`) {
+                violations.push(`${file}: ${packagePath} must link to its declared workspace.`);
+            }
+        }
+        if (packagePath &&
+            beforePackages[packagePath] === undefined &&
+            !reachable.has(packagePath))
+            violations.push(`${file}: Added unrelated lockfile package ${packagePath}.`);
+    }
+}
+function reachablePackageLockEntries(packages, manifests) {
+    const reachable = new Set();
+    const queue = [...manifests.keys()];
+    for (const [directory, manifest] of manifests) {
+        if (!directory)
+            continue;
+        const linkPath = `node_modules/${manifest.name}`;
+        const link = objectMap(packages[linkPath]);
+        if (link.link === true && link.resolved === directory)
+            queue.push(linkPath);
+    }
+    while (queue.length) {
+        const current = queue.shift();
+        if (reachable.has(current))
+            continue;
+        reachable.add(current);
+        const entry = objectMap(packages[current]);
+        if (entry.link === true) {
+            if (typeof entry.resolved === "string" && manifests.has(entry.resolved))
+                queue.push(entry.resolved);
+            continue;
+        }
+        // Seed workspace dependencies from their actual manifests. Registry packages
+        // contribute only installed dependencies, not their own development tools.
+        const manifest = manifests.get(current);
+        const dependencies = manifest ?? entry;
+        for (const name of Object.keys({
+            ...stringMap(dependencies.dependencies),
+            ...stringMap(manifest?.devDependencies),
+            ...stringMap(dependencies.optionalDependencies),
+            ...stringMap(dependencies.peerDependencies),
+        })) {
+            const resolved = resolvePackageLockEntry(current, name, packages);
+            if (resolved && !reachable.has(resolved))
+                queue.push(resolved);
+        }
+    }
+    return reachable;
+}
+function resolvePackageLockEntry(owner, dependency, packages) {
+    let directory = owner;
+    while (true) {
+        const prefix = directory ? `${directory}/node_modules` : "node_modules";
+        const candidate = `${prefix}/${dependency}`;
+        if (packages[candidate] !== undefined)
+            return candidate;
+        if (!directory)
+            break;
+        directory = path.posix.dirname(directory);
+        if (path.posix.basename(directory) === "node_modules")
+            directory = path.posix.dirname(directory);
+        if (directory === ".")
+            directory = "";
+    }
+    return undefined;
+}
+function addedUnsafeLockSource(beforeRaw, afterRaw) {
+    const allowedHosts = new Set(["registry.npmjs.org"]);
+    for (const match of beforeRaw.matchAll(/https:\/\/([^/\s"']+)/g))
+        allowedHosts.add(match[1].toLowerCase());
+    const beforeLines = new Set(beforeRaw.replace(/\r\n/g, "\n").split("\n"));
+    for (const line of afterRaw.replace(/\r\n/g, "\n").split("\n")) {
+        if (beforeLines.has(line))
+            continue;
+        const unsafe = line.match(/(?:file:|git\+|git@|ssh:\/\/|http:\/\/)[^\s"']*/i)?.[0];
+        if (unsafe)
+            return unsafe;
+        for (const match of line.matchAll(/https:\/\/([^/\s"']+)/g)) {
+            if (!allowedHosts.has(match[1].toLowerCase()))
+                return match[0];
+        }
+    }
+    return undefined;
+}
+function stringMap(value) {
+    if (!isObject(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+function objectMap(value) {
+    return isObject(value) ? value : {};
+}
+function nestedObject(root, ...keys) {
+    let current = root;
+    for (const key of keys) {
+        if (!isObject(current))
+            return undefined;
+        current = current[key];
+    }
+    return isObject(current) ? current : undefined;
+}
+function nestedValue(root, ...keys) {
+    let current = root;
+    for (const key of keys) {
+        if (!isObject(current))
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+function deleteNestedAndPrune(root, ...keys) {
+    const parents = [root];
+    let current = root;
+    for (const key of keys.slice(0, -1)) {
+        const child = current[key];
+        if (!isObject(child))
+            return;
+        current = child;
+        parents.push(current);
+    }
+    delete current[keys.at(-1)];
+    for (let index = parents.length - 1; index > 0; index--) {
+        if (Object.keys(parents[index]).length)
+            break;
+        delete parents[index - 1][keys[index - 1]];
+    }
+}
+function isStringRecord(value) {
+    return (isObject(value) &&
+        Object.values(value).every((entry) => typeof entry === "string"));
+}
+function unionKeys(a, b) {
+    return [...new Set([...Object.keys(a), ...Object.keys(b)])].sort();
+}
+function normalizeText(value) {
+    return value
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .join("\n");
+}
+function normalizePythonName(value) {
+    return value.trim().toLowerCase().replace(/[_.]+/g, "-");
+}
+function isSafeNpmSpecifier(value) {
+    return Boolean(value) && !/[:/\\]|^(?:\.|git\+)|\s@\s/i.test(value);
+}
+function isSafePythonRequirement(value) {
+    return !/(?:\s@\s|https?:|git\+|file:|^\s*-)/i.test(value);
+}