ast-mcp-server 0.5.0 → 0.6.0

package/dist/services/project-status.js

@@ -0,0 +1,736 @@
+import { createHash } from "node:crypto";
+import { createTruncationMetadata, isFreshnessCause, isSnapshotState, isTruncationReason, } from "./read-contracts.js";
+export const MAX_PENDING_FILES = 64;
+export const MAX_PENDING_FILENAME_LENGTH = 256;
+export const MAX_DEGRADED_ERRORS = 8;
+export const MAX_STATUS_TEXT_LENGTH = 512;
+const TRUNCATION_SUFFIX = "... [truncated]";
+const MAX_STATUS_CAUSES = 5;
+const MAX_PENDING_INPUT_SCAN = MAX_PENDING_FILES * 4;
+const MAX_ERROR_INPUT_SCAN = MAX_DEGRADED_ERRORS * 4;
+function isCompilerStatusState(value) {
+    return value === "ready" || value === "rebuilding" || value === "failed";
+}
+function isIndexStatusState(value) {
+    return value === "disabled" || value === "ready" || value === "rebuilding" || value === "failed";
+}
+function isWatcherStatusState(value) {
+    return value === "disabled" || value === "ready" || value === "failed";
+}
+function isSynchronizationCause(value) {
+    return value === "source_change" || value === "config_change" || value === "compiler_rebuild";
+}
+function canonicalIdentityPath(value) {
+    const normalized = value.trim().replaceAll("\\", "/");
+    const hasLeadingSlash = normalized.startsWith("/");
+    const windowsDrive = /^[A-Za-z]:\//.test(normalized);
+    const segments = normalized.split("/");
+    const result = [];
+    for (const segment of segments) {
+        if (!segment || segment === ".")
+            continue;
+        if (segment === ".." && result.length > 0 && result[result.length - 1] !== "..") {
+            result.pop();
+            continue;
+        }
+        result.push(segment);
+    }
+    const joined = result.join("/");
+    if (hasLeadingSlash)
+        return `/${joined}`;
+    if (windowsDrive)
+        return joined;
+    return joined || ".";
+}
+function digest(prefix, value) {
+    return `${prefix}_${createHash("sha256").update(value, "utf8").digest("hex").slice(0, 20)}`;
+}
+function fingerprintDigest(prefix, value) {
+    return `${prefix}_${createHash("sha256").update(value, "utf8").digest("hex")}`;
+}
+function normalizeIdentityToken(value, prefix) {
+    const expected = new RegExp(`^${prefix}_[0-9a-f]{20}$`);
+    return typeof value === "string" && expected.test(value) ? value : digest(prefix, "[redacted]");
+}
+function normalizeProjectIdentity(value) {
+    const record = typeof value === "object" && value !== null
+        ? value
+        : {};
+    return {
+        project_id: normalizeIdentityToken(record.project_id, "project"),
+        config_id: record.config_id === null || record.config_id === undefined
+            ? null
+            : normalizeIdentityToken(record.config_id, "config"),
+    };
+}
+export function createProjectIdentity(input) {
+    if (typeof input !== "object" ||
+        input === null ||
+        typeof input.projectRoot !== "string" ||
+        (input.configPath !== undefined && typeof input.configPath !== "string")) {
+        throw new Error("Project identity input must contain string paths.");
+    }
+    const projectRoot = canonicalIdentityPath(input.projectRoot);
+    const configPath = input.configPath === undefined ? null : canonicalIdentityPath(input.configPath);
+    return {
+        project_id: digest("project", projectRoot),
+        config_id: configPath === null ? null : digest("config", configPath),
+    };
+}
+function isFiniteCount(value) {
+    return (typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0);
+}
+function boundedCount(value) {
+    if (!isFiniteCount(value))
+        return 0;
+    return value;
+}
+function redactAbsolutePaths(value) {
+    const traversalMarker = "__TRAVERSAL_PATH_REDACTED__";
+    const quotedTraversalPath = /(?<=["'`])(?:[^"'`\n\r]*[\\/])?\.\.[\\/][^"'`\n\r]*?(?=["'`])/g;
+    const labelledTraversalPath = /([=:]\s+)([^"'`:\n\r;,]*[ \t]+[^"'`:\n\r;,/\\]+[\\/]\.\.[\\/][^"'`:\n\r]*?)(?=\s*[:;,\n\r"'`)\]}]|(?:\.(?=\s|$))|$)/g;
+    const diagnosticTraversalPath = /(\b(?:read|open|resolve|watch|parse)\s+)([^"'`:\n\r;,]*[\\/]\.\.[\\/][^"'`:\n\r]*?)(?=\s*[:;,\n\r"'`)\]}]|(?:\.(?=\s|$))|$)/gi;
+    const spacedTraversalPath = /(?<=\s)([^"'`:\n\r;,]*[ \t]+[^"'`:\n\r;,/\\]+[\\/]\.\.[\\/][^"'`:\n\r]*?)(?=\s*[:;,\n\r"'`)\]}]|(?:\.(?=\s|$))|$)/g;
+    const relativeTraversalPath = /(?:[^\s"'`:/${}\\]+[\\/])+\.\.[\\/][^"'`:\n\r]*?(?=\s*[:;,\n\r"'`)\]}]|(?:\.(?=\s|$))|$)/g;
+    const directTraversalPath = /(?:^|(?<=[\s(]))\.\.[\\/][^"'`:\n\r]*?(?=\s*[:;,\n\r"'`)\]}]|(?:\.(?=\s|$))|$)/g;
+    const uncPath = /(?:\\\\|\/{2})[^"'`\n\r]*?(?=\s*(?::(?=\s|$)|[;,\n\r"'`)\]}])|(?:\.(?=\s|$))|$)/g;
+    const drivePath = /\b[A-Za-z]:[^"'`\n\r]*?(?=\s*(?::(?=\s|$)|[;,\n\r"'`)\]}])|(?:\.(?=\s|$))|$)/g;
+    const posixPath = /(?<![A-Za-z0-9_./-])\/(?!\/)[^"'`\n\r]*?(?=\s*(?::(?=\s|$)|[;,\n\r"'`)\]}])|(?:\.(?=\s|$))|$)/g;
+    const redacted = value
+        .replace(quotedTraversalPath, traversalMarker)
+        .replace(labelledTraversalPath, `$1${traversalMarker}`)
+        .replace(diagnosticTraversalPath, `$1${traversalMarker}`)
+        .replace(spacedTraversalPath, traversalMarker)
+        .replace(relativeTraversalPath, traversalMarker)
+        .replace(directTraversalPath, traversalMarker);
+    return redacted
+        .replace(drivePath, "[path-redacted]")
+        .replace(uncPath, "[path-redacted]")
+        .replace(posixPath, "[path-redacted]")
+        .replaceAll(traversalMarker, "[path-redacted]");
+}
+function redactSensitiveText(value) {
+    return value
+        .replace(/(?!(?:\bauthorization[ \t]*[:=])[ \t]*\[REDACTED\])(\bauthorization[ \t]*[:=])([ \t]*)[^\r\n;]+/gi, "$1$2[REDACTED]")
+        .replace(/(?!(?:\bbearer)[ \t]+\[REDACTED\])\bbearer[ \t]+[^\r\n;]+/gi, "Bearer [REDACTED]")
+        .replace(/\b(api[-_ ]?key|access[-_ ]?token|refresh[-_ ]?token|token|password|secret|credential|connection[-_ ]?string)\b\s*[:=]\s*(?!\[REDACTED\])(?:"[^"]*"|'[^']*'|[^\s,;}\]]+)/gi, "$1=[REDACTED]")
+        .replace(/\b([A-Za-z][A-Za-z0-9+.-]*:\/\/)[^\s"'`]+@/g, "$1[REDACTED]@")
+        .replace(/\b(?:sk|ghp|github_pat|xox[baprs]-|AIza)[A-Za-z0-9_-]{8,}\b/g, "[REDACTED]");
+}
+function boundedText(value) {
+    const text = typeof value === "string" ? value : "[invalid-error]";
+    const redacted = redactSensitiveText(redactAbsolutePaths(text));
+    return redacted.length <= MAX_STATUS_TEXT_LENGTH
+        ? { value: redacted, truncated: false }
+        : {
+            value: `${redacted.slice(0, MAX_STATUS_TEXT_LENGTH - TRUNCATION_SUFFIX.length)}${TRUNCATION_SUFFIX}`,
+            truncated: true,
+        };
+}
+function projectRelativePath(value) {
+    let normalized = value.trim().replaceAll("\\", "/");
+    const quote = normalized[0];
+    if (normalized.length >= 2 &&
+        (quote === '"' || quote === "'" || quote === "`") &&
+        normalized.endsWith(quote)) {
+        normalized = normalized.slice(1, -1).trim();
+    }
+    if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized)) {
+        return "[absolute-path-redacted]";
+    }
+    const segments = normalized.split("/");
+    if (segments.some((segment) => segment === "..")) {
+        return "[path-redacted]";
+    }
+    return segments.filter((segment) => segment.length > 0 && segment !== ".").join("/") || ".";
+}
+function validateArrayShape(value, limit) {
+    if (!Array.isArray(value))
+        return { valid: false, truncated: false };
+    if (Object.getPrototypeOf(value) !== Array.prototype)
+        return { valid: false, truncated: false };
+    if (Object.getOwnPropertySymbols(value).length > 0)
+        return { valid: false, truncated: false };
+    const end = Math.min(value.length, limit);
+    for (let index = 0; index < end; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (descriptor === undefined ||
+            !("value" in descriptor) ||
+            typeof descriptor.value !== "string") {
+            return { valid: false, truncated: value.length > end };
+        }
+    }
+    return { valid: true, truncated: value.length > end };
+}
+function collectStringPrefix(value, limit) {
+    const shape = validateArrayShape(value, limit);
+    if (!Array.isArray(value))
+        return { values: [], ...shape };
+    const end = Math.min(value.length, limit);
+    const values = [];
+    for (let index = 0; index < end; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (descriptor !== undefined && "value" in descriptor && typeof descriptor.value === "string") {
+            values.push(descriptor.value);
+        }
+    }
+    return { values, ...shape };
+}
+function boundedPendingFilename(value) {
+    if (value.length <= MAX_PENDING_FILENAME_LENGTH) {
+        return { value, truncated: false };
+    }
+    return {
+        value: `${value.slice(0, MAX_PENDING_FILENAME_LENGTH - TRUNCATION_SUFFIX.length)}${TRUNCATION_SUFFIX}`,
+        truncated: true,
+    };
+}
+function boundedPendingFiles(files) {
+    const collected = collectStringPrefix(files, MAX_PENDING_INPUT_SCAN);
+    const unique = [];
+    const seen = new Set();
+    for (const file of collected.values) {
+        const normalized = projectRelativePath(file);
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        unique.push(normalized);
+        if (unique.length > MAX_PENDING_FILES)
+            break;
+    }
+    const bounded = unique.slice(0, MAX_PENDING_FILES).map(boundedPendingFilename);
+    const recordTruncated = collected.truncated || unique.length > MAX_PENDING_FILES;
+    const filenameTruncated = bounded.some((file) => file.truncated);
+    return {
+        files: bounded.slice(0, MAX_PENDING_FILES).map((file) => file.value),
+        recordTruncation: createTruncationMetadata(recordTruncated, recordTruncated ? "record_limit" : null),
+        filenameTruncation: createTruncationMetadata(filenameTruncated, filenameTruncated ? "serialization_limit" : null),
+    };
+}
+function mergePendingFiles(current, incoming) {
+    const currentPrefix = collectStringPrefix(current, MAX_PENDING_INPUT_SCAN);
+    const incomingPrefix = collectStringPrefix(incoming, MAX_PENDING_INPUT_SCAN);
+    const merged = boundedPendingFiles([...currentPrefix.values, ...incomingPrefix.values]);
+    const recordTruncated = merged.recordTruncation.truncated || currentPrefix.truncated || incomingPrefix.truncated;
+    return {
+        ...merged,
+        recordTruncation: createTruncationMetadata(recordTruncated, recordTruncated ? "record_limit" : null),
+    };
+}
+function appendCause(current, cause) {
+    if (current.includes(cause))
+        return current;
+    if (current.length >= MAX_STATUS_CAUSES)
+        return current;
+    return [...current, cause];
+}
+function removeCause(current, cause) {
+    return current.filter((currentCause) => currentCause !== cause);
+}
+function appendError(current, error) {
+    const bounded = boundedText(error);
+    const currentErrors = collectStringPrefix(current, MAX_DEGRADED_ERRORS).values;
+    const next = currentErrors.includes(bounded.value)
+        ? currentErrors
+        : [...currentErrors, bounded.value];
+    return {
+        errors: next.slice(-MAX_DEGRADED_ERRORS),
+        countTruncated: next.length > MAX_DEGRADED_ERRORS,
+        textTruncated: bounded.truncated,
+    };
+}
+function boundedErrors(errors) {
+    let current = [];
+    let countTruncated = false;
+    let textTruncated = false;
+    const collected = collectStringPrefix(errors, MAX_ERROR_INPUT_SCAN);
+    for (const error of collected.values) {
+        const appended = appendError(current, error);
+        current = appended.errors;
+        countTruncated ||= appended.countTruncated;
+        textTruncated ||= appended.textTruncated;
+    }
+    countTruncated ||= collected.truncated;
+    return {
+        errors: current,
+        collectionValid: collected.valid,
+        countTruncated,
+        textTruncated,
+    };
+}
+function emptyTruncationMetadata() {
+    return createTruncationMetadata(false);
+}
+function mergeTruncation(current, incoming, reason) {
+    const truncated = current.truncated || incoming.truncated;
+    return createTruncationMetadata(truncated, truncated ? reason : null);
+}
+function errorTruncation(countTruncated, textTruncated) {
+    if (countTruncated)
+        return createTruncationMetadata(true, "record_limit");
+    if (textTruncated)
+        return createTruncationMetadata(true, "serialization_limit");
+    return emptyTruncationMetadata();
+}
+function nonEmptyFingerprint(value, prefix) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim();
+    if (normalized.length === 0)
+        return null;
+    const canonical = new RegExp(`^${prefix}_[0-9a-f]{64}$`);
+    return canonical.test(value) ? value : fingerprintDigest(prefix, value);
+}
+function normalizedTimestamp(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim();
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{3}))?Z$/.exec(normalized);
+    if (match === null)
+        return null;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const hour = Number(match[4]);
+    const minute = Number(match[5]);
+    const second = Number(match[6]);
+    const millisecond = match[7] === undefined ? 0 : Number(match[7]);
+    const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const daysInMonth = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    return month >= 1 &&
+        month <= 12 &&
+        day >= 1 &&
+        day <= daysInMonth[month - 1] &&
+        hour <= 23 &&
+        minute <= 59 &&
+        second <= 59 &&
+        millisecond <= 999
+        ? normalized
+        : null;
+}
+function statusWith(status, changes) {
+    return { ...status, ...changes };
+}
+function normalizeTruncation(current, derived, fallbackReason, acceptedReasons = [fallbackReason]) {
+    const record = typeof current === "object" && current !== null
+        ? current
+        : {};
+    const currentTruncated = record.truncated === true;
+    const currentReason = isTruncationReason(record.reason) && acceptedReasons.includes(record.reason)
+        ? record.reason
+        : null;
+    const truncated = currentTruncated || derived.truncated;
+    if (!truncated)
+        return emptyTruncationMetadata();
+    return createTruncationMetadata(true, currentReason ?? derived.reason ?? fallbackReason);
+}
+function isValidTruncationMetadata(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const record = value;
+    if (typeof record.truncated !== "boolean")
+        return false;
+    return record.truncated ? isTruncationReason(record.reason) : record.reason === null;
+}
+function invalidProjectStatus() {
+    return {
+        project: normalizeProjectIdentity(null),
+        state: "degraded",
+        causes: [],
+        sourceCount: 0,
+        indexedCount: 0,
+        pendingFiles: [],
+        pendingFilesTruncated: false,
+        pendingFilesTruncation: emptyTruncationMetadata(),
+        pendingFilesFilenameTruncation: emptyTruncationMetadata(),
+        compiler: { state: "failed" },
+        index: { state: "disabled" },
+        watcher: { state: "disabled" },
+        lastSuccessfulSyncAt: null,
+        lastSuccessfulIndexAt: null,
+        sourceSnapshotFingerprint: null,
+        configSnapshotFingerprint: null,
+        canonicalSnapshotFingerprint: null,
+        degradedErrors: ["[invalid-status]"],
+        degradedErrorsTruncation: emptyTruncationMetadata(),
+        degradedErrorsTextTruncation: emptyTruncationMetadata(),
+        boundaryInvalid: true,
+    };
+}
+function normalizeProjectStatus(status) {
+    if (typeof status !== "object" || status === null || Array.isArray(status)) {
+        return invalidProjectStatus();
+    }
+    const causeCollection = collectStringPrefix(status.causes, MAX_STATUS_CAUSES * 4);
+    const causesFromInput = causeCollection.values
+        .filter(isFreshnessCause)
+        .filter((cause, index, causes) => causes.indexOf(cause) === index);
+    const hasMalformedCause = !causeCollection.valid ||
+        causeCollection.truncated ||
+        causeCollection.values.some((cause) => !isFreshnessCause(cause));
+    const rawIndexState = status.index?.state;
+    const rawWatcherState = status.watcher?.state;
+    const rawCompilerState = status.compiler?.state;
+    const malformedCount = !isFiniteCount(status.sourceCount) || !isFiniteCount(status.indexedCount);
+    const indexFailed = !isIndexStatusState(rawIndexState) || rawIndexState === "failed";
+    const watcherFailed = !isWatcherStatusState(rawWatcherState) || rawWatcherState === "failed";
+    const malformedComponentState = !isIndexStatusState(rawIndexState) || !isWatcherStatusState(rawWatcherState);
+    const compilerValid = isCompilerStatusState(rawCompilerState);
+    const compilerFailed = rawCompilerState === "failed";
+    const compilerRebuilding = rawCompilerState === "rebuilding";
+    const sourceSnapshotFingerprint = nonEmptyFingerprint(status.sourceSnapshotFingerprint, "source");
+    const configSnapshotFingerprint = nonEmptyFingerprint(status.configSnapshotFingerprint, "config");
+    const canonicalSnapshotFingerprint = nonEmptyFingerprint(status.canonicalSnapshotFingerprint, "snapshot");
+    const lastSuccessfulSyncAt = normalizedTimestamp(status.lastSuccessfulSyncAt);
+    const hasCompleteSnapshotEvidence = canonicalSnapshotFingerprint !== null ||
+        (sourceSnapshotFingerprint !== null && configSnapshotFingerprint !== null);
+    const hasActiveInvalidationCause = causesFromInput.some((cause) => cause === "source_change" || cause === "config_change" || cause === "compiler_rebuild");
+    let causes = causesFromInput;
+    if (indexFailed)
+        causes = appendCause(causes, "index_failure");
+    if (watcherFailed)
+        causes = appendCause(causes, "watcher_failure");
+    const hasComponentFailure = causes.includes("index_failure") ||
+        causes.includes("watcher_failure") ||
+        indexFailed ||
+        watcherFailed ||
+        (compilerFailed && status.state === "fresh");
+    const pendingCollection = collectStringPrefix(status.pendingFiles, MAX_PENDING_INPUT_SCAN);
+    const pending = boundedPendingFiles(status.pendingFiles);
+    const bounded = boundedErrors(status.degradedErrors);
+    const malformedTruncation = [
+        status.pendingFilesTruncation,
+        status.pendingFilesFilenameTruncation,
+        status.degradedErrorsTruncation,
+        status.degradedErrorsTextTruncation,
+    ].some((metadata) => !isValidTruncationMetadata(metadata));
+    const boundaryInvalid = status.boundaryInvalid === true ||
+        hasMalformedCause ||
+        malformedCount ||
+        malformedComponentState ||
+        !pendingCollection.valid ||
+        !bounded.collectionValid ||
+        malformedTruncation ||
+        !isSnapshotState(status.state) ||
+        !compilerValid;
+    const pendingFilesTruncation = normalizeTruncation(status.pendingFilesTruncation, pending.recordTruncation, "record_limit");
+    const pendingFilesFilenameTruncation = normalizeTruncation(status.pendingFilesFilenameTruncation, pending.filenameTruncation, "serialization_limit");
+    const degradedErrorsTruncation = normalizeTruncation(status.degradedErrorsTruncation, errorTruncation(bounded.countTruncated, bounded.textTruncated), "record_limit", ["record_limit", "serialization_limit"]);
+    const degradedErrorsTextTruncation = normalizeTruncation(status.degradedErrorsTextTruncation, createTruncationMetadata(bounded.textTruncated, bounded.textTruncated ? "serialization_limit" : null), "serialization_limit");
+    const hasPendingEvidence = pending.files.length > 0 ||
+        pendingFilesTruncation.truncated ||
+        pendingFilesFilenameTruncation.truncated;
+    return {
+        ...status,
+        project: normalizeProjectIdentity(status.project),
+        state: hasComponentFailure || boundaryInvalid
+            ? "degraded"
+            : status.state === "fresh" &&
+                (!hasCompleteSnapshotEvidence ||
+                    lastSuccessfulSyncAt === null ||
+                    hasActiveInvalidationCause ||
+                    hasPendingEvidence ||
+                    compilerRebuilding ||
+                    bounded.errors.length > 0)
+                ? "pending"
+                : status.state,
+        causes,
+        boundaryInvalid,
+        sourceCount: boundedCount(status.sourceCount),
+        indexedCount: 0,
+        index: { state: "disabled" },
+        compiler: { state: compilerValid ? rawCompilerState : "failed" },
+        watcher: { state: watcherFailed ? "failed" : rawWatcherState },
+        lastSuccessfulSyncAt,
+        lastSuccessfulIndexAt: null,
+        sourceSnapshotFingerprint,
+        configSnapshotFingerprint,
+        canonicalSnapshotFingerprint,
+        pendingFiles: pending.files,
+        pendingFilesTruncated: pendingFilesTruncation.truncated || pendingFilesFilenameTruncation.truncated,
+        pendingFilesTruncation,
+        pendingFilesFilenameTruncation,
+        degradedErrors: bounded.errors,
+        degradedErrorsTruncation,
+        degradedErrorsTextTruncation,
+    };
+}
+function hasActiveIndexFailure(status) {
+    return status.causes.includes("index_failure");
+}
+function hasActiveWatcherFailure(status) {
+    return status.causes.includes("watcher_failure");
+}
+function hasActiveComponentFailure(status) {
+    return (hasActiveIndexFailure(status) ||
+        hasActiveWatcherFailure(status) ||
+        status.boundaryInvalid === true ||
+        status.index.state === "failed" ||
+        status.watcher.state === "failed");
+}
+function stateAfterRecovery(status) {
+    return hasActiveComponentFailure(status) ? "degraded" : "pending";
+}
+function markInvalidTransition(status, error) {
+    const appended = appendError(status.degradedErrors, error);
+    const textTruncated = status.degradedErrorsTextTruncation.truncated || appended.textTruncated;
+    const countTruncated = status.degradedErrorsTruncation.reason === "record_limit" || appended.countTruncated;
+    return statusWith(status, {
+        state: "degraded",
+        boundaryInvalid: true,
+        degradedErrors: appended.errors,
+        degradedErrorsTruncation: errorTruncation(countTruncated, textTruncated),
+        degradedErrorsTextTruncation: createTruncationMetadata(textTruncated, textTruncated ? "serialization_limit" : null),
+    });
+}
+export function createInitialProjectStatus(project, options = {}) {
+    const pendingInput = options.pendingFiles === undefined ? [] : options.pendingFiles;
+    const pendingInputCollection = collectStringPrefix(pendingInput, MAX_PENDING_INPUT_SCAN);
+    const pending = boundedPendingFiles(pendingInput);
+    const watcherState = options.watcherState === undefined ? "disabled" : options.watcherState;
+    const initial = {
+        project: { ...project },
+        state: "pending",
+        causes: pending.files.length > 0 ? ["source_change"] : [],
+        sourceCount: boundedCount(options.sourceCount),
+        indexedCount: 0,
+        pendingFiles: pending.files,
+        pendingFilesTruncated: pending.recordTruncation.truncated || pending.filenameTruncation.truncated,
+        pendingFilesTruncation: pending.recordTruncation,
+        pendingFilesFilenameTruncation: pending.filenameTruncation,
+        compiler: { state: "ready" },
+        index: { state: "disabled" },
+        watcher: { state: watcherState },
+        lastSuccessfulSyncAt: null,
+        lastSuccessfulIndexAt: null,
+        sourceSnapshotFingerprint: null,
+        configSnapshotFingerprint: null,
+        canonicalSnapshotFingerprint: null,
+        degradedErrors: [],
+        degradedErrorsTruncation: emptyTruncationMetadata(),
+        degradedErrorsTextTruncation: emptyTruncationMetadata(),
+        boundaryInvalid: !pendingInputCollection.valid ||
+            (options.sourceCount !== undefined && !isFiniteCount(options.sourceCount)) ||
+            (options.indexedCount !== undefined && !isFiniteCount(options.indexedCount)),
+    };
+    return normalizeProjectStatus(initial);
+}
+export function transitionProjectStatus(inputStatus, event) {
+    const status = normalizeProjectStatus(inputStatus);
+    const runtimeEvent = event;
+    if (typeof runtimeEvent !== "object" ||
+        runtimeEvent === null ||
+        typeof runtimeEvent.type !== "string") {
+        return markInvalidTransition(status, "[invalid-event]");
+    }
+    switch (event.type) {
+        case "source_changed": {
+            const eventFiles = collectStringPrefix(event.files, MAX_PENDING_INPUT_SCAN);
+            if (!eventFiles.valid)
+                return markInvalidTransition(status, "[invalid-files]");
+            const pending = mergePendingFiles(status.pendingFiles, event.files);
+            const recordTruncation = mergeTruncation(status.pendingFilesTruncation, pending.recordTruncation, "record_limit");
+            const filenameTruncation = mergeTruncation(status.pendingFilesFilenameTruncation, pending.filenameTruncation, "serialization_limit");
+            return statusWith(status, {
+                state: status.state === "degraded" ? "degraded" : "pending",
+                causes: appendCause(status.causes, "source_change"),
+                pendingFiles: pending.files,
+                pendingFilesTruncated: recordTruncation.truncated || filenameTruncation.truncated,
+                pendingFilesTruncation: recordTruncation,
+                pendingFilesFilenameTruncation: filenameTruncation,
+            });
+        }
+        case "config_changed":
+            return statusWith(status, {
+                state: status.state === "degraded" ? "degraded" : "pending",
+                causes: appendCause(status.causes, "config_change"),
+            });
+        case "compiler_rebuild_started":
+            return statusWith(status, {
+                state: status.state === "degraded" ? "degraded" : "rebuilding",
+                causes: appendCause(status.causes, "compiler_rebuild"),
+                compiler: { state: "rebuilding" },
+                index: {
+                    state: hasActiveIndexFailure(status) || status.index.state === "disabled"
+                        ? "disabled"
+                        : "rebuilding",
+                },
+            });
+        case "sync_succeeded": {
+            if (!isFiniteCount(event.sourceCount) || !isFiniteCount(event.indexedCount)) {
+                return markInvalidTransition(status, "[invalid-count]");
+            }
+            const hasFailure = hasActiveComponentFailure(status);
+            const indexDisabled = hasActiveIndexFailure(status) || status.index.state === "disabled";
+            const sourceSnapshotFingerprint = nonEmptyFingerprint(event.sourceSnapshotFingerprint, "source");
+            const configSnapshotFingerprint = nonEmptyFingerprint(event.configSnapshotFingerprint, "config");
+            const canonicalSnapshotFingerprint = nonEmptyFingerprint(event.canonicalSnapshotFingerprint, "snapshot");
+            const hasSnapshotEvidence = sourceSnapshotFingerprint !== null ||
+                configSnapshotFingerprint !== null ||
+                canonicalSnapshotFingerprint !== null;
+            const hasCompleteSnapshotEvidence = canonicalSnapshotFingerprint !== null ||
+                (sourceSnapshotFingerprint !== null && configSnapshotFingerprint !== null);
+            const eventSyncAt = event.at === undefined ? status.lastSuccessfulSyncAt : normalizedTimestamp(event.at);
+            const nextSyncAt = event.at === undefined
+                ? status.lastSuccessfulSyncAt
+                : (normalizedTimestamp(event.at) ?? status.lastSuccessfulSyncAt);
+            const hasFreshEvidence = hasCompleteSnapshotEvidence && eventSyncAt !== null;
+            const canClearInvalidation = !hasFailure && hasFreshEvidence;
+            const pending = canClearInvalidation
+                ? boundedPendingFiles([])
+                : {
+                    files: status.pendingFiles,
+                    recordTruncation: status.pendingFilesTruncation,
+                    filenameTruncation: status.pendingFilesFilenameTruncation,
+                };
+            const nextState = hasFailure ? "degraded" : canClearInvalidation ? "fresh" : "pending";
+            return statusWith(status, {
+                state: nextState,
+                causes: canClearInvalidation ? [] : status.causes,
+                sourceCount: boundedCount(event.sourceCount),
+                indexedCount: indexDisabled ? 0 : boundedCount(event.indexedCount),
+                pendingFiles: pending.files,
+                pendingFilesTruncated: pending.recordTruncation.truncated || pending.filenameTruncation.truncated,
+                pendingFilesTruncation: pending.recordTruncation,
+                pendingFilesFilenameTruncation: pending.filenameTruncation,
+                compiler: { state: "ready" },
+                index: {
+                    state: indexDisabled
+                        ? "disabled"
+                        : hasFailure && status.index.state === "failed"
+                            ? "failed"
+                            : "ready",
+                },
+                lastSuccessfulSyncAt: canClearInvalidation ? nextSyncAt : status.lastSuccessfulSyncAt,
+                lastSuccessfulIndexAt: !hasFreshEvidence || indexDisabled || (hasFailure && status.index.state === "failed")
+                    ? status.lastSuccessfulIndexAt
+                    : (nextSyncAt ?? status.lastSuccessfulIndexAt),
+                sourceSnapshotFingerprint: hasSnapshotEvidence
+                    ? (sourceSnapshotFingerprint ?? status.sourceSnapshotFingerprint)
+                    : status.sourceSnapshotFingerprint,
+                configSnapshotFingerprint: hasSnapshotEvidence
+                    ? (configSnapshotFingerprint ?? status.configSnapshotFingerprint)
+                    : status.configSnapshotFingerprint,
+                canonicalSnapshotFingerprint: hasSnapshotEvidence
+                    ? (canonicalSnapshotFingerprint ?? status.canonicalSnapshotFingerprint)
+                    : status.canonicalSnapshotFingerprint,
+                degradedErrors: canClearInvalidation ? [] : status.degradedErrors,
+                degradedErrorsTruncation: canClearInvalidation
+                    ? emptyTruncationMetadata()
+                    : status.degradedErrorsTruncation,
+                degradedErrorsTextTruncation: canClearInvalidation
+                    ? emptyTruncationMetadata()
+                    : status.degradedErrorsTextTruncation,
+            });
+        }
+        case "sync_failed":
+            if (!isSynchronizationCause(event.cause)) {
+                return markInvalidTransition(status, event.error);
+            }
+            return statusWith(status, {
+                state: hasActiveComponentFailure(status) ? "degraded" : "stale",
+                causes: appendCause(status.causes, event.cause),
+                compiler: { state: "failed" },
+            });
+        case "stale_detected": {
+            const cause = event.cause === undefined ? "source_change" : event.cause;
+            const eventFiles = event.files === undefined
+                ? { valid: true }
+                : collectStringPrefix(event.files, MAX_PENDING_INPUT_SCAN);
+            if (!eventFiles.valid)
+                return markInvalidTransition(status, "[invalid-files]");
+            const pending = mergePendingFiles(status.pendingFiles, event.files);
+            const recordTruncation = mergeTruncation(status.pendingFilesTruncation, pending.recordTruncation, "record_limit");
+            const filenameTruncation = mergeTruncation(status.pendingFilesFilenameTruncation, pending.filenameTruncation, "serialization_limit");
+            const next = statusWith(status, {
+                state: hasActiveComponentFailure(status) ? "degraded" : "stale",
+                causes: isSynchronizationCause(cause) ? appendCause(status.causes, cause) : status.causes,
+                pendingFiles: pending.files,
+                pendingFilesTruncated: recordTruncation.truncated || filenameTruncation.truncated,
+                pendingFilesTruncation: recordTruncation,
+                pendingFilesFilenameTruncation: filenameTruncation,
+            });
+            return isSynchronizationCause(cause) ? next : markInvalidTransition(next, "[invalid-cause]");
+        }
+        case "index_failed": {
+            const appended = appendError(status.degradedErrors, event.error);
+            const textTruncated = status.degradedErrorsTextTruncation.truncated || appended.textTruncated;
+            const countTruncated = status.degradedErrorsTruncation.reason === "record_limit" || appended.countTruncated;
+            return statusWith(status, {
+                state: "degraded",
+                causes: appendCause(status.causes, "index_failure"),
+                index: { state: "disabled" },
+                degradedErrors: appended.errors,
+                degradedErrorsTruncation: errorTruncation(countTruncated, textTruncated),
+                degradedErrorsTextTruncation: createTruncationMetadata(textTruncated, textTruncated ? "serialization_limit" : null),
+            });
+        }
+        case "watcher_failed": {
+            const appended = appendError(status.degradedErrors, event.error);
+            const textTruncated = status.degradedErrorsTextTruncation.truncated || appended.textTruncated;
+            const countTruncated = status.degradedErrorsTruncation.reason === "record_limit" || appended.countTruncated;
+            return statusWith(status, {
+                state: "degraded",
+                causes: appendCause(status.causes, "watcher_failure"),
+                watcher: { state: "failed" },
+                degradedErrors: appended.errors,
+                degradedErrorsTruncation: errorTruncation(countTruncated, textTruncated),
+                degradedErrorsTextTruncation: createTruncationMetadata(textTruncated, textTruncated ? "serialization_limit" : null),
+            });
+        }
+        case "component_recovered":
+            if (event.component !== "index" && event.component !== "watcher") {
+                return markInvalidTransition(status, "[invalid-component]");
+            }
+            return recoverComponent(status, event.component);
+        case "index_recovered":
+            return recoverComponent(status, "index");
+        case "watcher_recovered":
+            return recoverComponent(status, "watcher");
+        default:
+            return markInvalidTransition(status, "[invalid-event]");
+    }
+}
+function recoverComponent(status, component) {
+    const recovered = component === "index"
+        ? statusWith(status, {
+            index: { state: "disabled" },
+            causes: removeCause(status.causes, "index_failure"),
+        })
+        : statusWith(status, {
+            watcher: { state: "ready" },
+            causes: removeCause(status.causes, "watcher_failure"),
+        });
+    const state = stateAfterRecovery(recovered);
+    return statusWith(recovered, {
+        state,
+        degradedErrors: state === "degraded" ? recovered.degradedErrors : [],
+        degradedErrorsTruncation: state === "degraded" ? recovered.degradedErrorsTruncation : emptyTruncationMetadata(),
+        degradedErrorsTextTruncation: state === "degraded" ? recovered.degradedErrorsTextTruncation : emptyTruncationMetadata(),
+    });
+}
+export function projectStatusToProjection(status) {
+    const normalized = normalizeProjectStatus(status);
+    return {
+        project: { ...normalized.project },
+        state: normalized.state,
+        causes: [...normalized.causes],
+        source_count: normalized.sourceCount,
+        indexed_count: 0,
+        pending_files: [...normalized.pendingFiles],
+        pending_files_truncated: normalized.pendingFilesTruncated,
+        pending_files_truncation: { ...normalized.pendingFilesTruncation },
+        pending_files_filename_truncation: { ...normalized.pendingFilesFilenameTruncation },
+        compiler: { ...normalized.compiler },
+        index: { state: "disabled" },
+        watcher: { ...normalized.watcher },
+        last_successful_sync_at: normalized.lastSuccessfulSyncAt,
+        last_successful_index_at: null,
+        source_snapshot_fingerprint: normalized.sourceSnapshotFingerprint,
+        config_snapshot_fingerprint: normalized.configSnapshotFingerprint,
+        canonical_snapshot_fingerprint: normalized.canonicalSnapshotFingerprint,
+        degraded_errors: [...normalized.degradedErrors],
+        degraded_errors_truncation: { ...normalized.degradedErrorsTruncation },
+        degraded_errors_text_truncation: { ...normalized.degradedErrorsTextTruncation },
+    };
+}