@timo972/cc-router 0.12.1 → 0.12.2-rc.0

package/dist/telemetry/privacy.js

@@ -0,0 +1,567 @@
+import { createHash } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { ANALYTICS_EVENT_NAMES, CPU_ARCHITECTURES, DURATION_BUCKETS, HTTP_METHODS, INSTRUMENTATION_SCOPES, LOG_EVENT_CODES, MAX_ACCOUNT_POOL_SIZE, MAX_ATTEMPT, MAX_CONCURRENCY, MAX_DURATION_MS, ERROR_KINDS, MAX_STACK_FRAMES, MAX_STACK_FRAME_PATH_LENGTH, MAX_TIMESTAMP_MS, MAX_TOKEN_COUNT, MAX_VERSION_LENGTH, MODEL_FAMILIES, OPERATIONS, OS_FAMILIES, OUTCOMES, PROVIDERS, REQUEST_SOURCES, ROUTES, RUNTIME_MODES, SETUP_METHODS, SETUP_REASONS, SETUP_STAGES, SEVERITIES, SPAN_KINDS, SPAN_STATUS_CODES, STREAM_OUTCOMES, SYSTEM_ERROR_CODES, } from "./contracts.js";
+// Only frames under this package's own dist/ or node_modules/ survive, so the
+// user's home directory and workspace layout never reach a stack trace.
+const PROJECT_ROOT = fileURLToPath(new URL("../../", import.meta.url))
+    .replace(/\\/g, "/")
+    .replace(/\/+$/, "");
+const CASE_INSENSITIVE_ROOT = process.platform === "win32";
+const COMPARISON_ROOT = CASE_INSENSITIVE_ROOT ? PROJECT_ROOT.toLowerCase() : PROJECT_ROOT;
+/** OTel attribute name for every field of the closed span schema. */
+export const SPAN_ATTRIBUTE_KEYS = {
+    httpMethod: "http.request.method",
+    httpStatusCode: "http.response.status_code",
+    provider: "cc_router.provider",
+    route: "cc_router.route",
+    modelFamily: "cc_router.model_family",
+    requestSource: "cc_router.request_source",
+    runtimeMode: "cc_router.runtime_mode",
+    streaming: "cc_router.streaming",
+    streamOutcome: "cc_router.stream_outcome",
+    outcome: "cc_router.outcome",
+    attempt: "cc_router.attempt",
+    accountPoolSize: "cc_router.account_pool_size",
+    concurrency: "cc_router.concurrency",
+    inputTokens: "cc_router.input_tokens",
+    outputTokens: "cc_router.output_tokens",
+    operationDurationMs: "cc_router.operation_duration_ms",
+};
+/** OTel attribute name for every field of both closed log schemas. */
+export const LOG_ATTRIBUTE_KEYS = {
+    operation: "cc_router.operation",
+    provider: "cc_router.provider",
+    method: "cc_router.method",
+    stage: "cc_router.stage",
+    reason: "cc_router.reason",
+    outcome: "cc_router.outcome",
+    httpStatusCode: "http.response.status_code",
+    durationBucket: "cc_router.duration_bucket",
+    attempt: "cc_router.attempt",
+    accountPoolSize: "cc_router.account_pool_size",
+    concurrency: "cc_router.concurrency",
+    operationDurationMs: "cc_router.operation_duration_ms",
+    serviceVersion: "service.version",
+    osFamily: "os.type",
+    runtimeMode: "cc_router.runtime_mode",
+    diagnosticId: "cc_router.diagnostic_id",
+};
+/** OTel attribute name for every field of the closed resource schema. */
+export const RESOURCE_ATTRIBUTE_KEYS = {
+    serviceName: "service.name",
+    serviceVersion: "service.version",
+    serviceInstanceId: "service.instance.id",
+    nodeVersion: "process.runtime.version",
+    osFamily: "os.type",
+    cpuArchitecture: "host.arch",
+    runtimeMode: "cc_router.runtime_mode",
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function own(input, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    return descriptor && "value" in descriptor ? descriptor.value : undefined;
+}
+function member(values, value) {
+    return typeof value === "string" && values.includes(value)
+        ? value
+        : undefined;
+}
+function otherEnum(values, value) {
+    if (value === undefined)
+        return undefined;
+    return member(values, value) ?? member(values, "other");
+}
+function boundedInteger(value, maximum, minimum = 0) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= minimum && value <= maximum
+        ? value
+        : undefined;
+}
+function boundedNumber(value, maximum, minimum = 0) {
+    return typeof value === "number" && Number.isFinite(value) && value >= minimum && value <= maximum
+        ? value
+        : undefined;
+}
+function version(value) {
+    if (typeof value !== "string" || value.length > MAX_VERSION_LENGTH)
+        return undefined;
+    return /^\d+\.\d+\.\d+(?:-[0-9a-z.-]+)?$/.test(value) ? value : undefined;
+}
+function uuid(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.toLowerCase();
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(normalized)
+        ? normalized
+        : undefined;
+}
+function installationId(identity) {
+    return uuid(identity?.installationId);
+}
+/** A per-occurrence diagnostic id must never collapse onto the stable install id. */
+function diagnosticId(identity, trustedInstallationId) {
+    if (identity?.diagnosticId === undefined)
+        return undefined;
+    const value = uuid(identity.diagnosticId);
+    return value && value !== trustedInstallationId ? value : undefined;
+}
+function hexId(value, length) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.toLowerCase();
+    return new RegExp(`^[0-9a-f]{${length}}$`).test(normalized) && !/^0+$/.test(normalized)
+        ? normalized
+        : undefined;
+}
+function httpStatusCode(value) {
+    return boundedInteger(value, 599, 100);
+}
+function setupMethodForProvider(provider, value) {
+    const method = member(SETUP_METHODS, value);
+    if (provider === "anthropic") {
+        return method === "macos_keychain" || method === "claude_credentials_file" || method === "manual_token"
+            ? method
+            : undefined;
+    }
+    return method === "manual_token" || method === "device_oauth" ? method : undefined;
+}
+function assignIfDefined(target, key, value) {
+    if (value !== undefined)
+        Object.assign(target, { [key]: value });
+}
+/** Project a reconstructed record onto its OTel attribute names. */
+export function toOtelAttributes(keys, safe) {
+    const output = {};
+    for (const [field, attribute] of Object.entries(keys)) {
+        const value = own(safe, field);
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            output[attribute] = value;
+        }
+    }
+    return output;
+}
+/** Read an untrusted OTel attribute bag back into candidate record fields. */
+export function fromOtelAttributes(keys, attributes) {
+    const output = {};
+    for (const [field, attribute] of Object.entries(keys)) {
+        output[field] = own(attributes, attribute);
+    }
+    return output;
+}
+function errorKind(input) {
+    if (typeof AggregateError !== "undefined" && input instanceof AggregateError)
+        return "aggregate_error";
+    if (input instanceof TypeError)
+        return "type_error";
+    if (input instanceof RangeError)
+        return "range_error";
+    if (input instanceof ReferenceError)
+        return "reference_error";
+    if (input instanceof SyntaxError)
+        return "syntax_error";
+    if (input instanceof URIError)
+        return "uri_error";
+    if (input instanceof EvalError)
+        return "eval_error";
+    return "error";
+}
+// UUID-shaped segments are stripped: a temp/cache directory name can identify
+// an install as reliably as a home directory does.
+function safePathSegments(path) {
+    return path.split("/").every((segment) => segment.length > 0
+        && segment !== "."
+        && segment !== ".."
+        && !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(segment)
+        && /^[0-9A-Za-z@._+~-]+$/.test(segment));
+}
+function normalizedFramePath(rawPath) {
+    let path = rawPath.trim().replace(/\\/g, "/");
+    const openingParenthesis = path.lastIndexOf("(");
+    if (openingParenthesis >= 0)
+        path = path.slice(openingParenthesis + 1);
+    if (/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(path) && !path.startsWith("file://"))
+        return undefined;
+    if (path.startsWith("file://"))
+        path = path.slice("file://".length);
+    if (/^\/[A-Za-z]:\//.test(path))
+        path = path.slice(1);
+    const comparisonPath = CASE_INSENSITIVE_ROOT ? path.toLowerCase() : path;
+    const projectDistPrefix = `${COMPARISON_ROOT}/dist/`;
+    if (comparisonPath.startsWith(projectDistPrefix)) {
+        const relative = `dist/${path.slice(projectDistPrefix.length)}`;
+        return relative.length <= MAX_STACK_FRAME_PATH_LENGTH && safePathSegments(relative)
+            ? relative
+            : undefined;
+    }
+    const dependencyIndex = path.lastIndexOf("/node_modules/");
+    if (dependencyIndex >= 0) {
+        const relative = path.slice(dependencyIndex + 1);
+        const segments = relative.split("/");
+        const packageSegmentCount = segments[1]?.startsWith("@") ? 2 : 1;
+        if (segments.length < packageSegmentCount + 2 || !safePathSegments(relative))
+            return undefined;
+        return relative.length <= MAX_STACK_FRAME_PATH_LENGTH
+            ? relative
+            : undefined;
+    }
+    return undefined;
+}
+function stackHeaderName(kind) {
+    switch (kind) {
+        case "type_error": return "TypeError";
+        case "range_error": return "RangeError";
+        case "reference_error": return "ReferenceError";
+        case "syntax_error": return "SyntaxError";
+        case "uri_error": return "URIError";
+        case "eval_error": return "EvalError";
+        case "aggregate_error": return "AggregateError";
+        default: return "Error";
+    }
+}
+function normalizedFrames(input, kind) {
+    const stack = input.stack;
+    if (typeof stack !== "string")
+        return [];
+    // The header carries the raw message. Parse frames only after removing it
+    // verbatim, so a multiline message can never inject a frame.
+    const rawMessage = own(input, "message");
+    if (rawMessage !== undefined && typeof rawMessage !== "string")
+        return [];
+    const header = `${stackHeaderName(kind)}${rawMessage ? `: ${rawMessage}` : ""}`;
+    if (!stack.startsWith(`${header}\n`))
+        return [];
+    const frames = [];
+    for (const line of stack.slice(header.length + 1).split("\n")) {
+        if (frames.length >= MAX_STACK_FRAMES)
+            break;
+        const match = line.match(/(?:\(|\bat\s+)(.+):(\d+):(\d+)\)?\s*$/);
+        if (!match)
+            continue;
+        const path = normalizedFramePath(match[1]);
+        const frameLine = boundedInteger(Number(match[2]), Number.MAX_SAFE_INTEGER, 1);
+        const column = boundedInteger(Number(match[3]), Number.MAX_SAFE_INTEGER, 1);
+        if (!path || frameLine === undefined || column === undefined)
+            continue;
+        frames.push({ path, line: frameLine, column });
+    }
+    return frames;
+}
+function sanitizedError(reason, frames) {
+    const error = new Error(reason);
+    error.stack = [
+        `Error: ${reason}`,
+        ...frames.map(frame => `    at ${frame.path}:${frame.line}:${frame.column}`),
+    ].join("\n");
+    return error;
+}
+function fingerprint(kind, context, systemErrorCode, status, frames) {
+    return createHash("sha256").update(JSON.stringify({
+        errorKind: kind,
+        category: context.category,
+        reason: context.reason,
+        operation: context.operation,
+        provider: context.provider,
+        setupStage: context.setupStage,
+        runtimeMode: context.runtimeMode,
+        systemErrorCode,
+        httpStatusCode: status,
+        frames,
+    })).digest("hex");
+}
+function exceptionContext(input) {
+    if (!isRecord(input))
+        return undefined;
+    const category = input.category === "setup" || input.category === "runtime" ? input.category : undefined;
+    const reason = otherEnum(SETUP_REASONS, input.reason);
+    if (!category || !reason)
+        return undefined;
+    const output = { category, reason };
+    assignIfDefined(output, "operation", member(OPERATIONS, input.operation));
+    assignIfDefined(output, "provider", otherEnum(PROVIDERS, input.provider));
+    assignIfDefined(output, "setupStage", member(SETUP_STAGES, input.setupStage));
+    assignIfDefined(output, "runtimeMode", member(RUNTIME_MODES, input.runtimeMode));
+    return output;
+}
+/**
+ * Reconstruct an exception from closed safe values. No original Error object,
+ * message, cause, or arbitrary thrown-value property escapes this boundary;
+ * a hostile thrown value can only cause the occurrence to be dropped.
+ */
+export function sanitizeException(input, candidateContext, identity) {
+    try {
+        const trustedInstallationId = installationId(identity);
+        if (!trustedInstallationId)
+            return undefined;
+        const trustedDiagnosticId = diagnosticId(identity, trustedInstallationId);
+        const context = exceptionContext(candidateContext);
+        if (!trustedDiagnosticId || !context)
+            return undefined;
+        const isError = input instanceof Error;
+        const kind = isError ? errorKind(input) : "unexpected_error";
+        const frames = isError ? normalizedFrames(input, kind) : [];
+        const code = isError
+            ? member(SYSTEM_ERROR_CODES, own(input, "code"))
+            : undefined;
+        const status = isError
+            ? httpStatusCode(own(input, "statusCode")) ?? httpStatusCode(own(input, "status"))
+            : undefined;
+        const output = {
+            error: sanitizedError(context.reason, frames),
+            ...context,
+            errorKind: kind,
+            frames,
+            fingerprint: fingerprint(kind, context, code, status, frames),
+            diagnosticId: trustedDiagnosticId,
+        };
+        assignIfDefined(output, "systemErrorCode", code);
+        assignIfDefined(output, "httpStatusCode", status);
+        return output;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function reconstructResource(input, identity) {
+    if (!isRecord(input) || input.serviceName !== "cc-router")
+        return undefined;
+    const serviceVersion = version(input.serviceVersion);
+    const nodeVersion = version(input.nodeVersion);
+    const serviceInstanceId = installationId(identity);
+    const runtimeMode = member(RUNTIME_MODES, input.runtimeMode);
+    const osFamily = otherEnum(OS_FAMILIES, input.osFamily);
+    const cpuArchitecture = otherEnum(CPU_ARCHITECTURES, input.cpuArchitecture);
+    if (!serviceVersion || !nodeVersion || !serviceInstanceId || !runtimeMode || !osFamily || !cpuArchitecture) {
+        return undefined;
+    }
+    return {
+        "service.name": "cc-router",
+        "service.version": serviceVersion,
+        "service.instance.id": serviceInstanceId,
+        "process.runtime.version": nodeVersion,
+        "os.type": osFamily,
+        "host.arch": cpuArchitecture,
+        "cc_router.runtime_mode": runtimeMode,
+    };
+}
+function reconstructSpanAttributes(input) {
+    if (!isRecord(input))
+        return {};
+    const output = {};
+    assignIfDefined(output, "httpMethod", member(HTTP_METHODS, input.httpMethod));
+    assignIfDefined(output, "httpStatusCode", httpStatusCode(input.httpStatusCode));
+    assignIfDefined(output, "provider", otherEnum(PROVIDERS, input.provider));
+    assignIfDefined(output, "route", otherEnum(ROUTES, input.route));
+    assignIfDefined(output, "modelFamily", otherEnum(MODEL_FAMILIES, input.modelFamily));
+    assignIfDefined(output, "requestSource", otherEnum(REQUEST_SOURCES, input.requestSource));
+    assignIfDefined(output, "runtimeMode", member(RUNTIME_MODES, input.runtimeMode));
+    assignIfDefined(output, "streaming", typeof input.streaming === "boolean" ? input.streaming : undefined);
+    assignIfDefined(output, "streamOutcome", otherEnum(STREAM_OUTCOMES, input.streamOutcome));
+    assignIfDefined(output, "outcome", otherEnum(OUTCOMES, input.outcome));
+    assignIfDefined(output, "attempt", boundedInteger(input.attempt, MAX_ATTEMPT));
+    assignIfDefined(output, "accountPoolSize", boundedInteger(input.accountPoolSize, MAX_ACCOUNT_POOL_SIZE));
+    assignIfDefined(output, "concurrency", boundedInteger(input.concurrency, MAX_CONCURRENCY));
+    assignIfDefined(output, "inputTokens", boundedInteger(input.inputTokens, MAX_TOKEN_COUNT));
+    assignIfDefined(output, "outputTokens", boundedInteger(input.outputTokens, MAX_TOKEN_COUNT));
+    assignIfDefined(output, "operationDurationMs", boundedNumber(input.operationDurationMs, MAX_DURATION_MS));
+    return output;
+}
+export function reconstructSpan(input) {
+    if (!isRecord(input))
+        return undefined;
+    const scope = member(INSTRUMENTATION_SCOPES, input.scope);
+    const operation = member(OPERATIONS, input.operation);
+    const traceId = hexId(input.traceId, 32);
+    const spanId = hexId(input.spanId, 16);
+    const kind = member(SPAN_KINDS, input.kind);
+    const startTimeMs = boundedNumber(input.startTimeMs, MAX_TIMESTAMP_MS);
+    const durationMs = boundedNumber(input.durationMs, MAX_DURATION_MS);
+    const statusCode = member(SPAN_STATUS_CODES, input.statusCode);
+    if (!scope || !operation || !traceId || !spanId || !kind || startTimeMs === undefined
+        || durationMs === undefined || !statusCode) {
+        return undefined;
+    }
+    const output = {
+        scope,
+        name: operation,
+        traceId,
+        spanId,
+        kind,
+        startTimeMs,
+        durationMs,
+        statusCode,
+        attributes: reconstructSpanAttributes(input.attributes),
+    };
+    assignIfDefined(output, "parentSpanId", hexId(input.parentSpanId, 16));
+    return output;
+}
+function setupAttributes(input, trustedDiagnosticId) {
+    if (!isRecord(input))
+        return undefined;
+    const provider = member(PROVIDERS, input.provider);
+    if (provider !== "anthropic" && provider !== "openai")
+        return undefined;
+    const method = setupMethodForProvider(provider, input.method);
+    const stage = member(SETUP_STAGES, input.stage);
+    if (!method || !stage)
+        return undefined;
+    const output = { provider, method, stage, diagnosticId: trustedDiagnosticId };
+    assignIfDefined(output, "reason", otherEnum(SETUP_REASONS, input.reason));
+    assignIfDefined(output, "outcome", otherEnum(OUTCOMES, input.outcome));
+    assignIfDefined(output, "httpStatusCode", httpStatusCode(input.httpStatusCode));
+    assignIfDefined(output, "durationBucket", member(DURATION_BUCKETS, input.durationBucket));
+    assignIfDefined(output, "serviceVersion", version(input.serviceVersion));
+    assignIfDefined(output, "osFamily", otherEnum(OS_FAMILIES, input.osFamily));
+    assignIfDefined(output, "runtimeMode", member(RUNTIME_MODES, input.runtimeMode));
+    return output;
+}
+function runtimeFailureAttributes(input, trustedDiagnosticId) {
+    if (!isRecord(input))
+        return undefined;
+    const operation = member(OPERATIONS, input.operation);
+    const reason = otherEnum(SETUP_REASONS, input.reason);
+    if (!operation || !reason)
+        return undefined;
+    const output = { operation, reason };
+    assignIfDefined(output, "provider", otherEnum(PROVIDERS, input.provider));
+    assignIfDefined(output, "outcome", otherEnum(OUTCOMES, input.outcome));
+    assignIfDefined(output, "httpStatusCode", httpStatusCode(input.httpStatusCode));
+    assignIfDefined(output, "attempt", boundedInteger(input.attempt, MAX_ATTEMPT));
+    assignIfDefined(output, "accountPoolSize", boundedInteger(input.accountPoolSize, MAX_ACCOUNT_POOL_SIZE));
+    assignIfDefined(output, "concurrency", boundedInteger(input.concurrency, MAX_CONCURRENCY));
+    assignIfDefined(output, "operationDurationMs", boundedNumber(input.operationDurationMs, MAX_DURATION_MS));
+    assignIfDefined(output, "serviceVersion", version(input.serviceVersion));
+    assignIfDefined(output, "osFamily", otherEnum(OS_FAMILIES, input.osFamily));
+    assignIfDefined(output, "runtimeMode", member(RUNTIME_MODES, input.runtimeMode));
+    assignIfDefined(output, "diagnosticId", trustedDiagnosticId);
+    return output;
+}
+export function reconstructLog(input, identity) {
+    if (!isRecord(input))
+        return undefined;
+    const scope = member(INSTRUMENTATION_SCOPES, input.scope);
+    const body = member(LOG_EVENT_CODES, input.body);
+    const severity = member(SEVERITIES, input.severity);
+    const timestampMs = boundedNumber(input.timestampMs, MAX_TIMESTAMP_MS);
+    const trustedInstallationId = installationId(identity);
+    if (!scope || !body || !severity || timestampMs === undefined || !trustedInstallationId)
+        return undefined;
+    const trustedDiagnosticId = diagnosticId(identity, trustedInstallationId);
+    if (identity.diagnosticId !== undefined && !trustedDiagnosticId)
+        return undefined;
+    if (body === "account.setup.diagnostic" && !trustedDiagnosticId)
+        return undefined;
+    const attributes = body === "account.setup.diagnostic"
+        ? setupAttributes(input.attributes, trustedDiagnosticId)
+        : runtimeFailureAttributes(input.attributes, trustedDiagnosticId);
+    if (!attributes)
+        return undefined;
+    const context = {};
+    assignIfDefined(context, "traceId", hexId(input.traceId, 32));
+    assignIfDefined(context, "spanId", hexId(input.spanId, 16));
+    return body === "account.setup.diagnostic"
+        ? { scope, body, severity, timestampMs, ...context, attributes: attributes }
+        : { scope, body, severity, timestampMs, ...context, attributes: attributes };
+}
+function runtimeEventProperties(input) {
+    if (!isRecord(input))
+        return undefined;
+    const output = {};
+    assignIfDefined(output, "serviceVersion", version(input.serviceVersion));
+    assignIfDefined(output, "osFamily", otherEnum(OS_FAMILIES, input.osFamily));
+    assignIfDefined(output, "runtimeMode", member(RUNTIME_MODES, input.runtimeMode));
+    assignIfDefined(output, "accountPoolSize", boundedInteger(input.accountPoolSize, MAX_ACCOUNT_POOL_SIZE));
+    return output;
+}
+function setupEventProperties(input, trustedDiagnosticId) {
+    const attributes = setupAttributes(input, trustedDiagnosticId);
+    if (!attributes)
+        return undefined;
+    const output = {
+        provider: attributes.provider,
+        method: attributes.method,
+        stage: attributes.stage,
+        diagnosticId: trustedDiagnosticId,
+    };
+    assignIfDefined(output, "reason", attributes.reason);
+    assignIfDefined(output, "durationBucket", attributes.durationBucket);
+    assignIfDefined(output, "serviceVersion", attributes.serviceVersion);
+    assignIfDefined(output, "osFamily", attributes.osFamily);
+    assignIfDefined(output, "runtimeMode", attributes.runtimeMode);
+    return output;
+}
+export function reconstructAnalyticsEvent(input, identity) {
+    if (!isRecord(input))
+        return undefined;
+    const event = member(ANALYTICS_EVENT_NAMES, input.event);
+    const trustedInstallationId = installationId(identity);
+    if (!event || !trustedInstallationId)
+        return undefined;
+    const isSetupEvent = event.startsWith("account_setup.");
+    const trustedDiagnosticId = diagnosticId(identity, trustedInstallationId);
+    if (identity.diagnosticId !== undefined && !trustedDiagnosticId)
+        return undefined;
+    if (isSetupEvent && !trustedDiagnosticId)
+        return undefined;
+    const properties = isSetupEvent
+        ? setupEventProperties(input.properties, trustedDiagnosticId)
+        : runtimeEventProperties(input.properties);
+    if (!properties)
+        return undefined;
+    const output = { event, properties, installationId: trustedInstallationId };
+    assignIfDefined(output, "diagnosticId", trustedDiagnosticId);
+    return output;
+}
+/**
+ * Rebuild a sanitized exception that was persisted for crash-safe delivery.
+ * The record is re-validated against the same closed schema as a live
+ * sanitization; anything outside it (including an edited file) is dropped.
+ */
+export function rebuildSanitizedException(input) {
+    if (!isRecord(input))
+        return undefined;
+    const category = input.category === "setup" || input.category === "runtime" ? input.category : undefined;
+    const reason = member(SETUP_REASONS, input.reason);
+    const errorKind = member(ERROR_KINDS, input.errorKind);
+    const fingerprint = typeof input.fingerprint === "string" && /^[0-9a-f]{64}$/.test(input.fingerprint)
+        ? input.fingerprint
+        : undefined;
+    const diagnosticId = uuid(input.diagnosticId);
+    if (!category || !reason || !errorKind || !fingerprint || !diagnosticId || !Array.isArray(input.frames)) {
+        return undefined;
+    }
+    const frames = [];
+    for (const frame of input.frames.slice(0, MAX_STACK_FRAMES)) {
+        if (!isRecord(frame) || typeof frame.path !== "string")
+            return undefined;
+        const path = frame.path;
+        if (!/^(dist|node_modules)\//.test(path) || path.length > MAX_STACK_FRAME_PATH_LENGTH || !safePathSegments(path)) {
+            return undefined;
+        }
+        const line = frame.line === undefined ? undefined : boundedInteger(frame.line, Number.MAX_SAFE_INTEGER, 1);
+        const column = frame.column === undefined ? undefined : boundedInteger(frame.column, Number.MAX_SAFE_INTEGER, 1);
+        if ((frame.line !== undefined && line === undefined) || (frame.column !== undefined && column === undefined)) {
+            return undefined;
+        }
+        const safeFrame = { path: path };
+        assignIfDefined(safeFrame, "line", line);
+        assignIfDefined(safeFrame, "column", column);
+        frames.push(safeFrame);
+    }
+    const contract = {
+        error: sanitizedError(reason, frames),
+        category,
+        reason,
+        errorKind,
+        frames,
+        fingerprint,
+        diagnosticId,
+    };
+    assignIfDefined(contract, "systemErrorCode", member(SYSTEM_ERROR_CODES, input.systemErrorCode));
+    assignIfDefined(contract, "httpStatusCode", httpStatusCode(input.httpStatusCode));
+    assignIfDefined(contract, "operation", member(OPERATIONS, input.operation));
+    assignIfDefined(contract, "provider", member(PROVIDERS, input.provider));
+    assignIfDefined(contract, "setupStage", member(SETUP_STAGES, input.setupStage));
+    assignIfDefined(contract, "runtimeMode", member(RUNTIME_MODES, input.runtimeMode));
+    return contract;
+}