ushman-ledger 1.2.1 → 1.2.2

package/dist/doctor.js

@@ -5,71 +5,202 @@ import { sha256File } from "./json.js";
 import { getOrderedEntryLocations, readManifestEntryBatch } from "./list.js";
 import { isReadIndexCurrent, readReadIndex } from "./read-index.js";
 import { loadLedgerState } from "./recovery.js";
+import { getLedgerRuntimeConfig } from "./runtime-config.js";
 import { readManifest } from "./storage/filesystem.js";
-const BLOB_HASH_CONCURRENCY = 16;
 const CHECKPOINT_MAX_AGE_MS = 24 * 60 * 60 * 1_000;
-const ENTRY_READ_BATCH_SIZE = 32;
 const OPEN_ISSUE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1_000;
-const checkPrevChain = (entry, previousByPhase, issues) => {
+export const DOCTOR_FINDING_CODES = [
+    'blob-corrupt',
+    'blob-missing',
+    'blob-unreadable',
+    'change-log-rollback-missing-target',
+    'change-log-smoke-failure-missing-rollback-plan',
+    'manifest-entry-count-mismatch',
+    'manifest-entry-location-missing',
+    'manifest-entry-missing-on-disk',
+    'manifest-last-sequence-mismatch',
+    'manifest-per-phase-latest-mismatch',
+    'manifest-phase-mismatch',
+    'manifest-sequence-mismatch',
+    'open-issue-stale',
+    'phase-prev-entry-mismatch',
+    'pre-change-checkpoint-stale',
+    'read-failure',
+];
+const createFinding = ({ code, message, metadata, remediation, }) => ({
+    code,
+    message,
+    metadata,
+    remediation,
+});
+const buildDoctorReport = (findings) => ({
+    checkedAt: new Date().toISOString(),
+    findings: [...findings],
+    issueCount: findings.length,
+    issues: findings.map((finding) => finding.message),
+    ok: findings.length === 0,
+});
+const pushFinding = (findings, finding) => {
+    findings.push(finding);
+};
+const isMissingPathError = (error) => {
+    const code = error.code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+};
+const buildReadFailure = (error) => buildDoctorReport([
+    createFinding({
+        code: 'read-failure',
+        message: `Failed to read ledger state: ${error instanceof Error ? error.message ?? error.name : String(error)}.`,
+        remediation: 'Re-open the ledger or rerun the command first so recovery can reconcile pending state. If the error persists, repair or restore the invalid manifest/read-index JSON before archiving.',
+    }),
+]);
+const isChangeLogEntry = (entry) => entry.kind === 'change-log';
+const isOpenIssueNote = (entry) => entry.kind === 'note' && entry.subkind === 'open-issue';
+const checkPrevChain = (entry, findings, previousByPhase) => {
     const expectedPrev = previousByPhase.get(entry.phase) ?? null;
     if (entry.prevEntryId !== expectedPrev) {
-        issues.push(`Phase ${entry.phase} has broken prevEntryId chain at ${entry.id}: expected ${expectedPrev ?? 'null'}, found ${entry.prevEntryId ?? 'null'}.`);
+        pushFinding(findings, createFinding({
+            code: 'phase-prev-entry-mismatch',
+            message: `Phase ${entry.phase} has broken prevEntryId chain at ${entry.id}: expected ${expectedPrev ?? 'null'}, found ${entry.prevEntryId ?? 'null'}.`,
+            metadata: {
+                entryId: entry.id,
+                expectedPrevEntryId: expectedPrev,
+                foundPrevEntryId: entry.prevEntryId,
+                phase: entry.phase,
+            },
+            remediation: 'Restore the edited entry or repair the phase chain so prevEntryId matches append order. Use a correction entry for content fixes instead of hand-editing ledger history.',
+        }));
     }
     previousByPhase.set(entry.phase, entry.id);
 };
 const checkBlobPresence = async (workspaceRoot, blobChecks) => {
-    const results = await mapWithConcurrencyLimit(blobChecks, BLOB_HASH_CONCURRENCY, async ({ blobHash, entryId }) => {
+    const { blobHashConcurrency } = getLedgerRuntimeConfig();
+    const groupedBlobChecks = new Map();
+    for (const { blobHash, entryId } of blobChecks) {
+        const entryIds = groupedBlobChecks.get(blobHash) ?? [];
+        entryIds.push(entryId);
+        groupedBlobChecks.set(blobHash, entryIds);
+    }
+    const results = await mapWithConcurrencyLimit([...groupedBlobChecks.entries()], blobHashConcurrency, async ([blobHash, entryIds]) => {
+        const blobPath = resolveBlobPath(workspaceRoot, blobHash);
         try {
-            const blobPath = resolveBlobPath(workspaceRoot, blobHash);
             await stat(blobPath);
+        }
+        catch (error) {
+            if (!isMissingPathError(error)) {
+                throw error;
+            }
+            return entryIds.map((entryId) => createFinding({
+                code: 'blob-missing',
+                message: `Missing blob ${blobHash} for ${entryId}.`,
+                metadata: {
+                    blobSha256: blobHash,
+                    entryId,
+                },
+                remediation: 'Restore the missing blob file under .lab/ledger/blobs/ or recreate the patch entry from the original diff before archiving.',
+            }));
+        }
+        try {
             const actualHash = await sha256File(blobPath);
             if (actualHash !== blobHash) {
-                return `Blob ${blobHash} for ${entryId} is corrupted (found ${actualHash}).`;
+                return entryIds.map((entryId) => createFinding({
+                    code: 'blob-corrupt',
+                    message: `Blob ${blobHash} for ${entryId} is corrupted (found ${actualHash}).`,
+                    metadata: {
+                        actualSha256: actualHash,
+                        blobSha256: blobHash,
+                        entryId,
+                    },
+                    remediation: 'Restore the original blob content under .lab/ledger/blobs/ or recreate the patch entry from the original diff before archiving.',
+                }));
             }
-            return null;
+            return [];
         }
-        catch {
-            return `Missing blob ${blobHash} for ${entryId}.`;
+        catch (error) {
+            return entryIds.map((entryId) => createFinding({
+                code: 'blob-unreadable',
+                message: `Blob ${blobHash} for ${entryId} could not be read: ${error instanceof Error ? error.message : String(error)}.`,
+                metadata: {
+                    blobSha256: blobHash,
+                    entryId,
+                },
+                remediation: 'Fix the filesystem permission or read error first, then rerun doctor so blob integrity can be verified before archiving.',
+            }));
         }
     });
-    return results.filter((issue) => issue !== null);
+    return results.flat();
 };
-const checkManifestCounts = (manifest, entryCount) => {
-    const issues = [];
+const checkManifestCounts = (findings, manifest, entryCount) => {
     if (manifest.entryCount !== entryCount) {
-        issues.push(`Manifest entryCount ${manifest.entryCount} does not match disk entries ${entryCount}.`);
+        pushFinding(findings, createFinding({
+            code: 'manifest-entry-count-mismatch',
+            message: `Manifest entryCount ${manifest.entryCount} does not match disk entries ${entryCount}.`,
+            metadata: {
+                diskEntryCount: entryCount,
+                manifestEntryCount: manifest.entryCount,
+            },
+            remediation: 'Rerun the command or reopen the ledger so recovery can replay pending commits. If the mismatch persists, compare manifest.json with the on-disk phase entries and repair the missing location or file.',
+        }));
     }
     if (manifest.lastSequence !== entryCount) {
-        issues.push(`Manifest lastSequence ${manifest.lastSequence} does not match disk entries ${entryCount}.`);
+        pushFinding(findings, createFinding({
+            code: 'manifest-last-sequence-mismatch',
+            message: `Manifest lastSequence ${manifest.lastSequence} does not match disk entries ${entryCount}.`,
+            metadata: {
+                diskEntryCount: entryCount,
+                manifestLastSequence: manifest.lastSequence,
+            },
+            remediation: 'Repair manifest.json so lastSequence matches the highest durable append sequence after recovery completes.',
+        }));
     }
-    return issues;
 };
-const finalizeManifestChecks = ({ entryCount, issues, latestByPhase, manifest, unseenManifestEntryIds, }) => {
-    issues.push(...checkManifestCounts(manifest, entryCount));
+const finalizeManifestChecks = ({ entryCount, findings, latestByPhase, manifest, unseenManifestEntryIds, }) => {
+    checkManifestCounts(findings, manifest, entryCount);
     for (const entryId of unseenManifestEntryIds) {
-        issues.push(`Manifest entry location points to missing disk entry ${entryId}.`);
+        pushFinding(findings, createFinding({
+            code: 'manifest-entry-missing-on-disk',
+            message: `Manifest entry location points to missing disk entry ${entryId}.`,
+            metadata: { entryId },
+            remediation: 'Restore the missing entry file or repair manifest.entryLocations so every referenced entry id exists on disk before archiving.',
+        }));
     }
-    for (const [phase, latest] of latestByPhase.entries()) {
-        if (manifest.perPhaseLatest[phase] !== latest.entryId) {
-            issues.push(`Manifest perPhaseLatest mismatch for ${phase}: expected ${latest.entryId}, found ${manifest.perPhaseLatest[phase] ?? 'missing'}.`);
+    const phasesToCheck = new Set([...Object.keys(manifest.perPhaseLatest), ...latestByPhase.keys()]);
+    for (const phase of phasesToCheck) {
+        const latest = latestByPhase.get(phase);
+        const expectedEntryId = latest?.entryId ?? null;
+        const foundEntryId = manifest.perPhaseLatest[phase] ?? null;
+        if (foundEntryId !== expectedEntryId) {
+            pushFinding(findings, createFinding({
+                code: 'manifest-per-phase-latest-mismatch',
+                message: `Manifest perPhaseLatest mismatch for ${phase}: expected ${expectedEntryId ?? 'missing'}, found ${foundEntryId ?? 'missing'}.`,
+                metadata: {
+                    expectedEntryId,
+                    foundEntryId,
+                    phase,
+                },
+                remediation: 'Repair perPhaseLatest so each phase points at the newest durable entry in that phase.',
+            }));
         }
     }
 };
-const checkManifestSequenceOrder = (entryLocations, issues) => {
+const checkManifestSequenceOrder = (entryLocations, findings) => {
     for (let index = 0; index < entryLocations.length; index += 1) {
         const [entryId, location] = entryLocations[index];
         const expectedSequence = index + 1;
         if (location.sequence !== expectedSequence) {
-            issues.push(`Manifest sequence mismatch for ${entryId}: expected ${expectedSequence}, found ${location.sequence}.`);
+            pushFinding(findings, createFinding({
+                code: 'manifest-sequence-mismatch',
+                message: `Manifest sequence mismatch for ${entryId}: expected ${expectedSequence}, found ${location.sequence}.`,
+                metadata: {
+                    entryId,
+                    expectedSequence,
+                    foundSequence: location.sequence,
+                },
+                remediation: 'Repair manifest.entryLocations so sequences remain contiguous and match append order.',
+            }));
         }
     }
 };
-const buildReadFailure = (error) => ({
-    issues: [`Failed to read ledger state: ${error instanceof Error ? (error.message ?? error.name) : String(error)}.`],
-    ok: false,
-});
-const isChangeLogEntry = (entry) => entry.kind === 'change-log';
-const isOpenIssueNote = (entry) => entry.kind === 'note' && entry.subkind === 'open-issue';
 const trackResolutionLinks = (entry, resolvedLedgerIds) => {
     if (entry.links.correctsLedgerId) {
         resolvedLedgerIds.add(entry.links.correctsLedgerId);
@@ -87,7 +218,7 @@ const trackIdempotencyEntry = (entry, entriesByIdempotencyKey) => {
     existingEntries.push({ id: entry.id, ts: entry.ts });
     entriesByIdempotencyKey.set(idempotencyKey, existingEntries);
 };
-const checkChangeLogWarnings = ({ checkpointEntries, entriesByIdempotencyKey, issues, nowMs, openIssueEntries, resolvedLedgerIds, }) => {
+const checkChangeLogWarnings = ({ checkpointEntries, entriesByIdempotencyKey, findings, nowMs, openIssueEntries, resolvedLedgerIds, }) => {
     for (const checkpointEntry of checkpointEntries) {
         const ageMs = nowMs - Date.parse(checkpointEntry.ts);
         if (ageMs <= CHECKPOINT_MAX_AGE_MS) {
@@ -97,7 +228,15 @@ const checkChangeLogWarnings = ({ checkpointEntries, entriesByIdempotencyKey, is
         const hasFollowUp = typeof idempotencyKey === 'string' &&
             (entriesByIdempotencyKey.get(idempotencyKey) ?? []).some((candidate) => candidate.id !== checkpointEntry.id && candidate.ts >= checkpointEntry.ts);
         if (!hasFollowUp) {
-            issues.push(`Pre-change checkpoint ${checkpointEntry.id} is older than 24h and has no follow-up entry with matching idempotencyKey.`);
+            pushFinding(findings, createFinding({
+                code: 'pre-change-checkpoint-stale',
+                message: `Pre-change checkpoint ${checkpointEntry.id} is older than 24h and has no follow-up entry with matching idempotencyKey.`,
+                metadata: {
+                    entryId: checkpointEntry.id,
+                    idempotencyKey: idempotencyKey ?? null,
+                },
+                remediation: 'Append a follow-up change-log entry with the same idempotency key, or close the stale checkpoint with a correction entry explaining the abandoned work.',
+            }));
         }
     }
     for (const openIssueEntry of openIssueEntries) {
@@ -105,17 +244,36 @@ const checkChangeLogWarnings = ({ checkpointEntries, entriesByIdempotencyKey, is
         if (ageMs <= OPEN_ISSUE_MAX_AGE_MS || resolvedLedgerIds.has(openIssueEntry.id)) {
             continue;
         }
-        issues.push(`Open issue note ${openIssueEntry.id} is older than 30 days and has no resolution link.`);
+        pushFinding(findings, createFinding({
+            code: 'open-issue-stale',
+            message: `Open issue note ${openIssueEntry.id} is older than 30 days and has no resolution link.`,
+            metadata: { entryId: openIssueEntry.id },
+            remediation: 'Append a correction or superseding note that links back to the open issue once the follow-up is complete.',
+        }));
     }
 };
-const inspectManifestLocation = ({ entry, issues, latestByPhase, manifest, }) => {
+const inspectManifestLocation = ({ entry, findings, latestByPhase, manifest, }) => {
     const manifestLocation = manifest.entryLocations[entry.id];
     if (!manifestLocation) {
-        issues.push(`Manifest is missing entry location for ${entry.id}.`);
+        pushFinding(findings, createFinding({
+            code: 'manifest-entry-location-missing',
+            message: `Manifest is missing entry location for ${entry.id}.`,
+            metadata: { entryId: entry.id },
+            remediation: 'Repair manifest.entryLocations so every durable entry has a phase/sequence location before archiving.',
+        }));
         return null;
     }
     if (manifestLocation.phase !== entry.phase) {
-        issues.push(`Manifest phase mismatch for ${entry.id}: expected ${entry.phase}, found ${manifestLocation.phase}.`);
+        pushFinding(findings, createFinding({
+            code: 'manifest-phase-mismatch',
+            message: `Manifest phase mismatch for ${entry.id}: expected ${entry.phase}, found ${manifestLocation.phase}.`,
+            metadata: {
+                entryId: entry.id,
+                expectedPhase: entry.phase,
+                foundPhase: manifestLocation.phase,
+            },
+            remediation: 'Move the entry back to the correct phase directory or repair manifest.entryLocations so the recorded phase matches the stored entry.',
+        }));
     }
     const currentLatest = latestByPhase.get(entry.phase);
     if (!currentLatest || manifestLocation.sequence > currentLatest.sequence) {
@@ -123,16 +281,26 @@ const inspectManifestLocation = ({ entry, issues, latestByPhase, manifest, }) =>
     }
     return manifestLocation;
 };
-const inspectNarrativeEntry = ({ checkpointEntries, entry, issues, openIssueEntries, }) => {
+const inspectNarrativeEntry = ({ checkpointEntries, entry, findings, openIssueEntries, }) => {
     if (isChangeLogEntry(entry)) {
         if (entry.subkind === 'pre-change-checkpoint') {
             checkpointEntries.push(entry);
         }
         if (entry.smokeResult === 'fail' && !entry.rollbackPlan) {
-            issues.push(`Change-log entry ${entry.id} has smokeResult=fail but no rollbackPlan.`);
+            pushFinding(findings, createFinding({
+                code: 'change-log-smoke-failure-missing-rollback-plan',
+                message: `Change-log entry ${entry.id} has smokeResult=fail but no rollbackPlan.`,
+                metadata: { entryId: entry.id },
+                remediation: 'Append a correction or follow-up change-log entry documenting the rollback plan before treating the failure as closed.',
+            }));
         }
         if (entry.subkind === 'rollback' && !entry.rollsBack) {
-            issues.push(`Change-log rollback entry ${entry.id} is missing rollsBack.`);
+            pushFinding(findings, createFinding({
+                code: 'change-log-rollback-missing-target',
+                message: `Change-log rollback entry ${entry.id} is missing rollsBack.`,
+                metadata: { entryId: entry.id },
+                remediation: 'Append a correction or replacement rollback entry with rollsBack pointing at the reverted ledger entry id.',
+            }));
         }
     }
     if (isOpenIssueNote(entry)) {
@@ -147,14 +315,14 @@ const inspectPatchEntry = ({ blobChecks, entry, }) => {
         blobChecks.push({ blobHash, entryId: entry.id });
     }
 };
-const inspectDoctorEntry = ({ blobChecks, checkpointEntries, entry, entriesByIdempotencyKey, issues, latestByPhase, manifest, openIssueEntries, previousByPhase, resolvedLedgerIds, unseenManifestEntryIds, }) => {
+const inspectDoctorEntry = ({ blobChecks, checkpointEntries, entriesByIdempotencyKey, entry, findings, latestByPhase, manifest, openIssueEntries, previousByPhase, resolvedLedgerIds, unseenManifestEntryIds, }) => {
     unseenManifestEntryIds.delete(entry.id);
-    checkPrevChain(entry, previousByPhase, issues);
+    checkPrevChain(entry, findings, previousByPhase);
     trackIdempotencyEntry(entry, entriesByIdempotencyKey);
     trackResolutionLinks(entry, resolvedLedgerIds);
     if (!inspectManifestLocation({
         entry,
-        issues,
+        findings,
         latestByPhase,
         manifest,
     })) {
@@ -163,7 +331,7 @@ const inspectDoctorEntry = ({ blobChecks, checkpointEntries, entry, entriesByIde
     inspectNarrativeEntry({
         checkpointEntries,
         entry,
-        issues,
+        findings,
         openIssueEntries,
     });
     inspectPatchEntry({
@@ -172,7 +340,7 @@ const inspectDoctorEntry = ({ blobChecks, checkpointEntries, entry, entriesByIde
     });
 };
 const collectDoctorState = async (workspaceRoot, manifest, readIndex) => {
-    const issues = [];
+    const findings = [];
     const previousByPhase = new Map();
     const latestByPhase = new Map();
     const unseenManifestEntryIds = new Set(Object.keys(manifest.entryLocations));
@@ -183,13 +351,15 @@ const collectDoctorState = async (workspaceRoot, manifest, readIndex) => {
     const resolvedLedgerIds = new Set();
     let entryCount = 0;
     const nowMs = Date.now();
+    const { scanBatchSize, scanConcurrency } = getLedgerRuntimeConfig();
     const orderedEntries = getOrderedEntryLocations(manifest, readIndex, {});
-    checkManifestSequenceOrder(orderedEntries, issues);
-    for (let index = 0; index < orderedEntries.length; index += ENTRY_READ_BATCH_SIZE) {
-        const batch = orderedEntries.slice(index, index + ENTRY_READ_BATCH_SIZE);
+    checkManifestSequenceOrder(orderedEntries, findings);
+    for (let index = 0; index < orderedEntries.length; index += scanBatchSize) {
+        const batch = orderedEntries.slice(index, index + scanBatchSize);
         const resolvedEntries = await readManifestEntryBatch({
             allowMissing: true,
             entryLocations: batch,
+            entryReadConcurrency: scanConcurrency,
             workspaceRoot,
         });
         for (const resolvedEntry of resolvedEntries) {
@@ -202,7 +372,7 @@ const collectDoctorState = async (workspaceRoot, manifest, readIndex) => {
                 checkpointEntries,
                 entriesByIdempotencyKey,
                 entry: resolvedEntry.entry,
-                issues,
+                findings,
                 latestByPhase,
                 manifest,
                 openIssueEntries,
@@ -215,7 +385,7 @@ const collectDoctorState = async (workspaceRoot, manifest, readIndex) => {
     checkChangeLogWarnings({
         checkpointEntries,
         entriesByIdempotencyKey,
-        issues,
+        findings,
         nowMs,
         openIssueEntries,
         resolvedLedgerIds,
@@ -223,7 +393,7 @@ const collectDoctorState = async (workspaceRoot, manifest, readIndex) => {
     return {
         blobChecks,
         entryCount,
-        issues,
+        findings,
         latestByPhase,
         unseenManifestEntryIds,
     };
@@ -256,17 +426,14 @@ export const runLedgerDoctor = async (workspaceRoot, options = {}) => {
     catch (error) {
         return buildReadFailure(error);
     }
-    const { blobChecks, entryCount, issues, latestByPhase, unseenManifestEntryIds } = doctorState;
-    issues.push(...(await checkBlobPresence(workspaceRoot, blobChecks)));
+    const { blobChecks, entryCount, findings, latestByPhase, unseenManifestEntryIds } = doctorState;
+    findings.push(...(await checkBlobPresence(workspaceRoot, blobChecks)));
     finalizeManifestChecks({
         entryCount,
-        issues,
+        findings,
         latestByPhase,
         manifest: preparedState.manifest,
         unseenManifestEntryIds,
     });
-    return {
-        issues,
-        ok: issues.length === 0,
-    };
+    return buildDoctorReport(findings);
 };

package/dist/helpers.d.ts

@@ -4,4 +4,5 @@ export declare const createWorkspaceFixture: () => Promise<{
 }>;
 export declare const ageFile: (filePath: string, ageMs?: number) => Promise<void>;
 export declare const waitForFile: (filePath: string, timeoutMs?: number) => Promise<void>;
+export declare const withEnvOverrides: <Value>(overrides: Record<string, string | undefined>, action: () => Promise<Value>) => Promise<Value>;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB;;;EAuBlC,CAAC;AAEF,eAAO,MAAM,OAAO,GAAU,UAAU,MAAM,EAAE,cAAc,kBAG7D,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,UAAU,MAAM,EAAE,kBAAiB,kBAcpE,CAAC"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB;;;EAuBlC,CAAC;AAEF,eAAO,MAAM,OAAO,GAAU,UAAU,MAAM,EAAE,cAAc,kBAG7D,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,UAAU,MAAM,EAAE,kBAAiB,kBAcpE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAU,KAAK,EACxC,WAAW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EAC7C,QAAQ,MAAM,OAAO,CAAC,KAAK,CAAC,mBAuB/B,CAAC"}

package/dist/helpers.js

@@ -36,3 +36,26 @@ export const waitForFile = async (filePath, timeoutMs = 1_000) => {
     }
     throw new Error(`Timed out waiting for file: ${filePath}`);
 };
+export const withEnvOverrides = async (overrides, action) => {
+    const previousValues = new Map();
+    for (const [key, value] of Object.entries(overrides)) {
+        previousValues.set(key, process.env[key]);
+        if (value === undefined) {
+            delete process.env[key];
+            continue;
+        }
+        process.env[key] = value;
+    }
+    try {
+        return await action();
+    }
+    finally {
+        for (const [key, value] of previousValues.entries()) {
+            if (value === undefined) {
+                delete process.env[key];
+                continue;
+            }
+            process.env[key] = value;
+        }
+    }
+};

package/dist/index.d.ts

@@ -1,8 +1,10 @@
 export { type BuildRecordInput, buildChangeLogRecord, buildCorrectionRecord, buildOperatorDecisionRecord, buildStripDecisionRevertedRecord, buildValidatorResultRecord, } from './builders.ts';
 export { runLedgerCli } from './cli.ts';
 export { type CoverageReport, computeCoverage } from './coverage.ts';
+export { DOCTOR_FINDING_CODES, type DoctorFinding, type DoctorFindingCode, type DoctorFindingMetadataValue, type DoctorReport, runLedgerDoctor, } from './doctor.ts';
 export { type LedgerHandle, type LedgerRenderOptions, type LedgerRenderToOptions, openLedger, type RenderTarget, type RenderWriter, } from './handle.ts';
 export type { LedgerFilter } from './list.ts';
+export { type LedgerRuntimeConfig, getLedgerRuntimeConfig, validateLedgerRuntimeConfig } from './runtime-config.ts';
 export { appendCleanupWaveNote, appendDecompositionWaveNote, appendNote, appendOpenIssueNote, appendSemanticCleanupSummaryNote, appendVerifiedFlowNote, type NoteBody, } from './note.ts';
 export { deriveFilesChangedFromPatch } from './patch-resolver.ts';
 export { type AgentPatchDiff, AgentPatchDiffSchema, AgentPatchEntrySchema, AgentPatchRecordSchema, type ChangeLogEntry, ChangeLogEntrySchema, type ChangeLogFileChange, ChangeLogFileChangeSchema, type ChangeLogParityStatus, ChangeLogParityStatusSchema, type ChangeLogRecord, ChangeLogRecordSchema, type ChangeLogSmokeResult, ChangeLogSmokeResultSchema, type ChangeLogSubkind, ChangeLogSubkindSchema, CorrectionEntrySchema, CorrectionRecordSchema, EmitterSchema, type LedgerEntry, LedgerEntrySchema, type LedgerKind, type LedgerLinks, LedgerLinksSchema, type LedgerPhase, LedgerPhaseSchema, type LedgerRecord, LedgerRecordSchema, type NoteEntry, NoteEntrySchema, type OperatorDecisionAction, OperatorDecisionActionSchema, OperatorDecisionEntrySchema, type OperatorDecisionPayload, OperatorDecisionPayloadSchema, OperatorDecisionRecordSchema, OperatorPatchEntrySchema, OperatorPatchRecordSchema, parseLedgerEntry, parseLedgerRecord, RuntimeEventEntrySchema, StripDecisionRevertedEntrySchema, type StripDecisionRevertedPayload, StripDecisionRevertedPayloadSchema, StripDecisionRevertedRecordSchema, ToolInvocationEntrySchema, ToolInvocationRecordSchema, ValidatorResultEntrySchema, ValidatorResultRecordSchema, } from './schema/entry.ts';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,gBAAgB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,2BAA2B,EAC3B,gCAAgC,EAChC,0BAA0B,GAC7B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,KAAK,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,UAAU,EACV,KAAK,YAAY,EACjB,KAAK,YAAY,GACpB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EACH,qBAAqB,EACrB,2BAA2B,EAC3B,UAAU,EACV,mBAAmB,EACnB,gCAAgC,EAChC,sBAAsB,EACtB,KAAK,QAAQ,GAChB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EACH,KAAK,cAAc,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,oBAAoB,EACzB,0BAA0B,EAC1B,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,aAAa,EACb,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,SAAS,EACd,eAAe,EACf,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC3B,KAAK,uBAAuB,EAC5B,6BAA6B,EAC7B,4BAA4B,EAC5B,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACvB,gCAAgC,EAChC,KAAK,4BAA4B,EACjC,kCAAkC,EAClC,iCAAiC,EACjC,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,GAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,WAAW,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,gBAAgB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,2BAA2B,EAC3B,gCAAgC,EAChC,0BAA0B,GAC7B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,KAAK,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EACH,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EACjB,eAAe,GAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,UAAU,EACV,KAAK,YAAY,EACjB,KAAK,YAAY,GACpB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,KAAK,mBAAmB,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AACpH,OAAO,EACH,qBAAqB,EACrB,2BAA2B,EAC3B,UAAU,EACV,mBAAmB,EACnB,gCAAgC,EAChC,sBAAsB,EACtB,KAAK,QAAQ,GAChB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EACH,KAAK,cAAc,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,oBAAoB,EACzB,0BAA0B,EAC1B,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,aAAa,EACb,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,SAAS,EACd,eAAe,EACf,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,2BAA2B,EAC3B,KAAK,uBAAuB,EAC5B,6BAA6B,EAC7B,4BAA4B,EAC5B,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACvB,gCAAgC,EAChC,KAAK,4BAA4B,EACjC,kCAAkC,EAClC,iCAAiC,EACjC,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,GAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,WAAW,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -1,7 +1,9 @@
 export { buildChangeLogRecord, buildCorrectionRecord, buildOperatorDecisionRecord, buildStripDecisionRevertedRecord, buildValidatorResultRecord, } from "./builders.js";
 export { runLedgerCli } from "./cli.js";
 export { computeCoverage } from "./coverage.js";
+export { DOCTOR_FINDING_CODES, runLedgerDoctor, } from "./doctor.js";
 export { openLedger, } from "./handle.js";
+export { getLedgerRuntimeConfig, validateLedgerRuntimeConfig } from "./runtime-config.js";
 export { appendCleanupWaveNote, appendDecompositionWaveNote, appendNote, appendOpenIssueNote, appendSemanticCleanupSummaryNote, appendVerifiedFlowNote, } from "./note.js";
 export { deriveFilesChangedFromPatch } from "./patch-resolver.js";
 export { AgentPatchDiffSchema, AgentPatchEntrySchema, AgentPatchRecordSchema, ChangeLogEntrySchema, ChangeLogFileChangeSchema, ChangeLogParityStatusSchema, ChangeLogRecordSchema, ChangeLogSmokeResultSchema, ChangeLogSubkindSchema, CorrectionEntrySchema, CorrectionRecordSchema, EmitterSchema, LedgerEntrySchema, LedgerLinksSchema, LedgerPhaseSchema, LedgerRecordSchema, NoteEntrySchema, OperatorDecisionActionSchema, OperatorDecisionEntrySchema, OperatorDecisionPayloadSchema, OperatorDecisionRecordSchema, OperatorPatchEntrySchema, OperatorPatchRecordSchema, parseLedgerEntry, parseLedgerRecord, RuntimeEventEntrySchema, StripDecisionRevertedEntrySchema, StripDecisionRevertedPayloadSchema, StripDecisionRevertedRecordSchema, ToolInvocationEntrySchema, ToolInvocationRecordSchema, ValidatorResultEntrySchema, ValidatorResultRecordSchema, } from "./schema/entry.js";

package/dist/list.d.ts

@@ -8,9 +8,10 @@ export type LedgerFilter = {
     readonly since?: string;
 };
 export declare const getOrderedEntryLocations: (manifest: LedgerManifest, readIndex: LedgerReadIndex, filter: LedgerFilter, direction?: "asc" | "desc") => ManifestEntryLocation[];
-export declare const readManifestEntryBatch: ({ allowMissing, entryLocations, workspaceRoot, }: {
+export declare const readManifestEntryBatch: ({ allowMissing, entryLocations, entryReadConcurrency, workspaceRoot, }: {
     readonly allowMissing?: boolean;
     readonly entryLocations: readonly ManifestEntryLocation[];
+    readonly entryReadConcurrency?: number;
     readonly workspaceRoot: string;
 }) => Promise<({
     entry: {

package/dist/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../src/list.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAG7B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAoB,MAAM,mBAAmB,CAAC;AAC1G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,MAAM,MAAM,YAAY,GAAG;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAmDF,eAAO,MAAM,wBAAwB,GACjC,UAAU,cAAc,EACxB,WAAW,eAAe,EAC1B,QAAQ,YAAY,EACpB,YAAW,KAAK,GAAG,MAAc,4BAgBpC,CAAC;AAgCF,eAAO,MAAM,sBAAsB,GAAU,kDAI1C;IACC,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC1D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAQI,CAAC;AAiDN,eAAO,MAAM,0BAA0B,GACnC,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,WAAW,eAAe,EAC1B,SAAQ,YAAiB,EACzB,YAAW,KAAK,GAAG,MAAc,KAClC,aAAa,CAAC,WAAW,CAwB3B,CAAC;AAEF,eAAO,MAAM,WAAW,GACpB,eAAe,MAAM,EACrB,SAAQ,YAAiB,KAC1B,aAAa,CAAC,WAAW,CAG3B,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,eAAe,MAAM,EAAE,SAAQ,YAAiB,KAAG,OAAO,CAAC,WAAW,EAAE,CAM5G,CAAC"}
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../src/list.ts"],"names":[],"mappings":"AACA,OAAO,EACH,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAG7B,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAoB,MAAM,mBAAmB,CAAC;AAC1G,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,MAAM,MAAM,YAAY,GAAG;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAgDF,eAAO,MAAM,wBAAwB,GACjC,UAAU,cAAc,EACxB,WAAW,eAAe,EAC1B,QAAQ,YAAY,EACpB,YAAW,KAAK,GAAG,MAAc,4BAgBpC,CAAC;AAiCF,eAAO,MAAM,sBAAsB,GAAU,wEAK1C;IACC,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC1D,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACvC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAQI,CAAC;AAsDN,eAAO,MAAM,0BAA0B,GACnC,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,WAAW,eAAe,EAC1B,SAAQ,YAAiB,EACzB,YAAW,KAAK,GAAG,MAAc,KAClC,aAAa,CAAC,WAAW,CAoC3B,CAAC;AAEF,eAAO,MAAM,WAAW,GACpB,eAAe,MAAM,EACrB,SAAQ,YAAiB,KAC1B,aAAa,CAAC,WAAW,CAG3B,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,eAAe,MAAM,EAAE,SAAQ,YAAiB,KAAG,OAAO,CAAC,WAAW,EAAE,CAM5G,CAAC"}

package/dist/list.js

@@ -1,5 +1,6 @@
 import { mapWithConcurrencyLimit } from "./async.js";
 import { matchesReadIndexFilter, } from "./read-index.js";
+import { getLedgerRuntimeConfig } from "./runtime-config.js";
 import { loadLedgerState } from "./recovery.js";
 import { parseLedgerEntry } from "./schema/entry.js";
 import { readPhaseEntryText } from "./storage/filesystem.js";
@@ -15,8 +16,6 @@ const matchesFilter = (entry, filter) => {
     }
     return true;
 };
-const ENTRY_READ_BATCH_SIZE = 32;
-const ENTRY_READ_CONCURRENCY = 16;
 const getFilteredReadIndexEntries = ({ direction, filter, manifest, readIndex, }) => {
     const sourceEntries = direction === 'asc' ? readIndex.entries : [...readIndex.entries].reverse();
     const filteredEntries = [];
@@ -71,20 +70,21 @@ const readManifestEntry = async ({ allowMissing, entryId, location, workspaceRoo
         throw error;
     }
 };
-export const readManifestEntryBatch = async ({ allowMissing = false, entryLocations, workspaceRoot, }) => mapWithConcurrencyLimit(entryLocations, ENTRY_READ_CONCURRENCY, async ([entryId, location]) => readManifestEntry({
+export const readManifestEntryBatch = async ({ allowMissing = false, entryLocations, entryReadConcurrency = getLedgerRuntimeConfig().scanConcurrency, workspaceRoot, }) => mapWithConcurrencyLimit(entryLocations, entryReadConcurrency, async ([entryId, location]) => readManifestEntry({
     allowMissing,
     entryId,
     location,
     workspaceRoot,
 }));
-const collectLimitedEntries = async ({ direction, filter, manifest, readIndex, workspaceRoot, }) => {
+const collectLimitedEntries = async ({ batchSize, direction, entryReadConcurrency, filter, manifest, readIndex, workspaceRoot, }) => {
     const collectedEntries = [];
     const orderedEntries = getOrderedEntryLocations(manifest, readIndex, filter, 'desc');
     const limit = filter.limit ?? 0;
-    for (let index = 0; index < orderedEntries.length && collectedEntries.length < limit; index += ENTRY_READ_BATCH_SIZE) {
-        const batch = orderedEntries.slice(index, index + ENTRY_READ_BATCH_SIZE);
+    for (let index = 0; index < orderedEntries.length && collectedEntries.length < limit; index += batchSize) {
+        const batch = orderedEntries.slice(index, index + batchSize);
         const resolvedEntries = await readManifestEntryBatch({
             entryLocations: batch,
+            entryReadConcurrency,
             workspaceRoot,
         });
         for (const resolvedEntry of resolvedEntries) {
@@ -105,17 +105,27 @@ const collectLimitedEntries = async ({ direction, filter, manifest, readIndex, w
     return collectedEntries;
 };
 export const iterateEntriesFromManifest = async function* (workspaceRoot, manifest, readIndex, filter = {}, direction = 'asc') {
+    const { scanBatchSize, scanConcurrency } = getLedgerRuntimeConfig();
     if (filter.limit) {
-        for (const entry of await collectLimitedEntries({ direction, filter, manifest, readIndex, workspaceRoot })) {
+        for (const entry of await collectLimitedEntries({
+            batchSize: scanBatchSize,
+            direction,
+            entryReadConcurrency: scanConcurrency,
+            filter,
+            manifest,
+            readIndex,
+            workspaceRoot,
+        })) {
             yield entry;
         }
         return;
     }
     const orderedEntries = getOrderedEntryLocations(manifest, readIndex, filter, direction);
-    for (let index = 0; index < orderedEntries.length; index += ENTRY_READ_BATCH_SIZE) {
-        const batch = orderedEntries.slice(index, index + ENTRY_READ_BATCH_SIZE);
+    for (let index = 0; index < orderedEntries.length; index += scanBatchSize) {
+        const batch = orderedEntries.slice(index, index + scanBatchSize);
         const resolvedEntries = await readManifestEntryBatch({
             entryLocations: batch,
+            entryReadConcurrency: scanConcurrency,
             workspaceRoot,
         });
         for (const resolvedEntry of resolvedEntries) {

package/dist/patch-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"patch-resolver.d.ts","sourceRoot":"","sources":["../src/patch-resolver.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,YAAY,EAEpB,MAAM,mBAAmB,CAAC;AAI3B,KAAK,gBAAgB,GAAG,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,CAAC;AACvE,KAAK,mBAAmB,GAAG,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAAC;AAQ7E,KAAK,wBAAwB,GAAG,IAAI,CAAC,gBAAgB,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,GAAG;IACxF,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;CAC/B,CAAC;AACF,KAAK,2BAA2B,GAAG,IAAI,CAAC,mBAAmB,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,GAAG;IAC9F,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,wBAAwB,GAAG,2BAA2B,CAAC;AAqKzF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,2BAA2B,GAAI,WAAW,MAAM,KAAG,mBAAmB,EAuClF,CAAC;AAmBF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;AACtC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC"}
+{"version":3,"file":"patch-resolver.d.ts","sourceRoot":"","sources":["../src/patch-resolver.ts"],"names":[],"mappings":"AASA,OAAO,EACH,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,YAAY,EAEpB,MAAM,mBAAmB,CAAC;AAK3B,KAAK,gBAAgB,GAAG,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC,CAAC;AACvE,KAAK,mBAAmB,GAAG,OAAO,CAAC,YAAY,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAAC;AAQ7E,KAAK,wBAAwB,GAAG,IAAI,CAAC,gBAAgB,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,GAAG;IACxF,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;CAC/B,CAAC;AACF,KAAK,2BAA2B,GAAG,IAAI,CAAC,mBAAmB,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,GAAG;IAC9F,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,wBAAwB,GAAG,2BAA2B,CAAC;AAsTzF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,2BAA2B,GAAI,WAAW,MAAM,KAAG,mBAAmB,EAuClF,CAAC;AAmBF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;AACtC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC"}