@aiot-nexus/plugin-sdk 3.0.2 → 3.1.1

package/dist/src/upgrade.js

@@ -0,0 +1,1198 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPluginSdkUpgradeResult = exports.runPluginSdkUpgrade = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const url_1 = require("url");
+const sdk_info_1 = require("./sdk-info");
+const sdkPackageName = "@aiot-nexus/plugin-sdk";
+const strictVersionPattern = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/;
+const pluginIdPattern = /^[a-z0-9][a-z0-9._-]{1,63}$/;
+const supportedLockfileVersions = new Set([1, 2]);
+const commandOutputLimit = 64 * 1024 * 1024;
+const recoveryDirectoryName = ".nexus-plugin-upgrade-recovery";
+const migrationGuideUrl = "https://github.com/ke4nec/aiot-nexus/blob/master/docs/plugin-framework-v2-v3-migration.md";
+function runPluginSdkUpgrade(options, runtime = defaultRuntime()) {
+    const projectDirectory = path.resolve(options.projectDirectory);
+    const result = createResult(projectDirectory, options.sdkSource || sdk_info_1.PLUGIN_SDK_VERSION);
+    let inspection;
+    try {
+        inspection = inspectUpgrade(options, runtime, result);
+    }
+    catch (error) {
+        addCheck(result, "upgrade", "failed", errorMessage(error));
+        return result;
+    }
+    if (hasFailedCheck(result)) {
+        return result;
+    }
+    if (!inspection.needsUpgrade) {
+        try {
+            verifyInstalledState(inspection, runtime);
+        }
+        catch (error) {
+            addCheck(result, "installed SDK", "failed", errorMessage(error));
+            return result;
+        }
+        result.status = "up-to-date";
+        return result;
+    }
+    result.status = "upgrade-available";
+    result.changedFiles = plannedChangedFiles(inspection);
+    if (options.checkOnly) {
+        addCheck(result, "project checks", "skipped", "Check mode does not install dependencies or run project scripts.");
+        return result;
+    }
+    return applyUpgrade(inspection, options, runtime);
+}
+exports.runPluginSdkUpgrade = runPluginSdkUpgrade;
+function formatPluginSdkUpgradeResult(result) {
+    const lines = [
+        "Plugin SDK upgrade: " + result.status,
+        "Project: " + result.projectDirectory,
+        "Current SDK: " + (result.currentVersion || "unknown"),
+        "Target SDK: " + result.targetVersion,
+        "Source: " + result.source,
+    ];
+    if (result.dependencySection) {
+        lines.push("Dependency section: " + result.dependencySection);
+    }
+    lines.push("Checks:");
+    for (const check of result.checks) {
+        lines.push("  [" + check.status + "] " + check.name + ": " + check.detail);
+    }
+    lines.push("Changed files:");
+    if (result.changedFiles.length === 0) {
+        lines.push("  (none)");
+    }
+    else {
+        result.changedFiles.forEach((filePath) => lines.push("  - " + filePath));
+    }
+    if (result.rollback) {
+        lines.push("Rollback: " +
+            (result.rollback.succeeded ? "succeeded" : "failed") +
+            ": " +
+            result.rollback.detail);
+    }
+    return lines.join("\n");
+}
+exports.formatPluginSdkUpgradeResult = formatPluginSdkUpgradeResult;
+function inspectUpgrade(options, runtime, result) {
+    const projectDirectory = result.projectDirectory;
+    const packageJsonPath = path.join(projectDirectory, "package.json");
+    assertNoPendingTransaction(projectDirectory);
+    assertRegularFile(packageJsonPath, "Plugin project package.json");
+    const packageJson = readJson(packageJsonPath, "Plugin project package.json");
+    addCheck(result, "project", "passed", "Found an npm plugin project package.json.");
+    assertNpmProject(projectDirectory, result);
+    const packageLockPath = path.join(projectDirectory, "package-lock.json");
+    const packageLockExisted = fs.existsSync(packageLockPath);
+    if (packageLockExisted) {
+        assertRegularFile(packageLockPath, "Plugin project package-lock.json");
+    }
+    const packageLock = packageLockExisted
+        ? readJson(packageLockPath, "Plugin project package-lock.json")
+        : undefined;
+    validatePackageLock(packageLock, result);
+    const dependency = findSdkDependency(packageJson, result);
+    result.dependencySection = dependency.section;
+    const currentVersion = resolveCurrentVersion(projectDirectory, dependency.spec, packageLock, result);
+    result.currentVersion = currentVersion;
+    if (!currentVersion) {
+        addCheck(result, "current SDK", "failed", "The current SDK version could not be resolved. Run npm install before upgrading.");
+    }
+    const npmVersionResult = runtime.runNpm(["--version"], projectDirectory);
+    if (!commandSucceeded(npmVersionResult)) {
+        addCheck(result, "npm", "failed", commandFailure("npm --version", npmVersionResult));
+    }
+    else {
+        const npmVersion = npmVersionResult.stdout.trim();
+        addCheck(result, "npm", isAtLeastVersion(npmVersion, "6.13.4") ? "passed" : "failed", "Detected npm " + npmVersion + "; required " + sdk_info_1.PLUGIN_SDK_NPM_ENGINE + ".");
+    }
+    const nodeVersion = runtime.nodeVersion.replace(/^v/, "");
+    addCheck(result, "Node.js", isSupportedNodeVersion(nodeVersion) ? "passed" : "failed", "Detected Node " +
+        nodeVersion +
+        "; required " +
+        sdk_info_1.PLUGIN_SDK_NODE_ENGINE +
+        ".");
+    validateProjectBaseline(packageJson, result);
+    const normalizedSource = normalizeSdkSource(options.sdkSource || sdk_info_1.PLUGIN_SDK_VERSION, options.workingDirectory, projectDirectory, runtime, result);
+    result.source = normalizedSource.display;
+    if (currentVersion) {
+        const comparison = compareVersions(sdk_info_1.PLUGIN_SDK_VERSION, currentVersion);
+        if (comparison < 0) {
+            addCheck(result, "version direction", "failed", "SDK downgrade is not supported: " +
+                currentVersion +
+                " -> " +
+                sdk_info_1.PLUGIN_SDK_VERSION +
+                ".");
+        }
+        else if (majorVersion(currentVersion) !== majorVersion(sdk_info_1.PLUGIN_SDK_VERSION) &&
+            !options.allowMajor) {
+            addCheck(result, "major version", "failed", "Major SDK upgrade requires --allow-major and the matching framework migration guide: " +
+                migrationGuideUrl +
+                " (" +
+                currentVersion +
+                " -> " +
+                sdk_info_1.PLUGIN_SDK_VERSION +
+                ").");
+        }
+        else {
+            addCheck(result, "version direction", "passed", currentVersion + " -> " + sdk_info_1.PLUGIN_SDK_VERSION + ".");
+        }
+    }
+    const currentManagedArchivePath = resolveManagedArchivePath(dependency.spec, projectDirectory);
+    validateManagedArchivePaths(normalizedSource.vendoredArchivePath, currentManagedArchivePath, result);
+    const builtPackagePath = resolveBuiltPackagePath(packageJson, projectDirectory, result);
+    const installedVersion = readInstalledSdkVersion(projectDirectory);
+    const lockedVersion = readLockedSdkVersion(packageLock);
+    const needsUpgrade = dependency.spec !== normalizedSource.dependencySpec ||
+        installedVersion !== sdk_info_1.PLUGIN_SDK_VERSION ||
+        !packageLockExisted ||
+        lockedVersion !== sdk_info_1.PLUGIN_SDK_VERSION;
+    addCheck(result, "SDK dependency", needsUpgrade ? "warning" : "passed", needsUpgrade
+        ? "The SDK dependency, lockfile, or installed package must be synchronized."
+        : "package.json, package-lock.json, and node_modules already use SDK " +
+            sdk_info_1.PLUGIN_SDK_VERSION +
+            ".");
+    return {
+        result,
+        packageJson,
+        packageJsonPath,
+        packageLockPath,
+        packageLockExisted,
+        dependencySection: dependency.section,
+        normalizedSource,
+        currentManagedArchivePath,
+        builtPackagePath,
+        needsUpgrade,
+    };
+}
+function applyUpgrade(inspection, options, runtime) {
+    const result = inspection.result;
+    const snapshotPaths = [
+        inspection.packageJsonPath,
+        inspection.packageLockPath,
+    ];
+    if (inspection.normalizedSource.vendoredArchivePath) {
+        snapshotPaths.push(inspection.normalizedSource.vendoredArchivePath);
+    }
+    if (inspection.currentManagedArchivePath) {
+        snapshotPaths.push(inspection.currentManagedArchivePath);
+    }
+    if (inspection.builtPackagePath) {
+        snapshotPaths.push(inspection.builtPackagePath);
+    }
+    let transaction;
+    try {
+        transaction = createUpgradeTransaction(inspection, Array.from(new Set(snapshotPaths)));
+    }
+    catch (error) {
+        addCheck(result, "upgrade snapshot", "failed", errorMessage(error));
+        return result;
+    }
+    try {
+        writeTransactionJournal(transaction, "installing");
+        prepareLocalArchive(inspection.normalizedSource);
+        const saveFlag = inspection.dependencySection === "devDependencies"
+            ? "--save-dev"
+            : "--save";
+        const installResult = runtime.runNpm([
+            "install",
+            saveFlag,
+            "--save-exact",
+            inspection.normalizedSource.installSpec,
+        ], result.projectDirectory);
+        if (!commandSucceeded(installResult)) {
+            throw new Error(commandFailure("npm install", installResult));
+        }
+        addCheck(result, "npm install", "passed", "SDK dependency and npm installation state were synchronized.");
+        verifyInstalledState(inspection, runtime);
+        writeTransactionJournal(transaction, "verifying");
+        if (options.skipProjectChecks) {
+            addCheck(result, "project checks", "skipped", "Skipped typecheck and build by explicit request.");
+        }
+        else {
+            verifyProject(inspection, runtime);
+        }
+        removeCurrentManagedArchive(inspection);
+        result.changedFiles = changedFiles(transaction.snapshots, result.projectDirectory);
+        if (!result.changedFiles.includes("node_modules/@aiot-nexus/plugin-sdk")) {
+            result.changedFiles.push("node_modules/@aiot-nexus/plugin-sdk");
+        }
+        writeTransactionJournal(transaction, "committed");
+        try {
+            cleanupUpgradeTransaction(transaction);
+            result.status = "upgraded";
+        }
+        catch (error) {
+            addCheck(result, "transaction cleanup", "failed", errorMessage(error));
+            addChangedFile(result, recoveryDirectoryName);
+            result.status = "blocked";
+        }
+        return result;
+    }
+    catch (error) {
+        addCheck(result, "upgrade", "failed", errorMessage(error));
+        tryWriteTransactionJournal(transaction, "rolling-back", errorMessage(error));
+        result.rollback = rollbackUpgrade(inspection, transaction.snapshots, runtime);
+        result.changedFiles = changedFiles(transaction.snapshots, result.projectDirectory);
+        if (result.rollback.succeeded) {
+            try {
+                writeTransactionJournal(transaction, "rolled-back");
+                cleanupUpgradeTransaction(transaction);
+            }
+            catch (cleanupError) {
+                result.rollback = {
+                    attempted: true,
+                    succeeded: false,
+                    detail: result.rollback.detail +
+                        " Recovery data could not be removed: " +
+                        errorMessage(cleanupError),
+                };
+            }
+        }
+        else {
+            tryWriteTransactionJournal(transaction, "rollback-failed", result.rollback.detail);
+        }
+        if (!result.rollback.succeeded) {
+            addChangedFile(result, "node_modules/@aiot-nexus/plugin-sdk");
+            addChangedFile(result, recoveryDirectoryName);
+        }
+        result.status = result.rollback.succeeded ? "rolled-back" : "blocked";
+        return result;
+    }
+}
+function verifyInstalledState(inspection, runtime) {
+    const projectDirectory = inspection.result.projectDirectory;
+    const packageJson = readJson(inspection.packageJsonPath, "Updated package.json");
+    const dependencies = asRecord(packageJson[inspection.dependencySection]);
+    if (!dependencies ||
+        dependencies[sdkPackageName] !== inspection.normalizedSource.dependencySpec) {
+        throw new Error("npm install did not write the expected exact SDK dependency spec.");
+    }
+    const installedPackagePath = path.join(projectDirectory, "node_modules", "@aiot-nexus", "plugin-sdk", "package.json");
+    const installedPackage = readJson(installedPackagePath, "Installed SDK package.json");
+    if (installedPackage.name !== sdkPackageName ||
+        installedPackage.version !== sdk_info_1.PLUGIN_SDK_VERSION) {
+        throw new Error("Installed SDK version does not match " + sdk_info_1.PLUGIN_SDK_VERSION + ".");
+    }
+    const lock = readJson(inspection.packageLockPath, "Updated package-lock.json");
+    if (readLockedSdkVersion(lock) !== sdk_info_1.PLUGIN_SDK_VERSION) {
+        throw new Error("package-lock.json does not resolve SDK " + sdk_info_1.PLUGIN_SDK_VERSION + ".");
+    }
+    const installedCliPath = path.join(projectDirectory, "node_modules", "@aiot-nexus", "plugin-sdk", "dist", "src", "cli.js");
+    assertRegularFile(installedCliPath, "Installed SDK CLI");
+    const infoResult = runtime.runNode([installedCliPath, "info", "--json"], projectDirectory);
+    if (!commandSucceeded(infoResult)) {
+        throw new Error(commandFailure("installed nexus-plugin info --json", infoResult));
+    }
+    const installedInfo = parseJsonText(infoResult.stdout, "Installed SDK info output");
+    if (installedInfo.sdkVersion !== sdk_info_1.PLUGIN_SDK_VERSION) {
+        throw new Error("Installed SDK CLI reports version " +
+            String(installedInfo.sdkVersion) +
+            ".");
+    }
+    addCheck(inspection.result, "installed SDK", "passed", "Installed CLI reports SDK " + sdk_info_1.PLUGIN_SDK_VERSION + ".");
+}
+function verifyProject(inspection, runtime) {
+    const scripts = asRecord(inspection.packageJson.scripts) || {};
+    let ranProjectCheck = false;
+    if (typeof scripts.typecheck === "string") {
+        runRequiredNpmScript("typecheck", inspection, runtime);
+        ranProjectCheck = true;
+    }
+    else {
+        addCheck(inspection.result, "typecheck", "skipped", "Project does not define a typecheck script.");
+    }
+    if (typeof scripts.build === "string") {
+        runRequiredNpmScript("build", inspection, runtime);
+        ranProjectCheck = true;
+        validateBuiltPlugin(inspection, runtime);
+    }
+    else {
+        addCheck(inspection.result, "build", "skipped", "Project does not define a build script.");
+    }
+    if (!ranProjectCheck) {
+        throw new Error("Project defines neither typecheck nor build; use --skip-project-checks only after manual verification.");
+    }
+}
+function runRequiredNpmScript(scriptName, inspection, runtime) {
+    const commandResult = runtime.runNpm(["run", scriptName], inspection.result.projectDirectory);
+    if (!commandSucceeded(commandResult)) {
+        throw new Error(commandFailure("npm run " + scriptName, commandResult));
+    }
+    addCheck(inspection.result, scriptName, "passed", "npm run " + scriptName + " completed successfully.");
+}
+function validateBuiltPlugin(inspection, runtime) {
+    if (!inspection.builtPackagePath) {
+        addCheck(inspection.result, "package validation", "skipped", "src/manifest.json was not found.");
+        return;
+    }
+    const packageDirectory = inspection.builtPackagePath;
+    assertRegularFile(path.join(packageDirectory, "manifest.json"), "Built plugin manifest");
+    const installedCliPath = path.join(inspection.result.projectDirectory, "node_modules", "@aiot-nexus", "plugin-sdk", "dist", "src", "cli.js");
+    const validation = runtime.runNode([installedCliPath, "validate", packageDirectory], inspection.result.projectDirectory);
+    if (!commandSucceeded(validation)) {
+        throw new Error(commandFailure("built plugin validation", validation));
+    }
+    addCheck(inspection.result, "package validation", "passed", "Validated " +
+        relativePath(inspection.result.projectDirectory, packageDirectory) +
+        ".");
+}
+function rollbackUpgrade(inspection, snapshots, runtime) {
+    try {
+        snapshots.slice().reverse().forEach(restoreSnapshot);
+    }
+    catch (error) {
+        return {
+            attempted: true,
+            succeeded: false,
+            detail: "Could not restore project files: " + errorMessage(error),
+        };
+    }
+    const restoreCommand = inspection.packageLockExisted
+        ? ["ci"]
+        : ["install", "--no-package-lock"];
+    const reinstall = runtime.runNpm(restoreCommand, inspection.result.projectDirectory);
+    if (!commandSucceeded(reinstall)) {
+        return {
+            attempted: true,
+            succeeded: false,
+            detail: commandFailure("npm " + restoreCommand[0] + " after file restoration", reinstall),
+        };
+    }
+    const restoredVersion = readInstalledSdkVersion(inspection.result.projectDirectory);
+    if (inspection.result.currentVersion &&
+        restoredVersion !== inspection.result.currentVersion) {
+        return {
+            attempted: true,
+            succeeded: false,
+            detail: "Project files were restored, but installed SDK is " +
+                String(restoredVersion) +
+                ".",
+        };
+    }
+    if (!inspection.packageLockExisted) {
+        return {
+            attempted: true,
+            succeeded: false,
+            detail: "Project files and SDK were restored, but the complete npm dependency tree cannot be proven without the original package-lock.json. Recovery data was retained; run npm install and the project checks before continuing.",
+        };
+    }
+    return {
+        attempted: true,
+        succeeded: true,
+        detail: "Restored project files and npm installation state.",
+    };
+}
+function validateProjectBaseline(packageJson, result) {
+    const engines = asRecord(packageJson.engines);
+    const projectNodeEngine = engines && engines.node;
+    addCheck(result, "project Node engine", projectNodeEngine === sdk_info_1.PLUGIN_SDK_NODE_ENGINE ? "passed" : "failed", projectNodeEngine === sdk_info_1.PLUGIN_SDK_NODE_ENGINE
+        ? "Project declares " + sdk_info_1.PLUGIN_SDK_NODE_ENGINE + "."
+        : "Expected engines.node " +
+            sdk_info_1.PLUGIN_SDK_NODE_ENGINE +
+            "; found " +
+            String(projectNodeEngine || "missing") +
+            ".");
+    validateExactDependency(packageJson, "electron", sdk_info_1.PLUGIN_SDK_ELECTRON_VERSION, result);
+    validateExactDependency(packageJson, "typescript", sdk_info_1.PLUGIN_SDK_TYPESCRIPT_VERSION, result);
+    validateExactDependency(packageJson, "@types/node", sdk_info_1.PLUGIN_SDK_TYPES_NODE_VERSION, result);
+}
+function validateExactDependency(packageJson, dependencyName, expectedVersion, result) {
+    const locations = ["dependencies", "devDependencies"]
+        .map((section) => asRecord(packageJson[section]))
+        .filter((section) => Boolean(section && dependencyName in section));
+    const values = locations.map((section) => section[dependencyName]);
+    const passed = values.length === 1 && values[0] === expectedVersion;
+    addCheck(result, dependencyName, passed ? "passed" : "failed", passed
+        ? "Project declares the required exact version " + expectedVersion + "."
+        : "Expected exactly one declaration at " +
+            expectedVersion +
+            "; found " +
+            (values.map(String).join(", ") || "missing") +
+            ".");
+}
+function normalizeSdkSource(value, workingDirectory, projectDirectory, runtime, result) {
+    const source = value.trim();
+    const packagePrefix = sdkPackageName + "@";
+    const version = source.startsWith(packagePrefix)
+        ? source.slice(packagePrefix.length)
+        : source;
+    if (isStrictVersion(version)) {
+        if (version !== sdk_info_1.PLUGIN_SDK_VERSION) {
+            addCheck(result, "SDK source", "failed", "The source version " +
+                version +
+                " does not match the executing CLI version " +
+                sdk_info_1.PLUGIN_SDK_VERSION +
+                ".");
+        }
+        else {
+            addCheck(result, "SDK source", "passed", "Using exact registry version " + version + ".");
+        }
+        return {
+            display: version,
+            dependencySpec: version,
+            installSpec: sdkPackageName + "@" + version,
+        };
+    }
+    let localArchivePath;
+    if (source.startsWith("file:")) {
+        try {
+            localArchivePath = (0, url_1.fileURLToPath)(source);
+        }
+        catch (error) {
+            addCheck(result, "SDK source", "failed", "Invalid SDK file URL: " + errorMessage(error));
+        }
+    }
+    else if (isPathLike(source)) {
+        localArchivePath = path.resolve(workingDirectory, source);
+    }
+    if (!localArchivePath) {
+        addCheck(result, "SDK source", "failed", "SDK source must be an exact X.Y.Z version or a local .tgz path.");
+        return { display: source, dependencySpec: source, installSpec: source };
+    }
+    try {
+        assertRegularFile(localArchivePath, "Local SDK archive", ".tgz");
+    }
+    catch (error) {
+        addCheck(result, "SDK source", "failed", errorMessage(error));
+        return {
+            display: localArchivePath,
+            dependencySpec: source,
+            installSpec: source,
+        };
+    }
+    const archiveInfo = runtime.runNpm([
+        "pack",
+        localArchivePath,
+        "--dry-run",
+        "--ignore-scripts",
+        "--json",
+        "--silent",
+    ], workingDirectory);
+    if (!commandSucceeded(archiveInfo)) {
+        addCheck(result, "SDK source", "failed", commandFailure("npm pack --dry-run", archiveInfo));
+    }
+    else {
+        try {
+            const report = JSON.parse(archiveInfo.stdout.trim());
+            const entry = Array.isArray(report) && report.length === 1
+                ? asRecord(report[0])
+                : undefined;
+            if (!entry ||
+                entry.name !== sdkPackageName ||
+                entry.version !== sdk_info_1.PLUGIN_SDK_VERSION) {
+                throw new Error("Archive must contain " +
+                    sdkPackageName +
+                    "@" +
+                    sdk_info_1.PLUGIN_SDK_VERSION +
+                    "; found " +
+                    String(entry && entry.name) +
+                    "@" +
+                    String(entry && entry.version) +
+                    ".");
+            }
+            addCheck(result, "SDK source", "passed", "Validated local SDK archive " + localArchivePath + ".");
+        }
+        catch (error) {
+            addCheck(result, "SDK source", "failed", errorMessage(error));
+        }
+    }
+    const vendoredRelativePath = "vendor/aiot-nexus-plugin-sdk-" + sdk_info_1.PLUGIN_SDK_VERSION + ".tgz";
+    return {
+        display: localArchivePath,
+        dependencySpec: "file:" + vendoredRelativePath,
+        installSpec: "file:" + vendoredRelativePath,
+        localArchivePath,
+        vendoredArchivePath: path.join(projectDirectory, ...vendoredRelativePath.split("/")),
+    };
+}
+function assertNpmProject(projectDirectory, result) {
+    const conflictingLocks = ["yarn.lock", "pnpm-lock.yaml"].filter((name) => fs.existsSync(path.join(projectDirectory, name)));
+    if (conflictingLocks.length > 0) {
+        addCheck(result, "package manager", "failed", "Only npm projects are supported; found " +
+            conflictingLocks.join(", ") +
+            ".");
+    }
+    else {
+        addCheck(result, "package manager", "passed", "No Yarn or pnpm lockfile was found.");
+    }
+}
+function validatePackageLock(packageLock, result) {
+    if (!packageLock) {
+        addCheck(result, "package-lock.json", "warning", "No lockfile exists; npm install will create one.");
+        return;
+    }
+    const version = packageLock.lockfileVersion;
+    if (typeof version !== "number" || !supportedLockfileVersions.has(version)) {
+        addCheck(result, "package-lock.json", "failed", "Supported lockfileVersion values are 1 and 2; found " +
+            String(version) +
+            ".");
+        return;
+    }
+    addCheck(result, "package-lock.json", "passed", "Using npm lockfileVersion " + String(version) + ".");
+}
+function validateManagedArchivePaths(vendoredArchivePath, currentManagedArchivePath, result) {
+    if (!vendoredArchivePath && !currentManagedArchivePath) {
+        return;
+    }
+    const archivePaths = [vendoredArchivePath, currentManagedArchivePath].filter((value) => Boolean(value));
+    const vendorDirectories = Array.from(new Set(archivePaths.map((filePath) => path.dirname(filePath))));
+    try {
+        for (const directory of vendorDirectories) {
+            if (!fs.existsSync(directory)) {
+                continue;
+            }
+            const stat = fs.lstatSync(directory);
+            if (!stat.isDirectory() || stat.isSymbolicLink()) {
+                throw new Error("Managed SDK vendor path must be a regular directory and cannot be a symbolic link: " +
+                    directory);
+            }
+        }
+        for (const archivePath of archivePaths) {
+            if (fs.existsSync(archivePath)) {
+                assertRegularFile(archivePath, "Managed SDK archive", ".tgz");
+            }
+        }
+        if (currentManagedArchivePath &&
+            !fs.existsSync(currentManagedArchivePath)) {
+            throw new Error("The current vendored SDK archive is missing: " +
+                currentManagedArchivePath);
+        }
+        addCheck(result, "managed SDK archive", "passed", "Vendor directory and managed archive paths are regular filesystem entries.");
+    }
+    catch (error) {
+        addCheck(result, "managed SDK archive", "failed", errorMessage(error));
+    }
+}
+function resolveManagedArchivePath(dependencySpec, projectDirectory) {
+    const normalizedSpec = dependencySpec.replace(/\\/g, "/");
+    const match = /^file:vendor\/(aiot-nexus-plugin-sdk(?:-[0-9]+\.[0-9]+\.[0-9]+)?\.tgz)$/.exec(normalizedSpec);
+    if (!match) {
+        return undefined;
+    }
+    const archivePath = path.join(projectDirectory, "vendor", match[1]);
+    assertProjectPath(projectDirectory, archivePath, "Managed SDK archive");
+    return archivePath;
+}
+function resolveBuiltPackagePath(packageJson, projectDirectory, result) {
+    const scripts = asRecord(packageJson.scripts);
+    if (!scripts || typeof scripts.build !== "string") {
+        return undefined;
+    }
+    const sourceManifestPath = path.join(projectDirectory, "src", "manifest.json");
+    if (!fs.existsSync(sourceManifestPath)) {
+        return undefined;
+    }
+    try {
+        assertRegularFile(sourceManifestPath, "Source plugin manifest", ".json");
+        const sourceManifest = readJson(sourceManifestPath, "Source plugin manifest");
+        if (typeof sourceManifest.pluginId !== "string" ||
+            !pluginIdPattern.test(sourceManifest.pluginId)) {
+            throw new Error("Source plugin manifest pluginId must match " +
+                pluginIdPattern.source +
+                ".");
+        }
+        const packageDirectory = path.join(projectDirectory, "dist", sourceManifest.pluginId);
+        assertProjectPath(projectDirectory, packageDirectory, "Built plugin package");
+        return packageDirectory;
+    }
+    catch (error) {
+        addCheck(result, "package output", "failed", errorMessage(error));
+        return undefined;
+    }
+}
+function findSdkDependency(packageJson, result) {
+    const found = [];
+    for (const section of ["dependencies", "devDependencies"]) {
+        const dependencies = asRecord(packageJson[section]);
+        if (dependencies && sdkPackageName in dependencies) {
+            const spec = dependencies[sdkPackageName];
+            if (typeof spec !== "string" || !spec.trim()) {
+                addCheck(result, "SDK dependency", "failed", section + " contains an invalid SDK dependency spec.");
+            }
+            else {
+                found.push({ section, spec });
+            }
+        }
+    }
+    if (found.length === 0) {
+        addCheck(result, "SDK dependency", "failed", "Project does not declare " + sdkPackageName + ".");
+        return { section: "devDependencies", spec: "" };
+    }
+    if (found.length > 1) {
+        addCheck(result, "SDK dependency", "failed", "SDK is declared in both dependencies and devDependencies.");
+    }
+    else {
+        addCheck(result, "SDK dependency location", "passed", "SDK is declared in " + found[0].section + ".");
+    }
+    return found[0];
+}
+function resolveCurrentVersion(projectDirectory, dependencySpec, packageLock, result) {
+    const candidates = [
+        readInstalledSdkVersion(projectDirectory),
+        readLockedSdkVersion(packageLock),
+        isStrictVersion(dependencySpec) ? dependencySpec : undefined,
+    ].filter((value) => Boolean(value));
+    const versions = Array.from(new Set(candidates));
+    if (versions.length > 1) {
+        addCheck(result, "current SDK", "failed", "SDK dependency state is inconsistent: " + versions.join(", ") + ".");
+        return versions[0];
+    }
+    if (versions.length === 1) {
+        addCheck(result, "current SDK", "passed", "Resolved current SDK " + versions[0] + ".");
+        return versions[0];
+    }
+    return null;
+}
+function readInstalledSdkVersion(projectDirectory) {
+    const packagePath = path.join(projectDirectory, "node_modules", "@aiot-nexus", "plugin-sdk", "package.json");
+    if (!fs.existsSync(packagePath)) {
+        return undefined;
+    }
+    try {
+        const packageJson = readJson(packagePath, "Installed SDK package.json");
+        return packageJson.name === sdkPackageName &&
+            isStrictVersion(packageJson.version)
+            ? packageJson.version
+            : undefined;
+    }
+    catch (_error) {
+        return undefined;
+    }
+}
+function readLockedSdkVersion(packageLock) {
+    if (!packageLock) {
+        return undefined;
+    }
+    const packages = asRecord(packageLock.packages);
+    const installed = packages && asRecord(packages["node_modules/@aiot-nexus/plugin-sdk"]);
+    if (installed && isStrictVersion(installed.version)) {
+        return installed.version;
+    }
+    const dependencies = asRecord(packageLock.dependencies);
+    const sdk = dependencies && asRecord(dependencies[sdkPackageName]);
+    return sdk && isStrictVersion(sdk.version) ? sdk.version : undefined;
+}
+function prepareLocalArchive(source) {
+    if (!source.localArchivePath || !source.vendoredArchivePath) {
+        return;
+    }
+    if (samePath(source.localArchivePath, source.vendoredArchivePath)) {
+        return;
+    }
+    fs.mkdirSync(path.dirname(source.vendoredArchivePath), { recursive: true });
+    fs.copyFileSync(source.localArchivePath, source.vendoredArchivePath);
+}
+function removeCurrentManagedArchive(inspection) {
+    if (!inspection.currentManagedArchivePath) {
+        return;
+    }
+    const targetArchivePath = inspection.normalizedSource.vendoredArchivePath;
+    if (!targetArchivePath ||
+        !samePath(inspection.currentManagedArchivePath, targetArchivePath)) {
+        fs.rmSync(inspection.currentManagedArchivePath, { force: true });
+    }
+}
+function plannedChangedFiles(inspection) {
+    const files = [
+        "package.json",
+        "package-lock.json",
+        "node_modules/@aiot-nexus/plugin-sdk",
+    ];
+    const projectDirectory = inspection.result.projectDirectory;
+    if (inspection.normalizedSource.vendoredArchivePath) {
+        files.push(relativePath(projectDirectory, inspection.normalizedSource.vendoredArchivePath));
+    }
+    if (inspection.currentManagedArchivePath) {
+        files.push(relativePath(projectDirectory, inspection.currentManagedArchivePath));
+    }
+    if (inspection.builtPackagePath) {
+        files.push(relativePath(projectDirectory, inspection.builtPackagePath));
+    }
+    return Array.from(new Set(files));
+}
+function restoreSnapshot(snapshot) {
+    removePath(snapshot.filePath);
+    if (snapshot.kind === "missing") {
+        return;
+    }
+    if (!snapshot.backupPath) {
+        throw new Error("Recovery snapshot is missing its backup path: " + snapshot.filePath);
+    }
+    fs.mkdirSync(path.dirname(snapshot.filePath), { recursive: true });
+    if (snapshot.kind === "file") {
+        fs.copyFileSync(snapshot.backupPath, snapshot.filePath);
+        if (snapshot.mode !== undefined) {
+            fs.chmodSync(snapshot.filePath, snapshot.mode);
+        }
+        return;
+    }
+    copyDirectory(snapshot.backupPath, snapshot.filePath);
+}
+function changedFiles(snapshots, projectDirectory) {
+    return snapshots
+        .filter(snapshotChanged)
+        .map((snapshot) => relativePath(projectDirectory, snapshot.filePath));
+}
+function assertNoPendingTransaction(projectDirectory) {
+    const transactionDirectory = path.join(projectDirectory, recoveryDirectoryName);
+    if (!fs.existsSync(transactionDirectory)) {
+        return;
+    }
+    const stat = fs.lstatSync(transactionDirectory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error("SDK upgrade recovery path is not a regular directory: " +
+            transactionDirectory);
+    }
+    const journalPath = path.join(transactionDirectory, "recovery.json");
+    let phase = "unknown";
+    if (fs.existsSync(journalPath)) {
+        try {
+            const journal = readJson(journalPath, "SDK upgrade recovery journal");
+            if (typeof journal.phase === "string") {
+                phase = journal.phase;
+            }
+        }
+        catch (_error) {
+            phase = "invalid-journal";
+        }
+    }
+    const recoveryInstruction = phase === "committed"
+        ? "The upgrade reached the committed phase. Verify the target SDK, lockfile, and project checks, then remove the recovery directory; do not restore the backups unless you intentionally revert."
+        : phase === "rolled-back"
+            ? "The rollback completed. Verify the original SDK and project checks, then remove the recovery directory."
+            : "Restore the files listed in recovery.json from its backups, then run npm ci when the original lockfile existed or npm install otherwise.";
+    throw new Error("A retained SDK upgrade recovery transaction was found at " +
+        transactionDirectory +
+        " (phase: " +
+        phase +
+        "). " +
+        recoveryInstruction +
+        " Do not delete the directory until the project is verified.");
+}
+function createUpgradeTransaction(inspection, snapshotPaths) {
+    const projectDirectory = inspection.result.projectDirectory;
+    const directory = path.join(projectDirectory, recoveryDirectoryName);
+    assertProjectPath(projectDirectory, directory, "SDK upgrade recovery directory");
+    if (fs.existsSync(directory)) {
+        throw new Error("SDK upgrade recovery directory already exists: " + directory);
+    }
+    fs.mkdirSync(directory);
+    const backupRoot = path.join(directory, "backups");
+    fs.mkdirSync(backupRoot);
+    const transaction = {
+        directory,
+        journalPath: path.join(directory, "recovery.json"),
+        projectDirectory,
+        currentVersion: inspection.result.currentVersion,
+        targetVersion: inspection.result.targetVersion,
+        packageLockExisted: inspection.packageLockExisted,
+        snapshots: [],
+    };
+    try {
+        transaction.snapshots = snapshotPaths.map((filePath, index) => snapshotPath(projectDirectory, filePath, path.join(backupRoot, String(index))));
+        writeTransactionJournal(transaction, "prepared");
+        return transaction;
+    }
+    catch (error) {
+        let retainedDetail = "";
+        try {
+            cleanupUpgradeTransaction(transaction);
+        }
+        catch (cleanupError) {
+            retainedDetail =
+                " Recovery data remains at " +
+                    directory +
+                    ": " +
+                    errorMessage(cleanupError) +
+                    ".";
+        }
+        throw new Error("Could not create the durable SDK upgrade recovery snapshot: " +
+            errorMessage(error) +
+            "." +
+            retainedDetail);
+    }
+}
+function snapshotPath(projectDirectory, filePath, backupPath) {
+    assertProjectPath(projectDirectory, filePath, "SDK upgrade snapshot target");
+    if (!fs.existsSync(filePath)) {
+        return { filePath, kind: "missing" };
+    }
+    const stat = fs.lstatSync(filePath);
+    if (stat.isSymbolicLink()) {
+        throw new Error("SDK upgrade snapshot targets cannot be symbolic links: " + filePath);
+    }
+    if (stat.isFile()) {
+        fs.copyFileSync(filePath, backupPath);
+        fs.chmodSync(backupPath, stat.mode);
+        flushFile(backupPath);
+        return { filePath, kind: "file", backupPath, mode: stat.mode };
+    }
+    if (stat.isDirectory()) {
+        copyDirectory(filePath, backupPath);
+        return { filePath, kind: "directory", backupPath, mode: stat.mode };
+    }
+    throw new Error("SDK upgrade snapshot targets must be regular files or directories: " +
+        filePath);
+}
+function writeTransactionJournal(transaction, phase, detail) {
+    const journal = {
+        schemaVersion: 1,
+        phase,
+        detail: detail || null,
+        projectDirectory: transaction.projectDirectory,
+        currentVersion: transaction.currentVersion,
+        targetVersion: transaction.targetVersion,
+        packageLockExisted: transaction.packageLockExisted,
+        recoveryInstallCommand: transaction.packageLockExisted
+            ? "npm ci"
+            : "npm install",
+        snapshots: transaction.snapshots.map((snapshot) => ({
+            path: relativePath(transaction.projectDirectory, snapshot.filePath),
+            kind: snapshot.kind,
+            backup: snapshot.backupPath
+                ? relativePath(transaction.directory, snapshot.backupPath)
+                : null,
+            mode: snapshot.mode === undefined ? null : snapshot.mode,
+        })),
+    };
+    const temporaryPath = transaction.journalPath + ".tmp";
+    fs.writeFileSync(temporaryPath, JSON.stringify(journal, null, 2) + "\n", "utf8");
+    flushFile(temporaryPath);
+    fs.rmSync(transaction.journalPath, { force: true });
+    fs.renameSync(temporaryPath, transaction.journalPath);
+}
+function tryWriteTransactionJournal(transaction, phase, detail) {
+    try {
+        writeTransactionJournal(transaction, phase, detail);
+    }
+    catch (_error) {
+        // The recovery directory and its backups remain the primary recovery evidence.
+    }
+}
+function cleanupUpgradeTransaction(transaction) {
+    const expectedDirectory = path.join(transaction.projectDirectory, recoveryDirectoryName);
+    if (!samePath(transaction.directory, expectedDirectory)) {
+        throw new Error("Refusing to remove an unexpected SDK recovery directory: " +
+            transaction.directory);
+    }
+    if (!fs.existsSync(transaction.directory)) {
+        return;
+    }
+    const stat = fs.lstatSync(transaction.directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error("Refusing to remove a non-directory SDK recovery path: " +
+            transaction.directory);
+    }
+    fs.rmSync(transaction.directory, { recursive: true, force: true });
+}
+function snapshotChanged(snapshot) {
+    if (snapshot.kind === "missing") {
+        return fs.existsSync(snapshot.filePath);
+    }
+    if (!fs.existsSync(snapshot.filePath) || !snapshot.backupPath) {
+        return true;
+    }
+    const stat = fs.lstatSync(snapshot.filePath);
+    if (stat.isSymbolicLink()) {
+        return true;
+    }
+    if (snapshot.kind === "file") {
+        return (!stat.isFile() || !filesEqual(snapshot.filePath, snapshot.backupPath));
+    }
+    return (!stat.isDirectory() ||
+        !directoriesEqual(snapshot.filePath, snapshot.backupPath));
+}
+function filesEqual(left, right) {
+    const leftStat = fs.statSync(left);
+    const rightStat = fs.statSync(right);
+    return (leftStat.size === rightStat.size &&
+        fs.readFileSync(left).equals(fs.readFileSync(right)));
+}
+function directoriesEqual(left, right) {
+    const leftEntries = fs
+        .readdirSync(left, { withFileTypes: true })
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const rightEntries = fs
+        .readdirSync(right, { withFileTypes: true })
+        .sort((a, b) => a.name.localeCompare(b.name));
+    if (leftEntries.length !== rightEntries.length) {
+        return false;
+    }
+    for (let index = 0; index < leftEntries.length; index += 1) {
+        const leftEntry = leftEntries[index];
+        const rightEntry = rightEntries[index];
+        if (leftEntry.name !== rightEntry.name ||
+            leftEntry.isDirectory() !== rightEntry.isDirectory() ||
+            leftEntry.isFile() !== rightEntry.isFile()) {
+            return false;
+        }
+        const leftPath = path.join(left, leftEntry.name);
+        const rightPath = path.join(right, rightEntry.name);
+        if (leftEntry.isDirectory()) {
+            if (!directoriesEqual(leftPath, rightPath)) {
+                return false;
+            }
+        }
+        else if (!leftEntry.isFile() || !filesEqual(leftPath, rightPath)) {
+            return false;
+        }
+    }
+    return true;
+}
+function copyDirectory(sourceDirectory, targetDirectory) {
+    const sourceStat = fs.lstatSync(sourceDirectory);
+    if (!sourceStat.isDirectory() || sourceStat.isSymbolicLink()) {
+        throw new Error("SDK recovery can only copy regular directories: " + sourceDirectory);
+    }
+    fs.mkdirSync(targetDirectory, { recursive: true });
+    fs.chmodSync(targetDirectory, sourceStat.mode);
+    for (const entry of fs.readdirSync(sourceDirectory, {
+        withFileTypes: true,
+    })) {
+        const sourcePath = path.join(sourceDirectory, entry.name);
+        const targetPath = path.join(targetDirectory, entry.name);
+        if (entry.isSymbolicLink()) {
+            throw new Error("SDK recovery directories cannot contain symbolic links: " + sourcePath);
+        }
+        if (entry.isDirectory()) {
+            copyDirectory(sourcePath, targetPath);
+            continue;
+        }
+        if (!entry.isFile()) {
+            throw new Error("SDK recovery encountered an unsupported filesystem entry: " +
+                sourcePath);
+        }
+        const stat = fs.lstatSync(sourcePath);
+        fs.copyFileSync(sourcePath, targetPath);
+        fs.chmodSync(targetPath, stat.mode);
+        flushFile(targetPath);
+    }
+}
+function flushFile(filePath) {
+    const descriptor = fs.openSync(filePath, "r+");
+    try {
+        fs.fsyncSync(descriptor);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+function removePath(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return;
+    }
+    const stat = fs.lstatSync(filePath);
+    fs.rmSync(filePath, {
+        recursive: stat.isDirectory() && !stat.isSymbolicLink(),
+        force: true,
+    });
+}
+function assertProjectPath(projectDirectory, filePath, label) {
+    const relative = path.relative(projectDirectory, path.resolve(filePath));
+    if (!relative ||
+        relative === ".." ||
+        relative.startsWith(".." + path.sep) ||
+        path.isAbsolute(relative)) {
+        throw new Error(label + " must stay inside the plugin project: " + filePath);
+    }
+}
+function addChangedFile(result, filePath) {
+    if (!result.changedFiles.includes(filePath)) {
+        result.changedFiles.push(filePath);
+    }
+}
+function createResult(projectDirectory, source) {
+    return {
+        status: "blocked",
+        projectDirectory,
+        currentVersion: null,
+        targetVersion: sdk_info_1.PLUGIN_SDK_VERSION,
+        source,
+        dependencySection: null,
+        changedFiles: [],
+        checks: [],
+        rollback: null,
+    };
+}
+function addCheck(result, name, status, detail) {
+    result.checks.push({ name, status, detail });
+}
+function hasFailedCheck(result) {
+    return result.checks.some((check) => check.status === "failed");
+}
+function commandSucceeded(result) {
+    return !result.error && result.status === 0;
+}
+function commandFailure(label, result) {
+    if (result.error) {
+        return label + " could not start: " + result.error.message;
+    }
+    const output = (result.stderr || result.stdout).trim();
+    const detail = output.length > 4000 ? output.slice(output.length - 4000) : output;
+    return (label +
+        " failed with exit code " +
+        String(result.status) +
+        (detail ? ": " + detail : "."));
+}
+function defaultRuntime() {
+    return {
+        nodeVersion: process.version,
+        runNpm: (args, cwd) => runNpm(args, cwd),
+        runNode: (args, cwd) => runProcess(process.execPath, args, cwd),
+    };
+}
+function runNpm(args, cwd) {
+    const npmExecPath = process.env.npm_execpath;
+    if (npmExecPath) {
+        return runProcess(process.execPath, [npmExecPath, ...args], cwd);
+    }
+    return runProcess(process.platform === "win32" ? "npm.cmd" : "npm", args, cwd);
+}
+function runProcess(command, args, cwd) {
+    const result = (0, child_process_1.spawnSync)(command, args, {
+        cwd,
+        encoding: "utf8",
+        shell: false,
+        maxBuffer: commandOutputLimit,
+        env: {
+            ...process.env,
+            NEXUS_PLUGIN_SDK_UPDATE_CHECK: "0",
+        },
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout || "",
+        stderr: result.stderr || "",
+        error: result.error,
+    };
+}
+function readJson(filePath, label) {
+    try {
+        const value = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        const record = asRecord(value);
+        if (!record) {
+            throw new Error("root value must be an object");
+        }
+        return record;
+    }
+    catch (error) {
+        throw new Error(label + " is invalid: " + errorMessage(error));
+    }
+}
+function parseJsonText(value, label) {
+    try {
+        const parsed = JSON.parse(value);
+        const record = asRecord(parsed);
+        if (!record) {
+            throw new Error("root value must be an object");
+        }
+        return record;
+    }
+    catch (error) {
+        throw new Error(label + " is invalid: " + errorMessage(error));
+    }
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function assertRegularFile(filePath, label, extension) {
+    if (extension && path.extname(filePath).toLowerCase() !== extension) {
+        throw new Error(label + " must use the " + extension + " extension: " + filePath);
+    }
+    if (!fs.existsSync(filePath)) {
+        throw new Error(label + " does not exist: " + filePath);
+    }
+    const stat = fs.lstatSync(filePath);
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        throw new Error(label +
+            " must be a regular file and cannot be a symbolic link: " +
+            filePath);
+    }
+}
+function isPathLike(value) {
+    return (path.isAbsolute(value) ||
+        value.startsWith(".") ||
+        value.includes("/") ||
+        value.includes("\\") ||
+        value.toLowerCase().endsWith(".tgz"));
+}
+function isStrictVersion(value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    const match = strictVersionPattern.exec(value);
+    return Boolean(match &&
+        [match[1], match[2], match[3]].every((segment) => Number.isSafeInteger(Number(segment))));
+}
+function compareVersions(left, right) {
+    const leftParts = versionParts(left);
+    const rightParts = versionParts(right);
+    for (let index = 0; index < 3; index += 1) {
+        if (leftParts[index] !== rightParts[index]) {
+            return leftParts[index] > rightParts[index] ? 1 : -1;
+        }
+    }
+    return 0;
+}
+function majorVersion(value) {
+    return versionParts(value)[0];
+}
+function isAtLeastVersion(value, minimum) {
+    return isStrictVersion(value) && compareVersions(value, minimum) >= 0;
+}
+function isSupportedNodeVersion(value) {
+    return (isStrictVersion(value) &&
+        majorVersion(value) === 16 &&
+        compareVersions(value, "16.20.0") >= 0);
+}
+function versionParts(value) {
+    const match = strictVersionPattern.exec(value);
+    if (!match) {
+        throw new Error("Version must use X.Y.Z format: " + value);
+    }
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function samePath(left, right) {
+    const normalize = (value) => {
+        const resolved = path.resolve(value).replace(/\\/g, "/");
+        return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+    };
+    return normalize(left) === normalize(right);
+}
+function relativePath(projectDirectory, filePath) {
+    return (path.relative(projectDirectory, filePath).replace(/\\/g, "/") ||
+        path.basename(filePath));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}