engineering-behavior-observatory 0.2.1

package/dist/src/exports.js

@@ -0,0 +1,966 @@
+import { createHash } from "node:crypto";
+import { mkdir, rm } from "node:fs/promises";
+import { homedir, userInfo } from "node:os";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { assertNoDuplicateJsonKeys, assertUniqueArtifactIdentities, canonicalizeMetadata, digestMetadata, inspectRetainedArtifact, readVerifiedArtifact, validateArtifact, validateRunManifestEvidence, writeArtifactAtomically, writeMetadataAtomically, } from "./artifacts.js";
+/** Sanitize a caller-allowlisted derived document; this does not grant sharing approval. */
+export function sanitizeDerivedExport(value, policy, correlations = []) {
+    validatePolicy(policy);
+    const sensitive = effectiveSensitiveValues(policy);
+    const replacements = new Map(correlations.map((source) => [source, `ref-${createHash("sha256").update(source).digest("hex").slice(0, 20)}`]));
+    // Derived views may embed cited session envelopes; apply native reasoning omission too.
+    const bytes = sanitizeArtifact(Buffer.from(canonicalizeMetadata(value)), "application/json", policy, replacements, sensitive, [homedir(), userInfo().username], new Map(), "session");
+    scanPortableTree([{ bytes, mediaType: "application/json" }], sensitive, correlations);
+    return JSON.parse(bytes.toString("utf8"));
+}
+const MAX_SOURCE_ARTIFACT_BYTES = 64 * 1024 * 1024;
+const HIDDEN_FIELDS = new Set([
+    "chainofthought",
+    "extendedthinking",
+    "hiddenreasoning",
+    "encryptedreasoning",
+    "encryptedthinking",
+    "rawapibody",
+    "rawrequestbody",
+    "rawresponsebody",
+    "reasoning",
+    "reasoningcontent",
+    "reasoningdetails",
+    "reasoningsignature",
+    "thinking",
+    "thinkingcontent",
+    "thinkingsignature",
+    "textsignature",
+    "thoughtsignature",
+]);
+const CODEX_REASONING_DELTA_METHOD = "item/reasoning/textDelta";
+const CODEX_REASONING_CONTENT_FIELDS = new Set(["content", "delta", "encryptedcontent", "summary", "text"]);
+const CURSOR_REASONING_TYPES = new Set(["thinking", "thinkingdelta", "thinkingcompleted", "thinkingmessage"]);
+const PI_PRIVATE_CONTENT_TYPES = new Set([
+    "thinking", "thinkingstart", "thinkingdelta", "thinkingend",
+    "reasoning", "reasoningstart", "reasoningdelta", "reasoningend",
+]);
+const PI_PRIVATE_CONTENT_FIELDS = new Set(["content", "delta", "encryptedcontent", "reasoning", "signature", "summary", "text", "thinking", "thinkingsignature"]);
+const PI_PRIVATE_FIELDS = new Set(["encryptedreasoning", "encryptedthinking", "reasoningcontent", "reasoningdetails", "reasoningsignature", "thinkingcontent", "thinkingsignature", "textsignature", "thoughtsignature"]);
+const SECRET_FIELDS = new Set([
+    "accesskey",
+    "accesstoken",
+    "apikey",
+    "authorization",
+    "blobencryptionkey",
+    "clientsecret",
+    "connectionstring",
+    "credential",
+    "credentials",
+    "credentialsjson",
+    "databaseurl",
+    "idtoken",
+    "oauthtoken",
+    "password",
+    "privatekey",
+    "refreshtoken",
+    "secret",
+    "secretaccesskey",
+    "token",
+]);
+// "eborunid"/"eboattemptid" are the normalized EBO OTel resource-attribute keys
+// ("ebo.run.id"/"ebo.attempt.id") retained inside native telemetry evidence.
+const CORRELATION_FIELDS = new Set(["attemptid", "bundleid", "id", "runid", "sessionid", "traceid", "eborunid", "eboattemptid"]);
+const LOCAL_IDENTIFIER_FIELDS = new Set(["login", "owner", "user", "username"]);
+const TRUNCATABLE_FIELDS = new Set([
+    "body",
+    "commandoutput",
+    "content",
+    "diff",
+    "filecontent",
+    "input",
+    "output",
+    "patch",
+    "prompt",
+    "stderr",
+    "stdout",
+    "text",
+    "toolinput",
+    "toolresult",
+]);
+const SECRET_PATTERNS = [
+    /()(?:-----BEGIN (?:(?:RSA |EC |DSA |OPENSSH |ENCRYPTED )?PRIVATE KEY|PGP PRIVATE KEY BLOCK)-----[\s\S]*?(?:-----END (?:(?:RSA |EC |DSA |OPENSSH |ENCRYPTED )?PRIVATE KEY|PGP PRIVATE KEY BLOCK)-----|$))()/gu,
+    /()(?:\b(?:gh[pousr]_[A-Za-z0-9_]{20,}|sk-ant-[A-Za-z0-9_-]{12,}|AKIA[0-9A-Z]{16})\b)()/gu,
+    /((?:authorization)\s*[:=])(?!(?:\s*)\[REDACTED_)\s*[^\r\n]+()/giu,
+    /((?:authorization|api[_-]?key|(?:access|oauth|refresh|id)?[_-]?token|client[_-]?secret|private[_-]?key|secret[_-]?access[_-]?key|credentials?(?:[_-]?json)?|database[_-]?url|connection[_-]?string|password)\s*[:=]\s*")(?!\[REDACTED_SECRET\]")(?:\\.|[^"\\])*(")/giu,
+    /((?:authorization|api[_-]?key|(?:access|oauth|refresh|id)?[_-]?token|client[_-]?secret|private[_-]?key|secret[_-]?access[_-]?key|credentials?(?:[_-]?json)?|database[_-]?url|connection[_-]?string|password)\s*[:=]\s*')(?!\[REDACTED_SECRET\]')(?:\\.|[^'\\])*(')/giu,
+    /((?:authorization|api[_-]?key|(?:access|oauth|refresh|id)?[_-]?token|client[_-]?secret|private[_-]?key|secret[_-]?access[_-]?key|credentials?(?:[_-]?json)?|database[_-]?url|connection[_-]?string|password)\s*[:=])(?!(?:\s*(?:Bearer\s+)?)\[REDACTED_)\s*(?:Bearer\s+)?[^\s,"'}\]]{8,}()/giu,
+];
+const LOCAL_IDENTIFIER_PATTERNS = [
+    /((?:user(?:name)?|owner|login)\s*[:=]\s*")(?!\[LOCAL_USER\]")(?:\\.|[^"\\])*(")/giu,
+    /((?:user(?:name)?|owner|login)\s*[:=]\s*')(?!\[LOCAL_USER\]')(?:\\.|[^'\\])*(')/giu,
+    /((?:user(?:name)?|owner|login)\s*[:=])(?!(?:\s*)\[LOCAL_USER\])\s*[^\s,"'}\]]+()/giu,
+];
+const LOCAL_PATH = /(^|[\s"'=:(+\-])(?:[A-Za-z]:\\(?:[^\\\s"']+\\)*[^\\\s"']*|\/(?!\/)[^\s"']+)/gu;
+const LOCAL_HOME_PATH = /(?:^|[\s`"'=:(+\-]|file:\/\/)(?:[A-Za-z]:\\+Users\\+[^\\\s`"']+(?=[\\\s`"',;:)}\]]|$)|\/(?:Users|home)\/[^/\s`"']+(?=[/\s`"',;:)}\]]|$)|\/root(?=[/\s`"',;:)}\]]|$))/giu;
+/** Create one separately rooted, sanitized derivative of an M2 run bundle. */
+export async function createPortableRunBundleExport(options) {
+    validatePolicy(options.policy);
+    const sourceRoot = resolve(options.sourceRoot);
+    const destinationRoot = resolve(options.destinationRoot);
+    const destinationWithinSource = relative(sourceRoot, destinationRoot);
+    if (destinationWithinSource === "" || (!destinationWithinSource.startsWith("..") && !isAbsolute(destinationWithinSource))) {
+        throw new Error("Portable export destination must be outside the restricted source bundle.");
+    }
+    const { manifest: sourceManifest, digest: sourceManifestDigest } = await readSourceManifest(sourceRoot);
+    const sourceErrors = [
+        ...validateArtifact("manifest.json", sourceManifest),
+        ...validateRunManifestEvidence("manifest.json", sourceManifest, sourceRoot),
+    ];
+    if (sourceErrors.length > 0)
+        throw new Error(formatValidationErrors(sourceErrors));
+    for (const descriptor of sourceManifest.evidence) {
+        if (descriptor.sharingClass === "unknown") {
+            throw new Error(`Artifact ${descriptor.id} has an unknown sharing classification.`);
+        }
+        if (!["restricted", "internal"].includes(descriptor.sharingClass)) {
+            throw new Error(`Artifact ${descriptor.id} is not a restricted or internal M2 source artifact.`);
+        }
+    }
+    const policyDigest = digestString(digestMetadata(policyRecord(options.policy)));
+    const correlations = correlationProjection(sourceManifest, policyDigest);
+    const replacements = correlationReplacements(sourceManifest, correlations);
+    const sensitiveValues = effectiveSensitiveValues(options.policy);
+    const localIdentifiers = [homedir(), userInfo().username].filter((value) => value.length > 1);
+    const artifacts = [];
+    const transformations = [];
+    const excludedArtifacts = [];
+    await mkdir(dirname(destinationRoot), { recursive: true, mode: 0o700 });
+    await mkdir(destinationRoot, { mode: 0o700 });
+    try {
+        const portableDiagnostics = new Map();
+        let diagnosticIndex = sourceManifest.evidence.length;
+        for (const verifier of sourceManifest.evidence.filter(({ kind }) => kind === "verifier")) {
+            const verifierBytes = await readVerifiedArtifact(sourceRoot, verifier.relativePath, digestValue(verifier.digest), MAX_SOURCE_ARTIFACT_BYTES);
+            for (const [index, diagnostic] of sourceDiagnostics(parseJson(verifierBytes, "Verifier evidence")).entries()) {
+                if (portableDiagnostics.has(diagnostic.locator)) {
+                    throw new Error(`Verifier diagnostic ${diagnostic.locator} is referenced more than once.`);
+                }
+                const sourceBytes = await readVerifiedArtifact(sourceRoot, diagnostic.locator, digestValue(diagnostic.digest), MAX_SOURCE_ARTIFACT_BYTES);
+                if (sourceBytes.length !== diagnostic.sizeBytes) {
+                    throw new Error(`Verifier diagnostic ${diagnostic.locator} size does not match its source reference.`);
+                }
+                const id = `diagnostic-${createHash("sha256").update(`${verifier.id}\0${String(index)}\0${diagnostic.locator}`).digest("hex").slice(0, 24)}`;
+                const relativePath = `evidence/${String(diagnosticIndex++).padStart(4, "0")}.txt`;
+                const counts = new Map([["sanitized", 1]]);
+                const outputBytes = sanitizeArtifact(sourceBytes, "text/plain", options.policy, replacements, sensitiveValues, localIdentifiers, counts, "diagnostic");
+                const digest = await writeArtifactAtomically(destinationRoot, relativePath, outputBytes, undefined, { overwrite: false });
+                const artifact = {
+                    id,
+                    sourceArtifactId: id,
+                    kind: "diagnostic",
+                    mediaType: "text/plain",
+                    digest: digestString(digest),
+                    sizeBytes: outputBytes.length,
+                    relativePath,
+                    sourceDigest: diagnostic.digest,
+                    diagnosticSource: {
+                        verifierId: verifier.id,
+                        stream: diagnostic.stream,
+                        locatorDigest: digestText(diagnostic.locator),
+                        sizeBytes: diagnostic.sizeBytes,
+                    },
+                };
+                artifacts.push(artifact);
+                transformations.push(...[...counts.entries()].map(([action, count]) => ({ artifactId: id, action, count })));
+                portableDiagnostics.set(diagnostic.locator, { artifact, truncated: diagnostic.truncated || counts.has("truncated") });
+            }
+        }
+        for (const [index, descriptor] of sourceManifest.evidence.entries()) {
+            if (descriptor.kind === "export-manifest") {
+                excludedArtifacts.push({ artifactId: descriptor.id, reason: "source-export-manifest" });
+                continue;
+            }
+            if (descriptor.kind === "workspace" && descriptor.mediaType === "application/gzip") {
+                excludedArtifacts.push({ artifactId: descriptor.id, reason: "unsupported-workspace-snapshot" });
+                continue;
+            }
+            assertSupportedPair(descriptor.kind, descriptor.mediaType);
+            const sourceBytes = await readVerifiedArtifact(sourceRoot, descriptor.relativePath, digestValue(descriptor.digest), MAX_SOURCE_ARTIFACT_BYTES);
+            if (sourceBytes.length !== descriptor.sizeBytes) {
+                throw new Error(`Artifact ${descriptor.id} size does not match its source descriptor.`);
+            }
+            const counts = new Map([["sanitized", 1]]);
+            const outputBytes = sanitizeArtifact(sourceBytes, descriptor.mediaType, options.policy, replacements, sensitiveValues, localIdentifiers, counts, descriptor.kind, portableDiagnostics);
+            const relativePath = `evidence/${String(index).padStart(4, "0")}${extensionFor(descriptor.mediaType)}`;
+            const digest = await writeArtifactAtomically(destinationRoot, relativePath, outputBytes, undefined, { overwrite: false });
+            artifacts.push({
+                id: descriptor.id,
+                sourceArtifactId: descriptor.id,
+                kind: descriptor.kind,
+                mediaType: descriptor.mediaType,
+                digest: digestString(digest),
+                sizeBytes: outputBytes.length,
+                relativePath,
+                sourceDigest: descriptor.digest,
+            });
+            transformations.push(...[...counts.entries()].map(([action, count]) => ({ artifactId: descriptor.id, action, count })));
+        }
+        const manifest = {
+            schemaVersion: "export-manifest/v1",
+            bundleId: correlations.bundleId,
+            status: "ready",
+            sharingClass: options.policy.sharingClass,
+            assessmentMode: sourceManifest.run.assessmentMode,
+            policyDigest,
+            artifactIds: artifacts.map(({ id }) => id),
+            sourceManifestDigest,
+            correlations,
+            artifacts,
+            transformations,
+            excludedArtifacts,
+        };
+        const schemaErrors = validateArtifact("manifest.json", manifest);
+        if (schemaErrors.length > 0)
+            throw new Error(formatValidationErrors(schemaErrors));
+        await writeMetadataAtomically(destinationRoot, "manifest.json", manifest, undefined, { overwrite: false });
+        const readback = await readPortableRunBundleExport(destinationRoot, options.policy, sourceManifest, sourceRoot);
+        if (readback.sourceManifestDigest !== sourceManifestDigest) {
+            throw new Error("Portable export source-manifest digest changed before readback.");
+        }
+        return structuredClone(manifest);
+    }
+    catch (error) {
+        await rm(destinationRoot, { recursive: true, force: true });
+        throw error;
+    }
+}
+/** Read back and revalidate a completed portable export tree. */
+export async function readPortableRunBundleExport(exportRoot, policy, sourceManifest, sourceRoot) {
+    validatePolicy(policy);
+    const root = resolve(exportRoot);
+    const manifestBytes = await verifiedManifestBytes(root);
+    const manifest = parseJson(manifestBytes, "Portable export manifest");
+    const schemaErrors = validateArtifact("manifest.json", manifest);
+    if (schemaErrors.length > 0)
+        throw new Error(formatValidationErrors(schemaErrors));
+    if (manifest.status !== "ready" && manifest.status !== "exported")
+        throw new Error("Portable export is not ready.");
+    if (manifest.sharingClass !== policy.sharingClass || manifest.policyDigest !== digestString(digestMetadata(policyRecord(policy)))) {
+        throw new Error("Portable export policy does not match the requested policy.");
+    }
+    assertUniqueArtifactIdentities(manifest.artifacts.map(({ id, relativePath }) => ({ id, relativePath })));
+    if (JSON.stringify(manifest.artifactIds) !== JSON.stringify(manifest.artifacts.map(({ id }) => id))) {
+        throw new Error("Portable export artifact index does not match its descriptors.");
+    }
+    const included = new Set(manifest.artifactIds);
+    const includedSources = new Set(manifest.artifacts.map(({ sourceArtifactId }) => sourceArtifactId));
+    const excluded = new Set(manifest.excludedArtifacts.map(({ artifactId }) => artifactId));
+    if (includedSources.size !== manifest.artifacts.length || excluded.size !== manifest.excludedArtifacts.length
+        || [...excluded].some((id) => included.has(id) || includedSources.has(id))) {
+        throw new Error("Portable export exclusions are duplicate or included artifacts.");
+    }
+    if (manifest.transformations.some(({ artifactId, count }) => !included.has(artifactId) || !Number.isSafeInteger(count) || count < 1)) {
+        throw new Error("Portable export transformation references are invalid.");
+    }
+    const transformationKeys = new Set(manifest.transformations.map(({ artifactId, action }) => `${artifactId}\0${action}`));
+    if (transformationKeys.size !== manifest.transformations.length) {
+        throw new Error("Portable export contains duplicate transformation records.");
+    }
+    if (manifest.artifacts.some(({ id }) => !manifest.transformations.some(({ artifactId }) => artifactId === id))) {
+        throw new Error("Portable export omits an artifact transformation record.");
+    }
+    const artifactBytes = [];
+    for (const artifact of manifest.artifacts) {
+        assertSupportedPair(artifact.kind, artifact.mediaType);
+        const bytes = await readVerifiedArtifact(root, artifact.relativePath, digestValue(artifact.digest), policy.maxArtifactBytes);
+        if (bytes.length !== artifact.sizeBytes)
+            throw new Error(`Portable artifact ${artifact.id} size does not match its descriptor.`);
+        parseSanitizedArtifact(bytes, artifact.mediaType);
+        artifactBytes.push(bytes);
+    }
+    validatePortableDiagnosticReferences(manifest, artifactBytes);
+    if (sourceManifest !== undefined)
+        await validateSourceReferences(manifest, sourceManifest, sourceRoot);
+    scanPortableTree([
+        { bytes: manifestBytes, mediaType: "application/json" },
+        ...artifactBytes.map((bytes, index) => ({
+            bytes,
+            mediaType: manifest.artifacts[index].mediaType,
+        })),
+    ], effectiveSensitiveValues(policy), sourceManifest === undefined ? [] : sourceCorrelationValues(sourceManifest));
+    return structuredClone(manifest);
+}
+async function readSourceManifest(root) {
+    const inspected = await inspectRetainedArtifact(root, "manifest.json");
+    if (inspected.sizeBytes > 8 * 1024 * 1024)
+        throw new Error("Run manifest exceeds the export byte limit.");
+    const bytes = await readVerifiedArtifact(root, "manifest.json", inspected.digest, 8 * 1024 * 1024);
+    return { manifest: parseJson(bytes, "Run manifest"), digest: digestString(inspected.digest) };
+}
+async function verifiedManifestBytes(root) {
+    const inspected = await inspectRetainedArtifact(root, "manifest.json");
+    if (inspected.sizeBytes > 8 * 1024 * 1024)
+        throw new Error("Portable export manifest exceeds the readback byte limit.");
+    return readVerifiedArtifact(root, "manifest.json", inspected.digest, 8 * 1024 * 1024);
+}
+function sanitizeArtifact(bytes, mediaType, policy, replacements, sensitiveValues, localIdentifiers, counts, kind, portableDiagnostics = new Map()) {
+    if (mediaType === "application/json") {
+        increment(counts, "canonicalized");
+        const output = Buffer.from(canonicalizeMetadata(sanitizeValue(kind === "verifier"
+            ? rewriteVerifierDiagnosticReferences(parseJson(bytes, "JSON evidence"), portableDiagnostics)
+            : stripNativeReasoning(parseJson(bytes, "JSON evidence"), kind, counts), policy, replacements, sensitiveValues, localIdentifiers, counts)));
+        if (output.length > policy.maxArtifactBytes)
+            throw new Error("Sanitized JSON evidence exceeds the configured artifact limit.");
+        return output;
+    }
+    if (mediaType === "application/x-ndjson") {
+        const lines = decode(bytes, "JSONL evidence").split(/\r?\n/gu).filter((line) => line.trim() !== "");
+        if (lines.length === 0)
+            throw new Error("JSONL evidence is empty.");
+        increment(counts, "canonicalized", lines.length);
+        const sanitized = lines.map((line) => canonicalizeMetadata(sanitizeValue(stripNativeReasoning(parseJson(Buffer.from(line), "JSONL evidence record"), kind, counts), policy, replacements, sensitiveValues, localIdentifiers, counts)));
+        const retained = [];
+        for (const line of sanitized) {
+            if (Buffer.byteLength(`${[...retained, line].join("\n")}\n`) > policy.maxArtifactBytes)
+                break;
+            retained.push(line);
+        }
+        if (retained.length === 0)
+            throw new Error("Sanitized JSONL record exceeds the configured artifact limit.");
+        if (retained.length !== sanitized.length)
+            increment(counts, "truncated", sanitized.length - retained.length);
+        return Buffer.from(`${retained.join("\n")}\n`);
+    }
+    const sanitized = rewriteString(decode(bytes, "text evidence"), policy, replacements, sensitiveValues, localIdentifiers, counts, false, true, true);
+    const bounded = truncateUtf8(sanitized, policy.maxArtifactBytes);
+    if (bounded !== sanitized)
+        increment(counts, "truncated");
+    return Buffer.from(bounded);
+}
+function sourceDiagnostics(value) {
+    if (!isRecord(value) || value.diagnostics === undefined)
+        return [];
+    if (!Array.isArray(value.diagnostics))
+        throw new Error("Verifier diagnostics must be an array.");
+    return value.diagnostics.map((entry) => {
+        if (!isRecord(entry) || !["stdout", "stderr"].includes(String(entry.stream))
+            || typeof entry.locator !== "string" || typeof entry.digest !== "string"
+            || !Number.isSafeInteger(entry.sizeBytes) || typeof entry.truncated !== "boolean") {
+            throw new Error("Verifier diagnostic reference is invalid.");
+        }
+        return {
+            stream: entry.stream,
+            locator: entry.locator,
+            digest: entry.digest,
+            sizeBytes: entry.sizeBytes,
+            truncated: entry.truncated,
+        };
+    });
+}
+function rewriteVerifierDiagnosticReferences(value, diagnostics) {
+    if (diagnostics.size === 0 || !isRecord(value) || !Array.isArray(value.diagnostics))
+        return value;
+    const output = structuredClone(value);
+    for (const diagnostic of output.diagnostics) {
+        if (!isRecord(diagnostic) || typeof diagnostic.locator !== "string") {
+            throw new Error("Verifier diagnostic reference is invalid.");
+        }
+        const portable = diagnostics.get(diagnostic.locator);
+        if (portable === undefined)
+            throw new Error(`Verifier diagnostic ${diagnostic.locator} was not exported.`);
+        diagnostic.locator = portable.artifact.relativePath;
+        diagnostic.digest = portable.artifact.digest;
+        diagnostic.sizeBytes = portable.artifact.sizeBytes;
+        diagnostic.truncated = portable.truncated;
+        delete diagnostic.source;
+    }
+    return output;
+}
+function sanitizeValue(value, policy, replacements, sensitiveValues, localIdentifiers, counts, fieldName, truncatable = false) {
+    const normalizedField = fieldName === undefined ? undefined : normalizeFieldName(fieldName);
+    if (typeof value === "string") {
+        // Correlation values are also rewritten as substrings: native evidence
+        // embeds session and workspace identities inside encoded path strings that
+        // survive absolute-path redaction.
+        return rewriteString(value, policy, replacements, sensitiveValues, localIdentifiers, counts, normalizedField !== undefined && CORRELATION_FIELDS.has(normalizedField), truncatable, true, normalizedField !== undefined && LOCAL_IDENTIFIER_FIELDS.has(normalizedField));
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => sanitizeValue(entry, policy, replacements, sensitiveValues, localIdentifiers, counts, fieldName, truncatable));
+    }
+    if (!isRecord(value))
+        return value;
+    const sourceFieldCount = Object.keys(value).length;
+    const output = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (HIDDEN_FIELDS.has(normalizeFieldName(key))) {
+            increment(counts, "removed-field");
+            continue;
+        }
+        if (SECRET_FIELDS.has(normalizeFieldName(key))) {
+            output[key] = "[REDACTED_SECRET]";
+            increment(counts, "redacted-secret");
+            continue;
+        }
+        output[key] = sanitizeValue(entry, policy, replacements, sensitiveValues, localIdentifiers, counts, key, truncatable || TRUNCATABLE_FIELDS.has(normalizeFieldName(key)));
+    }
+    if (sourceFieldCount > 0 && Object.keys(output).length === 0) {
+        throw new Error("Sanitization removed every field from an evidence record.");
+    }
+    return output;
+}
+function stripCodexReasoning(value, kind, counts) {
+    if (kind !== "session")
+        return value;
+    if (Array.isArray(value))
+        return value.map((entry) => stripCodexReasoning(entry, kind, counts));
+    if (!isRecord(value))
+        return value;
+    const reasoningItem = value.type === "reasoning";
+    const reasoningDelta = value.method === CODEX_REASONING_DELTA_METHOD;
+    const cursorReasoning = typeof value.type === "string" && CURSOR_REASONING_TYPES.has(normalizeFieldName(value.type));
+    const cursorCheckpoint = typeof value.agentId === "string" && typeof value.blobId === "string" && typeof value.dataBase64 === "string";
+    const payloadContainsReasoning = containsCodexReasoning(value.payload);
+    const output = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const normalized = normalizeFieldName(key);
+        if (reasoningItem && key !== "type" && key !== "id") {
+            increment(counts, "removed-field");
+            continue;
+        }
+        if (cursorReasoning && (CODEX_REASONING_CONTENT_FIELDS.has(normalized) || normalized === "thinkingdurationms" || normalized === "message")) {
+            increment(counts, "removed-field");
+            continue;
+        }
+        if (cursorCheckpoint && normalized === "database64") {
+            increment(counts, "removed-field");
+            continue;
+        }
+        if (key === "raw" && (reasoningDelta || payloadContainsReasoning || rawContainsCodexReasoning(entry))) {
+            increment(counts, "removed-field");
+            continue;
+        }
+        if (reasoningDelta && CODEX_REASONING_CONTENT_FIELDS.has(normalized)) {
+            increment(counts, "removed-field");
+            continue;
+        }
+        if (reasoningDelta && (key === "params" || key === "payload")) {
+            output[key] = stripCodexReasoningEnvelope(entry, kind, counts);
+            continue;
+        }
+        output[key] = stripCodexReasoning(entry, kind, counts);
+    }
+    return output;
+}
+function stripNativeReasoning(value, kind, counts) {
+    return stripPiReasoning(stripCodexReasoning(value, kind, counts), kind, counts);
+}
+function stripPiReasoning(value, kind, counts) {
+    if (kind !== "session")
+        return value;
+    if (Array.isArray(value))
+        return value.map((entry) => stripPiReasoning(entry, kind, counts));
+    if (!isRecord(value))
+        return value;
+    const privateContent = value.thought === true
+        || typeof value.type === "string" && PI_PRIVATE_CONTENT_TYPES.has(normalizeFieldName(value.type));
+    const output = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const normalized = normalizeFieldName(key);
+        if (PI_PRIVATE_FIELDS.has(normalized) || privateContent && PI_PRIVATE_CONTENT_FIELDS.has(normalized)) {
+            increment(counts, "removed-field");
+            continue;
+        }
+        output[key] = stripPiReasoning(entry, kind, counts);
+    }
+    return output;
+}
+function stripCodexReasoningEnvelope(value, kind, counts) {
+    if (Array.isArray(value))
+        return value.map((entry) => stripCodexReasoningEnvelope(entry, kind, counts));
+    if (!isRecord(value))
+        return value;
+    const output = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (CODEX_REASONING_CONTENT_FIELDS.has(normalizeFieldName(key))) {
+            increment(counts, "removed-field");
+            continue;
+        }
+        output[key] = stripCodexReasoning(entry, kind, counts);
+    }
+    return output;
+}
+function containsCodexReasoning(value) {
+    if (Array.isArray(value))
+        return value.some(containsCodexReasoning);
+    if (!isRecord(value))
+        return false;
+    return value.type === "reasoning" || value.method === CODEX_REASONING_DELTA_METHOD
+        || Object.values(value).some(containsCodexReasoning);
+}
+function rawContainsCodexReasoning(value) {
+    if (typeof value !== "string")
+        return false;
+    try {
+        return containsCodexReasoning(JSON.parse(value));
+    }
+    catch {
+        return false;
+    }
+}
+function rewriteString(input, policy, replacements, sensitiveValues, localIdentifiers, counts, rewriteCorrelation, truncateContent, rewriteTextCorrelations = false, rewriteLocalIdentifier = false) {
+    let output = input;
+    // Declared sensitive values are redacted before correlation rewriting: a
+    // secret that embeds a run, attempt, bundle, session, or trace ID must not
+    // be mutated into a form the exact-secret match and final scan cannot see.
+    for (const secret of sensitiveValues) {
+        const occurrences = countOccurrences(output, secret);
+        if (occurrences > 0) {
+            output = output.replaceAll(secret, "[REDACTED_SECRET]");
+            increment(counts, "redacted-secret", occurrences);
+        }
+    }
+    const correlation = rewriteCorrelation ? replacements.get(output) : undefined;
+    if (correlation !== undefined) {
+        output = correlation;
+        increment(counts, "rewritten-correlation");
+    }
+    if (rewriteTextCorrelations) {
+        for (const [source, replacement] of replacements) {
+            if (source.length < 8)
+                continue;
+            const occurrences = countOccurrences(output, source);
+            if (occurrences > 0) {
+                output = output.replaceAll(source, replacement);
+                increment(counts, "rewritten-correlation", occurrences);
+            }
+        }
+    }
+    for (const pattern of SECRET_PATTERNS) {
+        output = output.replace(pattern, (_match, prefix, suffix) => {
+            increment(counts, "redacted-secret");
+            return `${typeof prefix === "string" ? prefix : ""}[REDACTED_SECRET]${typeof suffix === "string" ? suffix : ""}`;
+        });
+    }
+    output = output.replace(LOCAL_PATH, (_match, prefix) => {
+        increment(counts, "redacted-local-identifier");
+        return `${typeof prefix === "string" ? prefix : ""}[LOCAL_PATH]`;
+    });
+    for (const pattern of LOCAL_IDENTIFIER_PATTERNS) {
+        output = output.replace(pattern, (_match, prefix, suffix) => {
+            increment(counts, "redacted-local-identifier");
+            return `${typeof prefix === "string" ? prefix : ""}[LOCAL_USER]${typeof suffix === "string" ? suffix : ""}`;
+        });
+    }
+    if (rewriteLocalIdentifier) {
+        for (const identifier of localIdentifiers.filter((value) => value !== homedir())) {
+            if (output === identifier) {
+                output = "[LOCAL_USER]";
+                increment(counts, "redacted-local-identifier");
+            }
+        }
+    }
+    if (!truncateContent)
+        return output;
+    const bounded = truncateUtf8(output, policy.maxStringBytes);
+    if (bounded !== output)
+        increment(counts, "truncated");
+    return bounded;
+}
+function scanPortableTree(buffers, sensitiveValues, sourceCorrelations) {
+    for (const [index, { bytes, mediaType }] of buffers.entries()) {
+        const text = decode(bytes, "portable export");
+        const failure = [
+            ["known sensitive value", sensitiveValues.some((value) => text.includes(value))],
+            ["secret pattern", containsPortableSecretPattern(text, mediaType)],
+            ["absolute path", containsLocalPath(text, mediaType)],
+            ["local identifier", LOCAL_IDENTIFIER_PATTERNS.some((pattern) => pattern.test(text))],
+            ["source correlation", sourceCorrelations.filter((value) => value.length >= 8).some((value) => text.includes(value))],
+            ["hidden content field", /"(?:chain[_-]?of[_-]?thought|extended[_-]?thinking|hidden[_-]?reasoning|encrypted[_-]?(?:reasoning|thinking)|reasoning(?:[_-]?(?:content|details|signature))?|thinking(?:[_-]?(?:content|signature))?|text[_-]?signature|thought[_-]?signature|raw[_-]?(?:api|request|response)[_-]?body)"\s*:/iu.test(text)],
+            ["Codex reasoning content", containsCodexReasoningContent(text, mediaType)],
+            ["Pi private reasoning content", containsPiReasoningContent(text, mediaType)],
+        ].find(([, matched]) => matched);
+        if (failure !== undefined) {
+            resetPatterns();
+            throw new Error(`Portable export buffer ${index} failed the final secret scan: ${String(failure[0])}.`);
+        }
+        resetPatterns();
+    }
+}
+function containsPiReasoningContent(text, mediaType) {
+    if (mediaType === "application/json")
+        return valueContainsPiReasoningContent(parseJson(Buffer.from(text), "Portable JSON Pi reasoning scan"));
+    if (mediaType === "application/x-ndjson")
+        return text.split(/\r?\n/gu).filter(Boolean).some((line) => valueContainsPiReasoningContent(parseJson(Buffer.from(line), "Portable JSONL Pi reasoning scan")));
+    return false;
+}
+function valueContainsPiReasoningContent(value) {
+    if (Array.isArray(value))
+        return value.some(valueContainsPiReasoningContent);
+    if (!isRecord(value))
+        return false;
+    if (Object.keys(value).some((key) => PI_PRIVATE_FIELDS.has(normalizeFieldName(key))))
+        return true;
+    if ((value.thought === true || typeof value.type === "string" && PI_PRIVATE_CONTENT_TYPES.has(normalizeFieldName(value.type)))
+        && Object.keys(value).some((key) => PI_PRIVATE_CONTENT_FIELDS.has(normalizeFieldName(key))))
+        return true;
+    return Object.values(value).some(valueContainsPiReasoningContent);
+}
+function containsCodexReasoningContent(text, mediaType) {
+    if (mediaType === "application/json") {
+        return valueContainsCodexReasoningContent(parseJson(Buffer.from(text), "Portable JSON reasoning scan"));
+    }
+    if (mediaType === "application/x-ndjson") {
+        return text.split(/\r?\n/gu).filter(Boolean).some((line) => valueContainsCodexReasoningContent(parseJson(Buffer.from(line), "Portable JSONL reasoning scan")));
+    }
+    return false;
+}
+function valueContainsCodexReasoningContent(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trimStart();
+        if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
+            return false;
+        try {
+            return valueContainsCodexReasoningContent(JSON.parse(trimmed));
+        }
+        catch {
+            return false;
+        }
+    }
+    if (Array.isArray(value))
+        return value.some(valueContainsCodexReasoningContent);
+    if (!isRecord(value))
+        return false;
+    if (value.type === "reasoning"
+        && Object.keys(value).some((key) => CODEX_REASONING_CONTENT_FIELDS.has(normalizeFieldName(key))))
+        return true;
+    if (value.method === CODEX_REASONING_DELTA_METHOD) {
+        for (const container of [value.params, value.payload]) {
+            if (isRecord(container)
+                && Object.keys(container).some((key) => CODEX_REASONING_CONTENT_FIELDS.has(normalizeFieldName(key))))
+                return true;
+        }
+    }
+    return Object.values(value).some(valueContainsCodexReasoningContent);
+}
+/** Use the export pipeline's fail-closed credential patterns on release material. */
+export function containsPortableSecretPattern(text, mediaType) {
+    if (mediaType === "application/json") {
+        return valueContainsSecretPattern(parseJson(Buffer.from(text), "Portable JSON final scan"));
+    }
+    if (mediaType === "application/x-ndjson") {
+        return text.split(/\r?\n/gu).filter(Boolean).some((line) => valueContainsSecretPattern(parseJson(Buffer.from(line), "Portable JSONL final scan")));
+    }
+    return stringContainsSecretPattern(text);
+}
+/** Detect user-identifying home paths without rejecting documented generic paths. */
+export function containsPortableLocalHomePath(text, mediaType = "text/plain") {
+    if (mediaType === "application/json") {
+        return valueContainsLocalHomePath(parseJson(Buffer.from(text), "Portable JSON local-home scan"));
+    }
+    if (mediaType === "application/x-ndjson") {
+        return text.split(/\r?\n/gu).filter(Boolean).some((line) => valueContainsLocalHomePath(parseJson(Buffer.from(line), "Portable JSONL local-home scan")));
+    }
+    return stringContainsLocalHomePath(text);
+}
+function valueContainsLocalHomePath(value) {
+    if (typeof value === "string")
+        return stringContainsLocalHomePath(value);
+    if (Array.isArray(value))
+        return value.some(valueContainsLocalHomePath);
+    if (!isRecord(value))
+        return false;
+    return Object.entries(value).some(([key, entry]) => stringContainsLocalHomePath(key) || valueContainsLocalHomePath(entry));
+}
+function stringContainsLocalHomePath(text) {
+    const matched = LOCAL_HOME_PATH.test(text);
+    LOCAL_HOME_PATH.lastIndex = 0;
+    return matched;
+}
+function valueContainsSecretPattern(value) {
+    if (typeof value === "string")
+        return stringContainsSecretPattern(value);
+    if (Array.isArray(value))
+        return value.some(valueContainsSecretPattern);
+    if (!isRecord(value))
+        return false;
+    return Object.entries(value).some(([key, entry]) => SECRET_FIELDS.has(normalizeFieldName(key)) && entry !== "[REDACTED_SECRET]"
+        || stringContainsSecretPattern(key)
+        || valueContainsSecretPattern(entry));
+}
+function stringContainsSecretPattern(value) {
+    const matched = SECRET_PATTERNS.some((pattern) => pattern.test(value));
+    resetPatterns();
+    return matched;
+}
+function containsLocalPath(text, mediaType) {
+    if (mediaType === "application/json") {
+        return valueContainsLocalPath(parseJson(Buffer.from(text), "Portable JSON final scan"));
+    }
+    if (mediaType === "application/x-ndjson") {
+        return text.split(/\r?\n/gu).filter(Boolean).some((line) => valueContainsLocalPath(parseJson(Buffer.from(line), "Portable JSONL final scan")));
+    }
+    return stringContainsLocalPath(text);
+}
+function valueContainsLocalPath(value) {
+    if (typeof value === "string")
+        return stringContainsLocalPath(value);
+    if (Array.isArray(value))
+        return value.some(valueContainsLocalPath);
+    if (!isRecord(value))
+        return false;
+    return Object.entries(value).some(([key, entry]) => stringContainsLocalPath(key) || valueContainsLocalPath(entry));
+}
+function stringContainsLocalPath(value) {
+    const matched = LOCAL_PATH.test(value);
+    LOCAL_PATH.lastIndex = 0;
+    return matched;
+}
+async function validateSourceReferences(manifest, source, sourceRoot) {
+    if ((manifest.assessmentMode ?? "verified") !== (source.run.assessmentMode ?? "verified")) {
+        throw new Error("Portable export assessment mode does not match its source run.");
+    }
+    const sourceById = new Map(source.evidence.map((descriptor) => [descriptor.id, descriptor]));
+    if (manifest.sourceManifestDigest === undefined)
+        throw new Error("Portable export omits its source-manifest digest.");
+    for (const artifact of manifest.artifacts) {
+        if (artifact.kind === "diagnostic") {
+            const verifier = artifact.diagnosticSource === undefined
+                ? undefined
+                : sourceById.get(artifact.diagnosticSource.verifierId);
+            if (artifact.diagnosticSource === undefined || verifier?.kind !== "verifier") {
+                throw new Error(`Portable diagnostic ${artifact.id} does not reference a source verifier.`);
+            }
+            if (sourceRoot === undefined) {
+                throw new Error("Source root is required to validate portable diagnostic provenance.");
+            }
+            const verifierBytes = await readVerifiedArtifact(sourceRoot, verifier.relativePath, digestValue(verifier.digest), MAX_SOURCE_ARTIFACT_BYTES);
+            const sourceDiagnostic = sourceDiagnostics(parseJson(verifierBytes, "Source verifier evidence")).find((diagnostic) => diagnostic.stream === artifact.diagnosticSource?.stream
+                && digestText(diagnostic.locator) === artifact.diagnosticSource.locatorDigest);
+            if (sourceDiagnostic === undefined || sourceDiagnostic.digest !== artifact.sourceDigest
+                || sourceDiagnostic.sizeBytes !== artifact.diagnosticSource.sizeBytes) {
+                throw new Error(`Portable diagnostic ${artifact.id} does not match its source diagnostic reference.`);
+            }
+            continue;
+        }
+        const descriptor = sourceById.get(artifact.sourceArtifactId);
+        if (descriptor === undefined || descriptor.digest !== artifact.sourceDigest
+            || descriptor.kind !== artifact.kind || descriptor.mediaType !== artifact.mediaType) {
+            throw new Error(`Portable artifact ${artifact.id} does not match its source reference.`);
+        }
+    }
+    for (const excluded of manifest.excludedArtifacts) {
+        const source = sourceById.get(excluded.artifactId);
+        const valid = excluded.reason === "source-export-manifest"
+            ? source?.kind === "export-manifest"
+            : source?.kind === "workspace" && source.mediaType === "application/gzip";
+        if (!valid) {
+            throw new Error(`Portable exclusion ${excluded.artifactId} does not match its declared reason.`);
+        }
+    }
+    const represented = new Set([
+        ...manifest.artifacts.map(({ sourceArtifactId }) => sourceArtifactId),
+        ...manifest.excludedArtifacts.map(({ artifactId }) => artifactId),
+    ]);
+    if (source.evidence.some(({ id }) => !represented.has(id))) {
+        throw new Error("Portable export does not account for every source artifact.");
+    }
+}
+function validatePortableDiagnosticReferences(manifest, artifactBytes) {
+    const artifactsByPath = new Map(manifest.artifacts.map((artifact) => [artifact.relativePath, artifact]));
+    const artifactsById = new Map(manifest.artifacts.map((artifact) => [artifact.id, artifact]));
+    const referencedDiagnostics = new Set();
+    for (const [index, verifier] of manifest.artifacts.entries()) {
+        if (verifier.kind !== "verifier")
+            continue;
+        const document = parseJson(artifactBytes[index], `Portable verifier ${verifier.id}`);
+        if (!isRecord(document) || document.diagnostics === undefined)
+            continue;
+        if (!Array.isArray(document.diagnostics))
+            throw new Error(`Portable verifier ${verifier.id} diagnostics are invalid.`);
+        for (const diagnostic of document.diagnostics) {
+            if (!isRecord(diagnostic) || typeof diagnostic.locator !== "string") {
+                throw new Error(`Portable verifier ${verifier.id} diagnostic reference is invalid.`);
+            }
+            const sidecar = artifactsByPath.get(diagnostic.locator);
+            if (sidecar?.kind !== "diagnostic" || sidecar.digest !== diagnostic.digest
+                || sidecar.sizeBytes !== diagnostic.sizeBytes
+                || sidecar.diagnosticSource?.verifierId !== verifier.id
+                || sidecar.diagnosticSource?.stream !== diagnostic.stream) {
+                throw new Error(`Portable verifier ${verifier.id} diagnostic reference is not bound to its sidecar.`);
+            }
+            referencedDiagnostics.add(sidecar.id);
+        }
+    }
+    for (const diagnostic of manifest.artifacts.filter(({ kind }) => kind === "diagnostic")) {
+        if (diagnostic.diagnosticSource === undefined
+            || artifactsById.get(diagnostic.diagnosticSource.verifierId)?.kind !== "verifier"
+            || !referencedDiagnostics.has(diagnostic.id)) {
+            throw new Error(`Portable diagnostic ${diagnostic.id} is not referenced by its verifier.`);
+        }
+    }
+}
+function parseSanitizedArtifact(bytes, mediaType) {
+    if (mediaType === "application/json") {
+        parseJson(bytes, "Portable JSON evidence");
+    }
+    else if (mediaType === "application/x-ndjson") {
+        const lines = decode(bytes, "Portable JSONL evidence").split(/\r?\n/gu).filter((line) => line.trim() !== "");
+        if (lines.length === 0)
+            throw new Error("Portable JSONL evidence is empty.");
+        for (const line of lines)
+            parseJson(Buffer.from(line), "Portable JSONL evidence record");
+    }
+    else {
+        decode(bytes, "Portable text evidence");
+    }
+}
+function parseJson(bytes, label) {
+    const text = decode(bytes, label);
+    assertNoDuplicateJsonKeys(text);
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`${label} is invalid JSON: ${errorMessage(error)}`);
+    }
+}
+function assertSupportedPair(kind, mediaType) {
+    const allowed = {
+        session: ["application/x-ndjson"],
+        hook: ["application/x-ndjson"],
+        telemetry: ["application/json"],
+        workspace: ["text/x-diff"],
+        verifier: ["application/json"],
+        diagnostic: ["text/plain"],
+        "capture-report": ["application/json"],
+    };
+    if (kind === "export-manifest")
+        return;
+    if (!allowed[kind]?.includes(mediaType))
+        throw new Error(`Artifact kind ${kind} has unsupported media type ${mediaType}.`);
+}
+function correlationProjection(manifest, salt) {
+    return {
+        bundleId: rewrittenId("bundle", manifest.bundleId, salt),
+        runId: rewrittenId("run", manifest.run.id, salt),
+        attemptId: rewrittenId("attempt", manifest.attempt.id, salt),
+        ...(manifest.run.native?.sessionId === undefined ? {} : { sessionId: rewrittenId("session", manifest.run.native.sessionId, salt) }),
+        ...(manifest.run.native?.traceId === undefined ? {} : { traceId: rewrittenId("trace", manifest.run.native.traceId, salt) }),
+    };
+}
+function correlationReplacements(manifest, projected) {
+    const replacements = [
+        [manifest.bundleId, projected.bundleId],
+        [manifest.run.id, projected.runId],
+        [manifest.attempt.id, projected.attemptId],
+    ];
+    if (manifest.run.native?.sessionId !== undefined && projected.sessionId !== undefined) {
+        replacements.push([manifest.run.native.sessionId, projected.sessionId]);
+    }
+    if (manifest.run.native?.traceId !== undefined && projected.traceId !== undefined) {
+        replacements.push([manifest.run.native.traceId, projected.traceId]);
+    }
+    return new Map(replacements);
+}
+function sourceCorrelationValues(manifest) {
+    return [
+        manifest.bundleId,
+        manifest.run.id,
+        manifest.attempt.id,
+        ...(manifest.run.native?.sessionId === undefined ? [] : [manifest.run.native.sessionId]),
+        ...(manifest.run.native?.traceId === undefined ? [] : [manifest.run.native.traceId]),
+    ];
+}
+function rewrittenId(kind, value, salt) {
+    return `${kind}-${createHash("sha256").update(`${salt}\0${value}`).digest("hex").slice(0, 24)}`;
+}
+function digestText(value) {
+    return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function policyRecord(policy) {
+    return {
+        sharingClass: policy.sharingClass,
+        maxArtifactBytes: policy.maxArtifactBytes,
+        maxStringBytes: policy.maxStringBytes,
+        sensitiveValueDigests: [...new Set(policy.sensitiveValues ?? [])]
+            .sort()
+            .map((value) => createHash("sha256").update(value).digest("hex")),
+    };
+}
+function effectiveSensitiveValues(policy) {
+    const environment = Object.entries(process.env)
+        .filter(([key, value]) => value !== undefined && value.length >= 8
+        && !["logname", "user", "username"].includes(normalizeFieldName(key)))
+        .map(([, value]) => value);
+    return [...new Set([...(policy.sensitiveValues ?? []).filter((value) => value !== ""), ...environment])]
+        .sort((left, right) => right.length - left.length);
+}
+function validatePolicy(policy) {
+    if (!["partner", "public"].includes(policy.sharingClass))
+        throw new Error("Portable export sharing class is invalid.");
+    for (const [name, value] of [["artifact", policy.maxArtifactBytes], ["string", policy.maxStringBytes]]) {
+        if (!Number.isSafeInteger(value) || value < 1)
+            throw new Error(`Portable export ${name} limit must be a positive safe integer.`);
+    }
+    if (policy.maxStringBytes > policy.maxArtifactBytes)
+        throw new Error("Portable export string limit cannot exceed the artifact limit.");
+}
+function extensionFor(mediaType) {
+    return mediaType === "application/json" ? ".json"
+        : mediaType === "application/x-ndjson" ? ".jsonl"
+            : mediaType === "text/x-diff" ? ".patch" : ".txt";
+}
+function truncateUtf8(value, maxBytes) {
+    if (Buffer.byteLength(value) <= maxBytes)
+        return value;
+    let low = 0;
+    let high = value.length;
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (Buffer.byteLength(value.slice(0, middle)) <= maxBytes)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return value.slice(0, low);
+}
+function countOccurrences(value, search) {
+    if (search === "")
+        return 0;
+    let count = 0;
+    for (let index = value.indexOf(search); index !== -1; index = value.indexOf(search, index + search.length))
+        count += 1;
+    return count;
+}
+function increment(counts, action, count = 1) {
+    counts.set(action, (counts.get(action) ?? 0) + count);
+}
+function digestValue(value) {
+    return { algorithm: "sha256", value: value.slice("sha256:".length) };
+}
+function digestString(value) {
+    return `sha256:${value.value}`;
+}
+function decode(bytes, label) {
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        throw new Error(`${label} is not valid UTF-8.`);
+    }
+}
+function formatValidationErrors(errors) {
+    return errors.map((error) => `${error.artifact} ${error.field}: ${error.message}`).join("\n");
+}
+function normalizeFieldName(value) {
+    return value.replaceAll(/[^a-z0-9]/giu, "").toLowerCase();
+}
+function resetPatterns() {
+    LOCAL_PATH.lastIndex = 0;
+    for (const pattern of SECRET_PATTERNS)
+        pattern.lastIndex = 0;
+    for (const pattern of LOCAL_IDENTIFIER_PATTERNS)
+        pattern.lastIndex = 0;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}