hadara 0.3.2 → 0.3.3-rc.0

package/dist/context/source-manifest.js

@@ -0,0 +1,566 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTEXT_SOURCE_MANIFEST_IGNORED_PATHS = exports.CONTEXT_SOURCE_MANIFEST_DEFAULT_BUDGETS = exports.CONTEXT_SOURCE_MANIFEST_CACHE_VERSION = exports.CONTEXT_SOURCE_MANIFEST_CACHE_PATH = exports.CONTEXT_SOURCE_MANIFEST_CACHE_ROOT = exports.CONTEXT_SOURCE_MANIFEST_SCHEMA_ID = void 0;
+exports.buildContextSourceManifest = buildContextSourceManifest;
+exports.checkContextSourceManifestFastFreshness = checkContextSourceManifestFastFreshness;
+exports.compareContextSourceManifests = compareContextSourceManifests;
+exports.createContextSourceSubsetHash = createContextSourceSubsetHash;
+exports.classifyContextSourcePath = classifyContextSourcePath;
+exports.extractorKeysForContextSource = extractorKeysForContextSource;
+exports.shouldIgnoreContextSourcePath = shouldIgnoreContextSourcePath;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const code_index_1 = require("./code-index");
+const extractor_contract_1 = require("./extractor-contract");
+exports.CONTEXT_SOURCE_MANIFEST_SCHEMA_ID = 'hadara.context.sourceManifest.v1';
+exports.CONTEXT_SOURCE_MANIFEST_CACHE_ROOT = '.hadara/local/cache/context';
+exports.CONTEXT_SOURCE_MANIFEST_CACHE_PATH = `${exports.CONTEXT_SOURCE_MANIFEST_CACHE_ROOT}/source-manifest.json`;
+exports.CONTEXT_SOURCE_MANIFEST_CACHE_VERSION = 'c6.1-source-manifest-v1';
+exports.CONTEXT_SOURCE_MANIFEST_DEFAULT_BUDGETS = {
+    maxSourceFiles: 5000,
+    maxSourceBytes: 40 * 1024 * 1024,
+    maxSingleSourceBytes: 2 * 1024 * 1024
+};
+exports.CONTEXT_SOURCE_MANIFEST_IGNORED_PATHS = Array.from(new Set([
+    ...code_index_1.CODE_INDEX_IGNORED_PATHS,
+    '.hadara/local',
+    '.hadara/tmp',
+    '.hadara/run',
+    '.dashboard-visual'
+])).sort();
+const DEFAULT_EXTRACTOR_VERSIONS = {
+    codeIndex: code_index_1.CODE_INDEX_EXTRACTOR_VERSION,
+    extractAgentHandoff: 'c1-agent-handoff-v1',
+    extractCommandRegistry: 'c1-command-registry-v1',
+    extractDecisions: 'c1-decisions-v1',
+    extractDocsRegistry: 'c1-docs-registry-v1',
+    extractEvidence: 'c1-evidence-v1',
+    extractManagedSections: 'c1-managed-sections-v1',
+    extractProjectState: 'c1-project-state-v1',
+    extractReleaseReadiness: 'c1-release-readiness-v1',
+    extractTaskBoard: 'c1-task-board-v1',
+    extractTaskCapsules: 'c1-task-capsules-v1'
+};
+function buildContextSourceManifest(options) {
+    const generatedAt = options.generatedAt ?? new Date().toISOString();
+    const budgets = normalizeContextSourceManifestBudgets(options.budgets);
+    const extractorVersions = { ...DEFAULT_EXTRACTOR_VERSIONS, ...(options.extractorVersions ?? {}) };
+    const ignoreConfigHash = (0, extractor_contract_1.hashContextGraphJson)(exports.CONTEXT_SOURCE_MANIFEST_IGNORED_PATHS);
+    const previousByPath = new Map((options.previousManifest?.sources ?? []).map((entry) => [entry.path, entry]));
+    const sources = [];
+    const issues = [];
+    let discoveredBytes = 0;
+    let skippedSourceCount = 0;
+    let fileBudgetIssueRecorded = false;
+    const root = node_path_1.default.resolve(options.projectRoot);
+    function addSource(relativePath, input = {}) {
+        if (shouldIgnoreContextSourcePath(relativePath))
+            return;
+        const kind = classifyContextSourcePath(relativePath);
+        if (!kind)
+            return;
+        if (sources.length >= budgets.maxSourceFiles) {
+            skippedSourceCount += 1;
+            if (!fileBudgetIssueRecorded) {
+                fileBudgetIssueRecorded = true;
+                issues.push(createPartialIssue({
+                    message: `Context source manifest exceeded max source file budget (${budgets.maxSourceFiles}); partial manifest returned.`,
+                    path: relativePath,
+                    fixHint: 'Reduce context source count or increase the future configurable source manifest budget.'
+                }));
+            }
+            return;
+        }
+        const absolutePath = node_path_1.default.join(root, relativePath);
+        let stats;
+        try {
+            stats = node_fs_1.default.statSync(absolutePath);
+        }
+        catch (error) {
+            if (input.skipMissing && isMissingFileError(error))
+                return;
+            skippedSourceCount += 1;
+            issues.push({
+                severity: 'warning',
+                code: 'SOURCE_MANIFEST_READ_FAILED',
+                message: `Failed to stat context source ${relativePath}: ${error instanceof Error ? error.message : String(error)}.`,
+                path: relativePath,
+                fixHint: 'Check file permissions or remove the unreadable file from context source paths.'
+            });
+            return;
+        }
+        if (!stats.isFile())
+            return;
+        if (stats.size > budgets.maxSingleSourceBytes) {
+            skippedSourceCount += 1;
+            issues.push(createPartialIssue({
+                message: `Skipped ${relativePath} because it exceeds the single-source manifest budget (${stats.size} bytes > ${budgets.maxSingleSourceBytes} bytes).`,
+                path: relativePath,
+                fixHint: 'Reduce the file size or wait for a future configurable source manifest budget.'
+            }));
+            return;
+        }
+        if (discoveredBytes + stats.size > budgets.maxSourceBytes) {
+            skippedSourceCount += 1;
+            issues.push(createPartialIssue({
+                message: `Skipped ${relativePath} because the source manifest byte budget would be exceeded (${discoveredBytes + stats.size} bytes > ${budgets.maxSourceBytes} bytes).`,
+                path: relativePath,
+                fixHint: 'Reduce context source size or wait for a future configurable source manifest budget.'
+            }));
+            return;
+        }
+        discoveredBytes += stats.size;
+        const extractorKeys = extractorKeysForContextSource(relativePath, kind);
+        const metadataHash = createContextSourceMetadataHash({
+            path: relativePath,
+            kind,
+            sizeBytes: stats.size,
+            mtimeMs: stats.mtimeMs,
+            ignoreConfigHash,
+            extractorKeys,
+            extractorVersions
+        });
+        const previous = previousByPath.get(relativePath);
+        const contentHash = previous && canCarryForwardContentHash(previous, {
+            kind,
+            sizeBytes: stats.size,
+            mtimeMs: stats.mtimeMs
+        }) ? previous.contentHash : undefined;
+        sources.push({
+            path: relativePath,
+            kind,
+            sizeBytes: stats.size,
+            mtimeMs: stats.mtimeMs,
+            metadataHash,
+            extractorKeys,
+            ...(contentHash ? { contentHash } : {}),
+            parseState: 'ok'
+        });
+    }
+    function visit(relativeDir) {
+        if (relativeDir && shouldIgnoreContextSourcePath(relativeDir))
+            return;
+        const absoluteDir = node_path_1.default.join(root, relativeDir);
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(absoluteDir, { withFileTypes: true });
+        }
+        catch (error) {
+            issues.push({
+                severity: 'warning',
+                code: 'SOURCE_MANIFEST_READ_FAILED',
+                message: `Failed to read context source directory ${(0, extractor_contract_1.normalizeContextGraphPath)(relativeDir || '.')}: ${error instanceof Error ? error.message : String(error)}.`,
+                path: (0, extractor_contract_1.normalizeContextGraphPath)(relativeDir || '.'),
+                fixHint: 'Check directory permissions or exclude the unreadable directory from context source discovery.'
+            });
+            return;
+        }
+        for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+            const relativePath = (0, extractor_contract_1.normalizeContextGraphPath)(node_path_1.default.join(relativeDir, entry.name));
+            if (shouldIgnoreContextSourcePath(relativePath))
+                continue;
+            if (entry.isDirectory()) {
+                visit(relativePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            addSource(relativePath);
+        }
+    }
+    const gitCandidatePaths = listGitContextSourceCandidatePaths(root);
+    if (gitCandidatePaths) {
+        for (const relativePath of gitCandidatePaths)
+            addSource(relativePath, { skipMissing: true });
+    }
+    else {
+        visit('');
+    }
+    const sortedSources = sources.sort((a, b) => a.path.localeCompare(b.path));
+    const projectFingerprint = (0, extractor_contract_1.hashContextGraphJson)({ rootName: node_path_1.default.basename(root) });
+    const fingerprint = createContextSourceManifestFingerprint({
+        projectRoot: root,
+        projectFingerprint,
+        cacheVersion: exports.CONTEXT_SOURCE_MANIFEST_CACHE_VERSION,
+        ignoreConfigHash,
+        extractorVersions
+    });
+    const manifestWithoutHash = {
+        schemaVersion: exports.CONTEXT_SOURCE_MANIFEST_SCHEMA_ID,
+        generatedAt,
+        projectFingerprint,
+        cacheVersion: exports.CONTEXT_SOURCE_MANIFEST_CACHE_VERSION,
+        ignoreConfigHash,
+        extractorVersions,
+        ...(fingerprint ? { fingerprint } : {}),
+        sources: sortedSources,
+        summary: {
+            sourceCount: sortedSources.length,
+            totalBytes: discoveredBytes,
+            hashedSourceCount: sortedSources.filter((source) => Boolean(source.contentHash)).length,
+            skippedSourceCount,
+            ...(options.generatedByCommand ? { generatedByCommand: options.generatedByCommand } : {})
+        },
+        budget: {
+            ...budgets,
+            discoveredSourceCount: sortedSources.length,
+            discoveredBytes,
+            skippedSourceCount
+        },
+        issues
+    };
+    return {
+        ...manifestWithoutHash,
+        manifestHash: createStableContextSourceManifestHash(manifestWithoutHash)
+    };
+}
+function checkContextSourceManifestFastFreshness(projectRoot, manifest) {
+    if (!manifest.fingerprint) {
+        return { ok: false, reason: 'missing-fingerprint' };
+    }
+    const currentFingerprint = createContextSourceManifestFingerprint({
+        projectRoot,
+        projectFingerprint: manifest.projectFingerprint,
+        cacheVersion: manifest.cacheVersion,
+        ignoreConfigHash: manifest.ignoreConfigHash,
+        extractorVersions: manifest.extractorVersions
+    });
+    if (!currentFingerprint) {
+        return { ok: false, reason: 'fingerprint-unavailable' };
+    }
+    if (sameContextSourceManifestFingerprint(manifest.fingerprint, currentFingerprint)) {
+        return {
+            ok: true,
+            strategy: currentFingerprint.strategy,
+            reason: 'fresh',
+            currentFingerprint
+        };
+    }
+    return {
+        ok: false,
+        strategy: currentFingerprint.strategy,
+        reason: 'fingerprint-mismatch',
+        currentFingerprint
+    };
+}
+function compareContextSourceManifests(previous, next) {
+    const previousByPath = new Map((previous?.sources ?? []).map((entry) => [entry.path, entry]));
+    const nextByPath = new Map(next.sources.map((entry) => [entry.path, entry]));
+    const addedPaths = [];
+    const removedPaths = [];
+    const changedPaths = [];
+    const unchangedPaths = [];
+    const staleExtractorKeys = new Set();
+    for (const nextEntry of next.sources) {
+        const previousEntry = previousByPath.get(nextEntry.path);
+        if (!previousEntry) {
+            addedPaths.push(nextEntry.path);
+            nextEntry.extractorKeys.forEach((key) => staleExtractorKeys.add(key));
+            continue;
+        }
+        if (previousEntry.metadataHash === nextEntry.metadataHash && previousEntry.contentHash === nextEntry.contentHash) {
+            unchangedPaths.push(nextEntry.path);
+        }
+        else {
+            changedPaths.push(nextEntry.path);
+            Array.from(new Set([...previousEntry.extractorKeys, ...nextEntry.extractorKeys])).forEach((key) => staleExtractorKeys.add(key));
+        }
+    }
+    for (const previousEntry of previousByPath.values()) {
+        if (nextByPath.has(previousEntry.path))
+            continue;
+        removedPaths.push(previousEntry.path);
+        previousEntry.extractorKeys.forEach((key) => staleExtractorKeys.add(key));
+    }
+    return {
+        addedPaths: addedPaths.sort(),
+        removedPaths: removedPaths.sort(),
+        changedPaths: changedPaths.sort(),
+        unchangedPaths: unchangedPaths.sort(),
+        staleExtractorKeys: Array.from(staleExtractorKeys).sort()
+    };
+}
+function createContextSourceSubsetHash(manifest, input = {}) {
+    const kindSet = input.kinds ? new Set(input.kinds) : undefined;
+    return (0, extractor_contract_1.hashContextGraphJson)(manifest.sources
+        .filter((source) => !input.extractorKey || source.extractorKeys.includes(input.extractorKey))
+        .filter((source) => !kindSet || kindSet.has(source.kind))
+        .map((source) => ({
+        path: source.path,
+        kind: source.kind,
+        metadataHash: source.metadataHash,
+        contentHash: source.contentHash ?? null
+    }))
+        .sort((a, b) => a.path.localeCompare(b.path)));
+}
+function classifyContextSourcePath(inputPath) {
+    const filePath = (0, extractor_contract_1.normalizeContextGraphPath)(inputPath);
+    if (filePath === 'docs/TASK_BOARD.md')
+        return 'task-board';
+    if (filePath === '.hadara/docs-registry.json' || filePath === 'docs/DOC_REGISTRY.md')
+        return 'docs-registry';
+    if (filePath === 'src/services/capability-registry.ts')
+        return 'command-registry';
+    if (filePath === 'docs/PROJECT_STATE.md')
+        return 'project-state-doc';
+    if (filePath === 'docs/AGENT_HANDOFF.md')
+        return 'handoff-doc';
+    if (filePath === 'docs/RELEASE_READINESS.md')
+        return 'release-doc';
+    if (filePath.startsWith('docs/specs/') && filePath.endsWith('.md'))
+        return 'spec-doc';
+    if (filePath.startsWith('tasks/') && filePath.endsWith('/evidence.jsonl'))
+        return 'evidence';
+    if (filePath.startsWith('tasks/') && filePath.endsWith('.md'))
+        return 'task-capsule';
+    const codeKind = (0, code_index_1.classifyCodeFile)(filePath);
+    if (codeKind === 'source' || codeKind === 'script')
+        return 'source-file';
+    if (codeKind === 'test')
+        return 'test-file';
+    if (codeKind === 'fixture')
+        return 'fixture-file';
+    if (codeKind === 'config')
+        return 'config-file';
+    if (filePath.startsWith('docs/') && filePath.endsWith('.md'))
+        return 'managed-section-source';
+    return undefined;
+}
+function extractorKeysForContextSource(relativePath, kind) {
+    switch (kind) {
+        case 'task-board':
+            return ['extractTaskBoard'];
+        case 'task-capsule':
+            return ['extractTaskCapsules'];
+        case 'evidence':
+            return ['extractEvidence'];
+        case 'docs-registry':
+            return ['extractDocsRegistry'];
+        case 'command-registry':
+            return ['extractCommandRegistry', 'codeIndex'];
+        case 'managed-section-source':
+            return ['extractManagedSections', 'extractDecisions'];
+        case 'release-doc':
+            return ['extractReleaseReadiness', 'extractManagedSections'];
+        case 'handoff-doc':
+            return ['extractAgentHandoff', 'extractManagedSections'];
+        case 'project-state-doc':
+            return ['extractProjectState', 'extractManagedSections'];
+        case 'spec-doc':
+            return ['extractDocsRegistry', 'extractManagedSections'];
+        case 'source-file':
+        case 'test-file':
+        case 'fixture-file':
+        case 'config-file':
+            return ['codeIndex'];
+        case 'other-doc':
+            return ['extractManagedSections'];
+        default:
+            return relativePath.startsWith('docs/') ? ['extractManagedSections'] : [];
+    }
+}
+function shouldIgnoreContextSourcePath(inputPath) {
+    const normalizedPath = (0, extractor_contract_1.normalizeContextGraphPath)(inputPath);
+    if (!normalizedPath || normalizedPath === '.')
+        return false;
+    return exports.CONTEXT_SOURCE_MANIFEST_IGNORED_PATHS.some((ignoredPath) => normalizedPath === ignoredPath || normalizedPath.startsWith(`${ignoredPath}/`));
+}
+function listGitContextSourceCandidatePaths(root) {
+    if (!node_fs_1.default.existsSync(node_path_1.default.join(root, '.git')))
+        return undefined;
+    try {
+        const output = (0, node_child_process_1.execFileSync)('git', ['-C', root, 'ls-files', '-z', '--cached', '--others', '--exclude-standard'], {
+            encoding: 'utf8',
+            maxBuffer: 50 * 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 5000
+        });
+        return Array.from(new Set(output
+            .split('\0')
+            .map((entry) => (0, extractor_contract_1.normalizeContextGraphPath)(entry))
+            .filter((entry) => entry && !shouldIgnoreContextSourcePath(entry))))
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return undefined;
+    }
+}
+function createContextSourceManifestFingerprint(input) {
+    if (!node_fs_1.default.existsSync(node_path_1.default.join(input.projectRoot, '.git')))
+        return undefined;
+    const gitHead = readGitOutput(input.projectRoot, ['rev-parse', 'HEAD']) ?? 'UNBORN';
+    const gitStatus = readGitOutput(input.projectRoot, ['status', '--porcelain=v1', '-z', '--untracked-files=all']);
+    if (gitStatus === undefined)
+        return undefined;
+    const relevantStatusEntries = contextRelevantGitStatusEntriesFromGitStatus(gitStatus);
+    if (!relevantStatusEntries)
+        return undefined;
+    const dirtyMetadataHash = createDirtyContextSourceMetadataHash(input.projectRoot, gitStatus);
+    if (!dirtyMetadataHash)
+        return undefined;
+    return {
+        strategy: 'git-worktree-v1',
+        projectFingerprint: input.projectFingerprint,
+        cacheVersion: input.cacheVersion,
+        ignoreConfigHash: input.ignoreConfigHash,
+        extractorVersionsHash: (0, extractor_contract_1.hashContextGraphJson)(input.extractorVersions),
+        gitHead,
+        gitStatusHash: (0, extractor_contract_1.hashContextGraphJson)(relevantStatusEntries),
+        dirtyContextSourceMetadataHash: dirtyMetadataHash
+    };
+}
+function readGitOutput(root, args) {
+    try {
+        return (0, node_child_process_1.execFileSync)('git', ['-C', root, ...args], {
+            encoding: 'utf8',
+            maxBuffer: 50 * 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 5000
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+function createDirtyContextSourceMetadataHash(root, gitStatus) {
+    const dirtyPaths = dirtyContextSourcePathsFromGitStatus(gitStatus);
+    if (!dirtyPaths)
+        return undefined;
+    const metadata = [];
+    for (const relativePath of dirtyPaths) {
+        try {
+            const stats = node_fs_1.default.statSync(node_path_1.default.join(root, relativePath));
+            if (stats.isFile()) {
+                metadata.push({
+                    path: relativePath,
+                    sizeBytes: stats.size,
+                    mtimeMs: stats.mtimeMs
+                });
+            }
+        }
+        catch (error) {
+            if (!isMissingFileError(error))
+                return undefined;
+        }
+    }
+    return (0, extractor_contract_1.hashContextGraphJson)(metadata.sort((a, b) => a.path.localeCompare(b.path)));
+}
+function dirtyContextSourcePathsFromGitStatus(gitStatus) {
+    const entries = contextRelevantGitStatusEntriesFromGitStatus(gitStatus);
+    if (!entries)
+        return undefined;
+    return entries.map((entry) => entry.path).sort((a, b) => a.localeCompare(b));
+}
+function contextRelevantGitStatusEntriesFromGitStatus(gitStatus) {
+    const paths = new Set();
+    const entriesByPath = new Map();
+    const entries = gitStatus.split('\0').filter(Boolean);
+    for (const entry of entries) {
+        if (entry.length < 4)
+            continue;
+        const indexStatus = entry[0];
+        const worktreeStatus = entry[1];
+        if (indexStatus === 'R' || worktreeStatus === 'R' || indexStatus === 'C' || worktreeStatus === 'C') {
+            return undefined;
+        }
+        const relativePath = (0, extractor_contract_1.normalizeContextGraphPath)(entry.slice(3));
+        if (!relativePath || shouldIgnoreContextSourcePath(relativePath))
+            continue;
+        const kind = classifyContextSourcePath(relativePath);
+        if (!kind)
+            continue;
+        paths.add(relativePath);
+        entriesByPath.set(relativePath, {
+            status: `${indexStatus}${worktreeStatus}`,
+            path: relativePath
+        });
+    }
+    return Array.from(paths)
+        .sort((a, b) => a.localeCompare(b))
+        .map((relativePath) => entriesByPath.get(relativePath))
+        .filter((entry) => Boolean(entry));
+}
+function sameContextSourceManifestFingerprint(left, right) {
+    return left.strategy === right.strategy
+        && left.projectFingerprint === right.projectFingerprint
+        && left.cacheVersion === right.cacheVersion
+        && left.ignoreConfigHash === right.ignoreConfigHash
+        && left.extractorVersionsHash === right.extractorVersionsHash
+        && left.gitHead === right.gitHead
+        && left.gitStatusHash === right.gitStatusHash
+        && left.dirtyContextSourceMetadataHash === right.dirtyContextSourceMetadataHash;
+}
+function isMissingFileError(error) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}
+function normalizeContextSourceManifestBudgets(input = {}) {
+    return {
+        maxSourceFiles: normalizeBudgetValue(input.maxSourceFiles, exports.CONTEXT_SOURCE_MANIFEST_DEFAULT_BUDGETS.maxSourceFiles),
+        maxSourceBytes: normalizeBudgetValue(input.maxSourceBytes, exports.CONTEXT_SOURCE_MANIFEST_DEFAULT_BUDGETS.maxSourceBytes),
+        maxSingleSourceBytes: normalizeBudgetValue(input.maxSingleSourceBytes, exports.CONTEXT_SOURCE_MANIFEST_DEFAULT_BUDGETS.maxSingleSourceBytes)
+    };
+}
+function normalizeBudgetValue(value, fallback) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    return Math.max(0, Math.floor(value));
+}
+function createPartialIssue(input) {
+    return {
+        severity: 'warning',
+        code: 'SOURCE_MANIFEST_PARTIAL',
+        message: input.message,
+        ...(input.path ? { path: input.path } : {}),
+        fixHint: input.fixHint
+    };
+}
+function createContextSourceMetadataHash(input) {
+    return (0, extractor_contract_1.hashContextGraphJson)({
+        path: input.path,
+        kind: input.kind,
+        sizeBytes: input.sizeBytes,
+        mtimeMs: input.mtimeMs ?? null,
+        ignoreConfigHash: input.ignoreConfigHash,
+        extractorKeys: input.extractorKeys,
+        extractorVersions: Object.fromEntries(input.extractorKeys.map((key) => [key, input.extractorVersions[key] ?? 'unknown']).sort())
+    });
+}
+function createStableContextSourceManifestHash(input) {
+    return (0, extractor_contract_1.hashContextGraphJson)({
+        schemaVersion: input.schemaVersion,
+        projectFingerprint: input.projectFingerprint,
+        cacheVersion: input.cacheVersion,
+        ignoreConfigHash: input.ignoreConfigHash,
+        extractorVersions: input.extractorVersions,
+        sources: input.sources.map((source) => ({
+            path: source.path,
+            kind: source.kind,
+            sizeBytes: source.sizeBytes,
+            mtimeMs: source.mtimeMs ?? null,
+            mtimeNs: source.mtimeNs ?? null,
+            contentHash: source.contentHash ?? null,
+            metadataHash: source.metadataHash,
+            extractorKeys: source.extractorKeys,
+            parseState: source.parseState ?? null,
+            issueCodes: source.issueCodes ?? []
+        })),
+        summary: {
+            sourceCount: input.summary.sourceCount,
+            totalBytes: input.summary.totalBytes,
+            hashedSourceCount: input.summary.hashedSourceCount,
+            skippedSourceCount: input.summary.skippedSourceCount
+        },
+        budget: input.budget,
+        issues: input.issues
+    });
+}
+function canCarryForwardContentHash(previous, next) {
+    return Boolean(previous.contentHash)
+        && previous.kind === next.kind
+        && previous.sizeBytes === next.sizeBytes
+        && previous.mtimeMs === next.mtimeMs;
+}