@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/tsc-wrapper/core.js

@@ -0,0 +1,697 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearTscResolutionCache = clearTscResolutionCache;
+exports.runAibTsc = runAibTsc;
+exports.runAibTscAsync = runAibTscAsync;
+exports.runAibTscCommand = runAibTscCommand;
+exports.showTscResolution = showTscResolution;
+exports.resolveTsc = resolveTsc;
+exports.formatTscResolutionText = formatTscResolutionText;
+exports.formatTscOutput = formatTscOutput;
+exports.parseTscDiagnostics = parseTscDiagnostics;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_child_process_1 = require("node:child_process");
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const env_vars_1 = require("../config/env-vars");
+const workspace_root_1 = require("../config/workspace-root");
+const buffered_process_1 = require("../runtime/buffered-process");
+const resolutionCache = new Map();
+const DEFAULT_TSC_OUTPUT_CAP_KB = 12;
+const GLOBAL_OUTPUT_CAP_ENV = "AIB_OUTPUT_CAP";
+function clearTscResolutionCache() {
+    resolutionCache.clear();
+}
+function runAibTsc(cwd, rawArgs, env = process.env) {
+    const args = stripLeadingTerminator(rawArgs);
+    const resolution = resolveTsc(cwd, args, env);
+    if (!resolution.ok || !resolution.executable) {
+        throw new errors_1.CliError("TSC_RESOLUTION_FAILED", "Unable to resolve TypeScript compiler.", {
+            project: resolution.project,
+            matched: resolution.matched,
+            configured: resolution.configured,
+            configuredStatus: resolution.configuredStatus,
+            fallback: resolution.fallback,
+            errors: resolution.errors
+        });
+    }
+    const startedAt = Date.now();
+    const spawned = (0, node_child_process_1.spawnSync)(resolution.executable.command, [...resolution.executable.argsPrefix, ...args], {
+        cwd: resolution.cwd,
+        env,
+        encoding: "utf8",
+        windowsHide: true,
+        shell: resolution.executable.shell,
+        maxBuffer: 64 * 1024 * 1024
+    });
+    const exitCode = typeof spawned.status === "number" ? spawned.status : spawned.error ? 127 : 1;
+    const stdout = spawned.stdout ?? "";
+    const stderr = spawned.stderr ?? (spawned.error ? `${spawned.error.message}\n` : "");
+    const rawOutput = `${stdout}${stderr}`;
+    let restOutputPath = null;
+    const formatted = formatTscOutput({
+        rawOutput,
+        exitCode,
+        durationMs: Date.now() - startedAt,
+        warnings: resolution.warnings,
+        outputCapBytes: readTscOutputCapBytes(cwd, env),
+        writeRestOutput: (restOutput) => {
+            restOutputPath = writeTscRestOutputLog(cwd, resolution, restOutput);
+            return restOutputPath;
+        }
+    });
+    return {
+        ok: exitCode === 0,
+        exitCode,
+        stdout,
+        stderr,
+        rawOutput,
+        formatted,
+        logPath: restOutputPath,
+        resolution,
+        spawnError: spawned.error ? spawned.error.message : null
+    };
+}
+async function runAibTscAsync(cwd, rawArgs, env = process.env, signal) {
+    const args = stripLeadingTerminator(rawArgs);
+    const resolution = resolveTsc(cwd, args, env);
+    if (!resolution.ok || !resolution.executable) {
+        throw new errors_1.CliError("TSC_RESOLUTION_FAILED", "Unable to resolve TypeScript compiler.", {
+            project: resolution.project,
+            matched: resolution.matched,
+            configured: resolution.configured,
+            configuredStatus: resolution.configuredStatus,
+            fallback: resolution.fallback,
+            errors: resolution.errors
+        });
+    }
+    const startedAt = Date.now();
+    const spawned = await (0, buffered_process_1.runBufferedProcess)({
+        command: resolution.executable.command,
+        args: [...resolution.executable.argsPrefix, ...args],
+        cwd: resolution.cwd,
+        env,
+        shell: resolution.executable.shell,
+        ...(signal ? { signal } : {})
+    });
+    const exitCode = typeof spawned.status === "number" ? spawned.status : spawned.error ? 127 : 1;
+    const stdout = spawned.stdout;
+    const stderr = spawned.stderr || (spawned.error ? `${spawned.error.message}\n` : "");
+    const rawOutput = `${stdout}${stderr}`;
+    let restOutputPath = null;
+    const formatted = formatTscOutput({
+        rawOutput,
+        exitCode,
+        durationMs: Date.now() - startedAt,
+        warnings: resolution.warnings,
+        outputCapBytes: readTscOutputCapBytes(cwd, env),
+        writeRestOutput: (restOutput) => {
+            restOutputPath = writeTscRestOutputLog(cwd, resolution, restOutput);
+            return restOutputPath;
+        }
+    });
+    return {
+        ok: exitCode === 0,
+        exitCode,
+        stdout,
+        stderr,
+        rawOutput,
+        formatted,
+        logPath: restOutputPath,
+        resolution,
+        spawnError: spawned.error?.message ?? null
+    };
+}
+function runAibTscCommand(cwd, args, env = process.env) {
+    const result = runAibTsc(cwd, args, env);
+    if (result.formatted) {
+        process.stdout.write(result.formatted.endsWith("\n") ? result.formatted : `${result.formatted}\n`);
+    }
+    process.exitCode = result.exitCode;
+}
+function showTscResolution(cwd, rawArgs, env = process.env) {
+    const args = stripLeadingTerminator(rawArgs);
+    const resolution = resolveTsc(cwd, args, env);
+    const response = {
+        ok: resolution.ok,
+        project: resolution.project,
+        matched: resolution.matched,
+        mode: resolution.mode,
+        configured: resolution.configured,
+        configuredStatus: resolution.configuredStatus,
+        resolved: resolution.resolved,
+        resolvedKind: resolution.resolvedKind,
+        fallback: resolution.fallback,
+        cache: resolution.cache,
+        warnings: [...resolution.warnings],
+        errors: [...resolution.errors]
+    };
+    return (0, agent_text_1.attachAgentText)(response, formatTscResolutionText(resolution));
+}
+function resolveTsc(cwd, args, env = process.env) {
+    const resolvedCwd = node_path_1.default.resolve(cwd);
+    const workspace = (0, workspace_root_1.resolveWorkspaceRoot)(resolvedCwd);
+    const root = workspace?.root ?? resolvedCwd;
+    const configRevision = workspace ? readConfigRevision(workspace) : "no-config";
+    const project = resolveProject(resolvedCwd, root, args);
+    const selected = selectConfigEntry(workspace, project.projectDir, resolvedCwd);
+    const cacheKey = [
+        root,
+        configRevision,
+        project.project,
+        project.projectDir,
+        selected.matched,
+        JSON.stringify(selected.entry),
+        env[env_vars_1.CLI_ENV.tscPath] ?? ""
+    ].join("\0");
+    const cached = resolutionCache.get(cacheKey);
+    if (cached?.key === cacheKey && cachedResolutionStillValid(cached.resolution)) {
+        return { ...cached.resolution, cache: "hit" };
+    }
+    const resolution = resolveTscUncached({
+        cwd: resolvedCwd,
+        root,
+        workspace,
+        configRevision,
+        project,
+        selected,
+        env
+    });
+    resolutionCache.set(cacheKey, { key: cacheKey, resolution });
+    return resolution;
+}
+function cachedResolutionStillValid(resolution) {
+    if (resolution.resolvedKind === "configured" || resolution.resolvedKind === "project") {
+        return Boolean(resolution.resolved && node_fs_1.default.existsSync(resolution.resolved) && node_fs_1.default.statSync(resolution.resolved).isFile());
+    }
+    return true;
+}
+function formatTscResolutionText(resolution) {
+    const lines = [
+        "tsc resolver",
+        `project: ${formatPath(resolution.workspaceRoot, resolution.project)}`,
+        `matched: ${resolution.matched}`,
+        `mode: ${resolution.mode}`,
+        `configured: ${resolution.configured ? formatPath(resolution.workspaceRoot, resolution.configured) : "not set"}`,
+        `configuredStatus: ${resolution.configuredStatus}`,
+        `resolved: ${resolution.resolved ? formatPath(resolution.workspaceRoot, resolution.resolved) : "not found"}`,
+        `resolvedKind: ${resolution.resolvedKind}`,
+        `fallback: ${resolution.fallback}`,
+        `cache: ${resolution.cache}`
+    ];
+    if (resolution.warnings.length > 0) {
+        lines.push("warnings:", ...resolution.warnings.map((warning) => `  ${warning}`));
+    }
+    if (resolution.errors.length > 0) {
+        lines.push("errors:", ...resolution.errors.map((error) => `  ${error}`));
+    }
+    return lines.join("\n");
+}
+function formatTscOutput(input) {
+    const diagnostics = parseTscDiagnostics(input.rawOutput);
+    if (input.exitCode === 0 && diagnostics.length === 0) {
+        return "tsc ok";
+    }
+    const lines = [];
+    if ((input.warnings ?? []).length > 0) {
+        lines.push(...(input.warnings ?? []).map((warning) => `warning: ${warning}`), "");
+    }
+    if (diagnostics.length === 0) {
+        lines.push(`tsc failed: exit ${input.exitCode}`);
+        const compact = input.rawOutput.trim();
+        if (compact) {
+            lines.push("", ...compact.split(/\r?\n/).slice(0, 80));
+        }
+        return applyTscOutputCap(lines.join("\n"), input);
+    }
+    const fileCount = new Set(diagnostics.map((diagnostic) => diagnostic.file)).size;
+    lines.push(`tsc failed: ${diagnostics.length} ${plural(diagnostics.length, "error")} in ${fileCount} ${plural(fileCount, "file")}`);
+    lines.push("");
+    const byFile = groupBy(diagnostics, (diagnostic) => diagnostic.file);
+    const files = [...byFile.entries()].sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]));
+    for (const [file, fileDiagnostics] of files) {
+        lines.push(`${file}`);
+        const byMessage = groupBy(fileDiagnostics, (diagnostic) => `${diagnostic.code}\0${diagnostic.message}`);
+        for (const [, group] of byMessage) {
+            const first = group[0];
+            if (!first) {
+                continue;
+            }
+            lines.push(`  ${first.code} ${first.message}`);
+            for (const diagnostic of group) {
+                lines.push(`    ${diagnostic.line}:${diagnostic.column}`);
+            }
+            const details = unique(group.flatMap((diagnostic) => diagnostic.details)).slice(0, 4);
+            for (const detail of details) {
+                lines.push(`    ${truncate(detail, 180)}`);
+            }
+        }
+        lines.push("");
+    }
+    return applyTscOutputCap(lines.join("\n").trimEnd(), input);
+}
+const TSC_DIAGNOSTIC_RE = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.+)$/;
+function parseTscDiagnostics(output) {
+    const lines = output.split(/\r?\n/);
+    const diagnostics = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const match = TSC_DIAGNOSTIC_RE.exec(line);
+        if (!match) {
+            continue;
+        }
+        const details = [];
+        let nextIndex = index + 1;
+        while (nextIndex < lines.length) {
+            const next = lines[nextIndex] ?? "";
+            if (TSC_DIAGNOSTIC_RE.test(next) || !/^\s+\S/.test(next)) {
+                break;
+            }
+            details.push(next.trim());
+            nextIndex += 1;
+        }
+        diagnostics.push({
+            file: normalizeSlashes(match[1] ?? ""),
+            line: Number(match[2] ?? 0),
+            column: Number(match[3] ?? 0),
+            level: match[4] === "warning" ? "warning" : "error",
+            code: match[5] ?? "TS0000",
+            message: match[6] ?? "",
+            details
+        });
+        index = nextIndex - 1;
+    }
+    return diagnostics;
+}
+function resolveTscUncached(input) {
+    const warnings = [];
+    const errors = [];
+    const entry = input.selected.entry;
+    const envTsc = readString(input.env[env_vars_1.CLI_ENV.tscPath]);
+    const configured = envTsc ?? (entry.tsc ? resolveMaybeRelative(input.root, entry.tsc) : null);
+    const configuredStatus = configured ? fileStatus(configured) : "not-configured";
+    const mode = entry.mode ?? (configured ? "project" : "project");
+    const fallback = entry.fallback ?? (configured ? "project" : "path");
+    if (configured && configuredStatus === "exists") {
+        return makeResolution(input, {
+            mode,
+            configured,
+            configuredStatus,
+            resolved: configured,
+            resolvedKind: "configured",
+            fallback: "not used",
+            warnings,
+            errors,
+            executable: executableForPath(configured)
+        });
+    }
+    if (configured && configuredStatus !== "exists") {
+        warnings.push(`configured tsc ${configuredStatus}: ${formatPath(input.root, configured)}`);
+        if (fallback === "none") {
+            errors.push("configured tsc is not available and fallback is none");
+            return makeResolution(input, {
+                mode,
+                configured,
+                configuredStatus,
+                resolved: null,
+                resolvedKind: "missing",
+                fallback,
+                warnings,
+                errors,
+                executable: null
+            });
+        }
+    }
+    if (mode === "path") {
+        const pathExecutable = pathExecutableForTsc(input.env);
+        return makeResolution(input, {
+            mode,
+            configured,
+            configuredStatus,
+            resolved: pathExecutable.display,
+            resolvedKind: "path",
+            fallback: configured ? fallback : "not used",
+            warnings,
+            errors,
+            executable: pathExecutable
+        });
+    }
+    if (!configured || fallback === "project") {
+        const projectLocal = findProjectLocalTsc(input.project.projectDir, input.root);
+        if (projectLocal) {
+            return makeResolution(input, {
+                mode,
+                configured,
+                configuredStatus,
+                resolved: projectLocal,
+                resolvedKind: "project",
+                fallback: configured ? fallback : "not used",
+                warnings,
+                errors,
+                executable: executableForPath(projectLocal)
+            });
+        }
+        warnings.push(`project-local tsc not found from ${formatPath(input.root, input.project.projectDir)}`);
+    }
+    if ((!configured && fallback === "path") || (configured && fallback === "path")) {
+        const pathExecutable = pathExecutableForTsc(input.env);
+        return makeResolution(input, {
+            mode,
+            configured,
+            configuredStatus,
+            resolved: pathExecutable.display,
+            resolvedKind: "path",
+            fallback: configured ? fallback : "path",
+            warnings,
+            errors,
+            executable: pathExecutable
+        });
+    }
+    errors.push("tsc was not found");
+    return makeResolution(input, {
+        mode,
+        configured,
+        configuredStatus,
+        resolved: null,
+        resolvedKind: "missing",
+        fallback,
+        warnings,
+        errors,
+        executable: null
+    });
+}
+function makeResolution(input, fields) {
+    return {
+        ok: fields.errors.length === 0 && fields.executable !== null,
+        cwd: input.cwd,
+        workspaceRoot: input.root,
+        configPath: input.workspace?.configPath ?? null,
+        configRevision: input.configRevision,
+        project: input.project.project,
+        projectDir: input.project.projectDir,
+        matched: input.selected.matched,
+        cache: "refreshed",
+        ...fields
+    };
+}
+function selectConfigEntry(workspace, projectDir, cwd) {
+    const config = workspace?.config ?? {};
+    const tsc = readObject(config.tsc);
+    const byPath = readObject(tsc?.byPath);
+    const defaultEntry = normalizeConfigEntry(tsc?.default) ?? { mode: "project", fallback: "path" };
+    if (!workspace || !byPath) {
+        return { matched: "default", entry: defaultEntry };
+    }
+    const candidates = [];
+    for (const [key, rawEntry] of Object.entries(byPath)) {
+        const entry = normalizeConfigEntry(rawEntry);
+        if (!entry) {
+            continue;
+        }
+        candidates.push({
+            key,
+            absolute: node_path_1.default.resolve(workspace.root, key),
+            entry
+        });
+    }
+    candidates.sort((left, right) => right.absolute.length - left.absolute.length);
+    const targetDirs = [projectDir, cwd].map((value) => node_path_1.default.resolve(value));
+    for (const candidate of candidates) {
+        if (targetDirs.some((target) => isInsideOrEqual(candidate.absolute, target))) {
+            return {
+                matched: `tsc.byPath ${candidate.key}`,
+                entry: { ...defaultEntry, ...candidate.entry }
+            };
+        }
+    }
+    return { matched: "default", entry: defaultEntry };
+}
+function normalizeConfigEntry(value) {
+    if (typeof value === "string" && value.trim()) {
+        return { tsc: value.trim() };
+    }
+    const object = readObject(value);
+    if (!object) {
+        return null;
+    }
+    const mode = readMode(object.mode);
+    const fallback = readFallback(object.fallback);
+    const tsc = readString(object.tsc);
+    return {
+        ...(mode ? { mode } : {}),
+        ...(fallback ? { fallback } : {}),
+        ...(tsc ? { tsc } : {})
+    };
+}
+function resolveProject(cwd, root, args) {
+    const projectArg = readProjectArg(args);
+    if (!projectArg) {
+        return {
+            project: node_path_1.default.join(cwd, "tsconfig.json"),
+            projectDir: cwd
+        };
+    }
+    const resolved = node_path_1.default.resolve(cwd, projectArg);
+    const project = node_fs_1.default.existsSync(resolved) && node_fs_1.default.statSync(resolved).isDirectory()
+        ? node_path_1.default.join(resolved, "tsconfig.json")
+        : resolved;
+    const projectDir = node_path_1.default.basename(project).toLowerCase().startsWith("tsconfig") ? node_path_1.default.dirname(project) : project;
+    return {
+        project: isInsideOrEqual(root, project) ? project : resolved,
+        projectDir
+    };
+}
+function readProjectArg(args) {
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index] ?? "";
+        if (current === "-p" || current === "--project") {
+            return args[index + 1] ?? null;
+        }
+        if (current.startsWith("--project=")) {
+            return current.slice("--project=".length);
+        }
+        if (current.startsWith("-p") && current.length > 2) {
+            return current.slice(2);
+        }
+    }
+    return null;
+}
+function findProjectLocalTsc(startDir, stopDir) {
+    let current = node_path_1.default.resolve(startDir);
+    const stop = node_path_1.default.resolve(stopDir);
+    const parsedRoot = node_path_1.default.parse(current).root;
+    while (true) {
+        const candidate = node_path_1.default.join(current, "node_modules", "typescript", "bin", "tsc");
+        if (node_fs_1.default.existsSync(candidate) && node_fs_1.default.statSync(candidate).isFile()) {
+            return candidate;
+        }
+        if (samePath(current, stop) || current === parsedRoot) {
+            break;
+        }
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return null;
+}
+function executableForPath(filePath) {
+    if (/\.(?:cmd|bat|exe)$/i.test(filePath)) {
+        return {
+            command: filePath,
+            argsPrefix: [],
+            shell: process.platform === "win32",
+            display: filePath
+        };
+    }
+    return {
+        command: process.execPath,
+        argsPrefix: [filePath],
+        shell: false,
+        display: filePath
+    };
+}
+function pathExecutableForTsc(env) {
+    const explicit = readString(env[env_vars_1.CLI_ENV.tscPath]);
+    if (explicit) {
+        return executableForPath(node_path_1.default.resolve(explicit));
+    }
+    return {
+        command: "tsc",
+        argsPrefix: [],
+        shell: process.platform === "win32",
+        display: "PATH:tsc"
+    };
+}
+function fileStatus(filePath) {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return "missing";
+    }
+    return node_fs_1.default.statSync(filePath).isFile() ? "exists" : "not-file";
+}
+function applyTscOutputCap(input, options) {
+    const capBytes = options.outputCapBytes;
+    if (typeof capBytes !== "number" || !Number.isFinite(capBytes) || capBytes <= 0) {
+        return input;
+    }
+    if (Buffer.byteLength(input, "utf8") <= capBytes) {
+        return input;
+    }
+    const split = splitTextByLineCap(input, capBytes);
+    if (!split.rest) {
+        return input;
+    }
+    const restPath = options.writeRestOutput ? options.writeRestOutput(split.rest) : null;
+    if (!restPath) {
+        return input;
+    }
+    const restSize = formatKb(Buffer.byteLength(split.rest, "utf8"));
+    return `${split.visible.trimEnd()}\n\nrest output: ${restPath} ${restSize}`;
+}
+function splitTextByLineCap(input, capBytes) {
+    const lines = input.split(/\r?\n/);
+    const visible = [];
+    let usedBytes = 0;
+    let restStart = lines.length;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const lineBytes = Buffer.byteLength(`${line}${index === lines.length - 1 ? "" : "\n"}`, "utf8");
+        if (visible.length === 0 || usedBytes + lineBytes <= capBytes) {
+            visible.push(line);
+            usedBytes += lineBytes;
+            continue;
+        }
+        restStart = index;
+        break;
+    }
+    return {
+        visible: visible.join("\n"),
+        rest: restStart < lines.length ? lines.slice(restStart).join("\n") : ""
+    };
+}
+function writeTscRestOutputLog(cwd, resolution, output) {
+    const configPath = resolution.configPath;
+    const hasWorkspaceConfig = Boolean(configPath && node_fs_1.default.existsSync(configPath));
+    const root = hasWorkspaceConfig ? resolution.workspaceRoot : node_os_1.default.tmpdir();
+    const dir = node_path_1.default.join(root, ".tmp", "aib", "tsc");
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+    const hash = node_crypto_1.default.createHash("sha256").update(output).digest("hex").slice(0, 12);
+    const filePath = node_path_1.default.join(dir, `${hash}_tsc.log`);
+    node_fs_1.default.writeFileSync(filePath, output, "utf8");
+    return hasWorkspaceConfig ? formatPath(resolution.workspaceRoot, filePath) : normalizeSlashes(filePath);
+}
+function readTscOutputCapBytes(cwd, env) {
+    if (isOutputCapDisabled(env[GLOBAL_OUTPUT_CAP_ENV])) {
+        return null;
+    }
+    const workspace = (0, workspace_root_1.resolveWorkspaceRoot)(cwd);
+    const tscConfig = readObject(workspace?.config.tsc);
+    const capKb = readOutputCapKbConfigValue(tscConfig?.outputCapKb, DEFAULT_TSC_OUTPUT_CAP_KB);
+    return capKb === null ? null : capKb * 1024;
+}
+function readOutputCapKbConfigValue(value, defaultValue) {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (typeof value === "boolean") {
+        return value ? defaultValue : null;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (isDisabledOutputCapToken(normalized)) {
+            return null;
+        }
+        return normalizeOutputCapKb(Number(normalized));
+    }
+    return typeof value === "number" ? normalizeOutputCapKb(value) : defaultValue;
+}
+function isOutputCapDisabled(value) {
+    return value !== undefined && isDisabledOutputCapToken(value.trim().toLowerCase());
+}
+function isDisabledOutputCapToken(value) {
+    return value === "" || value === "off" || value === "disabled" || value === "false" || value === "0";
+}
+function normalizeOutputCapKb(value) {
+    return Number.isFinite(value) && value > 0 ? value : null;
+}
+function formatKb(bytes) {
+    return `${Math.ceil(bytes / 1024)} KB`;
+}
+function readConfigRevision(workspace) {
+    try {
+        const stat = node_fs_1.default.statSync(workspace.configPath);
+        return `${workspace.configPath}:${stat.mtimeMs}:${stat.size}`;
+    }
+    catch {
+        return `${workspace.configPath}:missing`;
+    }
+}
+function readObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function readMode(value) {
+    return value === "project" || value === "path" ? value : null;
+}
+function readFallback(value) {
+    return value === "project" || value === "path" || value === "none" ? value : null;
+}
+function resolveMaybeRelative(root, value) {
+    return node_path_1.default.isAbsolute(value) ? node_path_1.default.resolve(value) : node_path_1.default.resolve(root, value);
+}
+function stripLeadingTerminator(args) {
+    return args[0] === "--" ? args.slice(1) : args;
+}
+function isInsideOrEqual(parent, child) {
+    const normalizedParent = normalizeForCompare(parent);
+    const normalizedChild = normalizeForCompare(child);
+    return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}${node_path_1.default.sep}`);
+}
+function samePath(left, right) {
+    return normalizeForCompare(left) === normalizeForCompare(right);
+}
+function normalizeForCompare(value) {
+    const resolved = node_path_1.default.resolve(value);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function formatPath(root, target) {
+    if (target === "PATH:tsc") {
+        return target;
+    }
+    const relative = node_path_1.default.relative(root, node_path_1.default.resolve(target));
+    if (relative && !relative.startsWith("..") && !node_path_1.default.isAbsolute(relative)) {
+        return normalizeSlashes(relative);
+    }
+    return normalizeSlashes(node_path_1.default.resolve(target));
+}
+function normalizeSlashes(value) {
+    return value.replace(/\\/g, "/");
+}
+function groupBy(items, key) {
+    const result = new Map();
+    for (const item of items) {
+        const itemKey = key(item);
+        const group = result.get(itemKey) ?? [];
+        group.push(item);
+        result.set(itemKey, group);
+    }
+    return result;
+}
+function unique(items) {
+    return [...new Set(items.filter((item) => item.length > 0))];
+}
+function plural(count, word) {
+    return count === 1 ? word : `${word}s`;
+}
+function truncate(value, maxLength) {
+    return value.length <= maxLength ? value : `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}