ushman-ledger 1.2.1 → 1.2.2

package/dist/patch-resolver.js

@@ -1,28 +1,94 @@
-import { readFile } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import * as v from 'valibot';
-import { resolveBlobPath, storePatchBlob } from "./blobs.js";
+import { assertPatchTextWithinLimit, readPatchTextFromFile, resolveBlobPath, storePatchBlob, } from "./blobs.js";
 import { WorkspaceRelativePathSchema, } from "./schema/entry.js";
+import { forEachLine } from "./text-lines.js";
 const readBlobText = async (workspaceRoot, blobSha256) => readFile(resolveBlobPath(workspaceRoot, blobSha256), 'utf8');
 const formatRecordContext = (record) => `${record.kind} "${record.summary}" [${record.phase}]`;
 const normalizeWorkspaceRelativePath = (value) => v.parse(WorkspaceRelativePathSchema, value.replaceAll('\\', '/'));
-const stripGitPathPrefix = (value) => {
+const normalizeDiffPathToken = ({ headerPrefixes, side, value, }) => {
     const normalized = value.trim().replace(/^"([^"]*)"$/u, '$1');
     if (normalized === '/dev/null') {
         return null;
     }
-    if (normalized.startsWith('a/') || normalized.startsWith('b/')) {
-        return normalized.slice(2);
+    const expectedPrefix = side === 'old' ? headerPrefixes?.oldPrefix : headerPrefixes?.newPrefix;
+    if (expectedPrefix && normalized.startsWith(expectedPrefix)) {
+        return normalized.slice(expectedPrefix.length);
     }
     return normalized;
 };
-const inferHeaderPath = (line) => {
-    const match = /^diff --git (?:"a\/([^"]+)"|a\/(\S+)) (?:"b\/([^"]+)"|b\/(\S+))$/u.exec(line.trim());
-    if (!match) {
+const splitPrefixCandidate = (value) => {
+    const slashIndex = value.indexOf('/');
+    if (slashIndex <= 0) {
         return null;
     }
-    const rightPath = match[3] ?? match[4];
-    return rightPath ? stripGitPathPrefix(`b/${rightPath}`) : null;
+    return {
+        prefix: value.slice(0, slashIndex + 1),
+        suffix: value.slice(slashIndex + 1),
+    };
+};
+const readDiffHeaderToken = (headerBody, startIndex) => {
+    let index = startIndex;
+    while (headerBody[index] === ' ') {
+        index += 1;
+    }
+    if (index >= headerBody.length) {
+        return null;
+    }
+    if (headerBody[index] === '"') {
+        const endIndex = headerBody.indexOf('"', index + 1);
+        if (endIndex === -1) {
+            return null;
+        }
+        return {
+            nextIndex: endIndex + 1,
+            token: headerBody.slice(index + 1, endIndex),
+        };
+    }
+    let endIndex = index;
+    while (endIndex < headerBody.length && headerBody[endIndex] !== ' ') {
+        endIndex += 1;
+    }
+    return {
+        nextIndex: endIndex + 1,
+        token: headerBody.slice(index, endIndex),
+    };
+};
+const resolveHeaderPrefixes = (oldPath, newPath) => {
+    if (oldPath.startsWith('a/') && newPath.startsWith('b/')) {
+        return {
+            newPrefix: 'b/',
+            oldPrefix: 'a/',
+        };
+    }
+    const oldCandidate = splitPrefixCandidate(oldPath);
+    const newCandidate = splitPrefixCandidate(newPath);
+    if (!oldCandidate ||
+        !newCandidate ||
+        oldCandidate.prefix === newCandidate.prefix ||
+        oldCandidate.suffix !== newCandidate.suffix) {
+        return null;
+    }
+    return {
+        newPrefix: newCandidate.prefix,
+        oldPrefix: oldCandidate.prefix,
+    };
+};
+const parseDiffHeaderPaths = (line) => {
+    const headerBody = line.trim().slice('diff --git '.length);
+    const firstToken = readDiffHeaderToken(headerBody, 0);
+    const secondToken = firstToken ? readDiffHeaderToken(headerBody, firstToken.nextIndex) : null;
+    if (!firstToken?.token || !secondToken?.token) {
+        return null;
+    }
+    const oldPath = firstToken.token;
+    const newPath = secondToken.token;
+    return {
+        headerPrefixes: resolveHeaderPrefixes(oldPath, newPath),
+        newPath,
+        oldPath,
+    };
 };
 const finalizeFileChange = (current, filesChanged) => {
     if (!current) {
@@ -38,19 +104,33 @@ const finalizeFileChange = (current, filesChanged) => {
         removed: current.removed > 0 ? current.removed : undefined,
     });
 };
-const createDiffFileAccumulator = (line) => ({
-    added: 0,
-    headerPath: inferHeaderPath(line),
-    minusPath: null,
-    plusPath: null,
-    removed: 0,
-});
+const createDiffFileAccumulator = (line) => {
+    const headerPaths = parseDiffHeaderPaths(line);
+    return {
+        added: 0,
+        headerPath: headerPaths
+            ? normalizeDiffPathToken({
+                headerPrefixes: headerPaths.headerPrefixes,
+                side: 'new',
+                value: headerPaths.newPath,
+            })
+            : null,
+        headerPrefixes: headerPaths?.headerPrefixes ?? null,
+        minusPath: null,
+        plusPath: null,
+        removed: 0,
+    };
+};
 const applyPatchMetadataLine = (current, line) => {
     if (line.startsWith('+++ ')) {
         return {
             next: {
                 ...current,
-                plusPath: stripGitPathPrefix(line.slice(4)),
+                plusPath: normalizeDiffPathToken({
+                    headerPrefixes: current.headerPrefixes,
+                    side: 'new',
+                    value: line.slice(4),
+                }),
             },
         };
     }
@@ -58,7 +138,35 @@ const applyPatchMetadataLine = (current, line) => {
         return {
             next: {
                 ...current,
-                minusPath: stripGitPathPrefix(line.slice(4)),
+                minusPath: normalizeDiffPathToken({
+                    headerPrefixes: current.headerPrefixes,
+                    side: 'old',
+                    value: line.slice(4),
+                }),
+            },
+        };
+    }
+    if (line.startsWith('rename from ')) {
+        return {
+            next: {
+                ...current,
+                minusPath: normalizeDiffPathToken({
+                    headerPrefixes: null,
+                    side: 'old',
+                    value: line.slice('rename from '.length),
+                }),
+            },
+        };
+    }
+    if (line.startsWith('rename to ')) {
+        return {
+            next: {
+                ...current,
+                plusPath: normalizeDiffPathToken({
+                    headerPrefixes: null,
+                    side: 'new',
+                    value: line.slice('rename to '.length),
+                }),
             },
         };
     }
@@ -74,16 +182,12 @@ const applyPatchMetadataLine = (current, line) => {
 };
 const applyPatchHunkLine = (current, line) => {
     if (line.startsWith('+')) {
-        return {
-            ...current,
-            added: current.added + 1,
-        };
+        current.added += 1;
+        return current;
     }
     if (line.startsWith('-')) {
-        return {
-            ...current,
-            removed: current.removed + 1,
-        };
+        current.removed += 1;
+        return current;
     }
     return current;
 };
@@ -91,36 +195,56 @@ const mergeBlobLink = (links, blobSha256) => ({
     ...links,
     blobs: [...new Set([...(links?.blobs ?? []), blobSha256])],
 });
-const resolvePatchSource = async ({ record, workspaceRoot, }) => {
-    if (record.diffPath) {
-        const resolvedPath = path.resolve(workspaceRoot, record.diffPath);
+const resolvePatchSourceFromFile = async (record, workspaceRoot) => {
+    const resolvedPath = path.resolve(workspaceRoot, record.diffPath);
+    try {
         return {
-            patchText: await readFile(resolvedPath, 'utf8'),
+            patchText: await readPatchTextFromFile(resolvedPath),
             source: 'file',
             sourceLabel: resolvedPath,
         };
     }
-    if (record.diffText) {
+    catch (error) {
+        throw new Error(`Failed to read diff file ${resolvedPath} for ${formatRecordContext(record)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+const resolvePatchSourceFromInlineText = (record) => {
+    try {
+        assertPatchTextWithinLimit(record.diffText, 'inline diff text');
         return {
             patchText: record.diffText,
             source: 'inline',
             sourceLabel: 'inline diff text',
         };
     }
-    if (record.diff) {
-        try {
-            return {
-                patchText: await readBlobText(workspaceRoot, record.diff.blobSha256),
-                source: 'blob',
-                sourceLabel: `blob ${record.diff.blobSha256}`,
-            };
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                throw new Error(`Patch blob ${record.diff.blobSha256} was not found for ${formatRecordContext(record)}. Store it first or use diffPath.`);
-            }
-            throw error;
+    catch (error) {
+        throw new Error(`Failed to validate inline diff text for ${formatRecordContext(record)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+const resolvePatchSourceFromStoredBlob = async (record, workspaceRoot) => {
+    try {
+        return {
+            patchText: await readBlobText(workspaceRoot, record.diff?.blobSha256),
+            source: 'blob',
+            sourceLabel: `blob ${record.diff?.blobSha256}`,
+        };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Patch blob ${record.diff?.blobSha256} was not found for ${formatRecordContext(record)}. Store it first or use diffPath.`);
         }
+        throw error;
+    }
+};
+const resolvePatchSource = async ({ record, workspaceRoot, }) => {
+    if (record.diffPath) {
+        return resolvePatchSourceFromFile(record, workspaceRoot);
+    }
+    if (record.diffText) {
+        return resolvePatchSourceFromInlineText(record);
+    }
+    if (record.diff) {
+        return resolvePatchSourceFromStoredBlob(record, workspaceRoot);
     }
     throw new Error(`${record.kind} records require diff, diffPath, or diffText.`);
 };
@@ -140,34 +264,34 @@ export const deriveFilesChangedFromPatch = (patchText) => {
     const filesChanged = [];
     let current;
     let insideHunk = false;
-    for (const line of patchText.split(/\r?\n/u)) {
+    forEachLine(patchText, (line) => {
         if (line.startsWith('diff --git ')) {
             finalizeFileChange(current, filesChanged);
             current = createDiffFileAccumulator(line);
             insideHunk = false;
-            continue;
+            return;
         }
         if (!current) {
-            continue;
+            return;
         }
         if (insideHunk) {
             if (line.startsWith('@@')) {
-                continue;
+                return;
             }
             current = applyPatchHunkLine(current, line);
-            continue;
+            return;
         }
         const metadataUpdate = applyPatchMetadataLine(current, line);
         current = metadataUpdate.next;
         if (metadataUpdate.startHunk) {
             insideHunk = true;
-            continue;
+            return;
         }
         if (!insideHunk) {
-            continue;
+            return;
         }
         current = applyPatchHunkLine(current, line);
-    }
+    });
     finalizeFileChange(current, filesChanged);
     return filesChanged;
 };
@@ -180,6 +304,22 @@ const buildResolvedPatchRecord = ({ links, record, storedDiff, }) => {
     };
 };
 export async function resolvePatchRecord({ record, workspaceRoot, }) {
+    if (record.diff && !record.diffPath && !record.diffText) {
+        try {
+            await stat(resolveBlobPath(workspaceRoot, record.diff.blobSha256));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`Patch blob ${record.diff.blobSha256} was not found for ${formatRecordContext(record)}. Store it first or use diffPath.`);
+            }
+            throw new Error(`Failed to read patch blob ${record.diff.blobSha256} for ${formatRecordContext(record)}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return buildResolvedPatchRecord({
+            links: mergeBlobLink(record.links, record.diff.blobSha256),
+            record,
+            storedDiff: record.diff,
+        });
+    }
     const { patchText, sourceLabel } = await resolvePatchSource({
         record,
         workspaceRoot,

package/dist/read-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read-index.d.ts","sourceRoot":"","sources":["../src/read-index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAG7B,OAAO,EAAgB,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAoB,MAAM,mBAAmB,CAAC;AACxH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAO3D,QAAA,MAAM,oBAAoB;;;;aAIxB,CAAC;AAEH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAc1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACxE,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AA0HhG,eAAO,MAAM,0BAA0B,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc;;;;;;;;;;;EAuB/F,CAAC;AAYF,eAAO,MAAM,kBAAkB,GAAI,OAAO,eAAe,EAAE,UAAU,cAAc,YAG1C,CAAC;AAE1C,eAAO,MAAM,aAAa,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAWzF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,eAAe,MAAM,EAAE,WAAW,eAAe,kBAGpF,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc;;;;;;;;;;;EAiB7F,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,iCAIpC;IACC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B;;;;;;;;;;;CAYA,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,uCAIpC;IACC,QAAQ,CAAC,MAAM,EAAE;QACb,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;QAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;QAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CAC3C,YAeA,CAAC"}
+{"version":3,"file":"read-index.d.ts","sourceRoot":"","sources":["../src/read-index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAI7B,OAAO,EAAgB,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAoB,MAAM,mBAAmB,CAAC;AACxH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAK3D,QAAA,MAAM,oBAAoB;;;;aAIxB,CAAC;AAEH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAc1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACxE,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AA4HhG,eAAO,MAAM,0BAA0B,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc;;;;;;;;;;;EAyB/F,CAAC;AAYF,eAAO,MAAM,kBAAkB,GAAI,OAAO,eAAe,EAAE,UAAU,cAAc,YAG1C,CAAC;AAE1C,eAAO,MAAM,aAAa,GAAU,eAAe,MAAM,KAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAWzF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAU,eAAe,MAAM,EAAE,WAAW,eAAe,kBAGpF,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAU,eAAe,MAAM,EAAE,UAAU,cAAc;;;;;;;;;;;EAiB7F,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,iCAIpC;IACC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC7B;;;;;;;;;;;CAYA,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,uCAIpC;IACC,QAAQ,CAAC,MAAM,EAAE;QACb,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;QAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;QAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;IACF,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;CAC3C,YAeA,CAAC"}

package/dist/read-index.js

@@ -2,11 +2,10 @@ import { readFile } from 'node:fs/promises';
 import * as v from 'valibot';
 import { mapWithConcurrencyLimit } from "./async.js";
 import { stableStringify } from "./json.js";
+import { getLedgerRuntimeConfig } from "./runtime-config.js";
 import { LEDGER_KINDS, parseLedgerEntry } from "./schema/entry.js";
 import { readPhaseEntryText, resolveLedgerPaths, writeAtomicTextFile } from "./storage/filesystem.js";
 const READ_INDEX_SCHEMA_VERSION = 'ushman-ledger-read-index/v1';
-const ENTRY_READ_BATCH_SIZE = 32;
-const ENTRY_READ_CONCURRENCY = 16;
 const ReadIndexEntrySchema = v.object({
     id: v.pipe(v.string(), v.minLength(1)),
     kind: v.picklist(LEDGER_KINDS),
@@ -83,7 +82,7 @@ const readIndexedEntry = async ({ entryId, phase, workspaceRoot, }) => {
     const text = await readPhaseEntryText(workspaceRoot, phase, `${entryId}.json`);
     return parseLedgerEntry(JSON.parse(text));
 };
-const readIndexedEntryBatch = async ({ entryLocations, workspaceRoot, }) => mapWithConcurrencyLimit(entryLocations, ENTRY_READ_CONCURRENCY, async ([entryId, location]) => readIndexedEntry({
+const readIndexedEntryBatch = async ({ entryReadConcurrency, entryLocations, workspaceRoot, }) => mapWithConcurrencyLimit(entryLocations, entryReadConcurrency, async ([entryId, location]) => readIndexedEntry({
     entryId,
     phase: location.phase,
     workspaceRoot,
@@ -97,12 +96,14 @@ const collectCoveredFiles = (entry, coveredFiles) => {
     }
 };
 export const buildReadIndexFromManifest = async (workspaceRoot, manifest) => {
+    const { readIndexRebuildBatchSize, readIndexRebuildConcurrency } = getLedgerRuntimeConfig();
     const orderedEntryLocations = getManifestSequenceLocations(manifest);
     const entries = [];
     const coveredFiles = new Set();
-    for (let index = 0; index < orderedEntryLocations.length; index += ENTRY_READ_BATCH_SIZE) {
-        const batch = orderedEntryLocations.slice(index, index + ENTRY_READ_BATCH_SIZE);
+    for (let index = 0; index < orderedEntryLocations.length; index += readIndexRebuildBatchSize) {
+        const batch = orderedEntryLocations.slice(index, index + readIndexRebuildBatchSize);
         const resolvedEntries = await readIndexedEntryBatch({
+            entryReadConcurrency: readIndexRebuildConcurrency,
             entryLocations: batch,
             workspaceRoot,
         });

package/dist/record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../src/record.ts"],"names":[],"mappings":"AAQA,OAAO,EACH,KAAK,WAAW,EAMnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAU3D,KAAK,qBAAqB,GAAG;IACzB,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,QAAQ,CAAC,uBAAuB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpF,CAAC;AAOF,eAAO,MAAM,wBAAwB,GAAI,eAAe,MAAM,EAAE,OAAO,qBAAqB,GAAG,IAAI,SAOlG,CAAC;AA0EF,eAAO,MAAM,YAAY,GACrB,eAAe,MAAM,EACrB,OAAO,OAAO,KACf,OAAO,CAAC;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAsF5C,CAAC;AAEF,eAAO,MAAM,aAAa,GACtB,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,SAAS,MAAM,KAChB,OAAO,CAAC,WAAW,CASrB,CAAC"}
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../src/record.ts"],"names":[],"mappings":"AASA,OAAO,EACH,KAAK,WAAW,EAMnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAU3D,KAAK,qBAAqB,GAAG;IACzB,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,QAAQ,CAAC,uBAAuB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjH,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpF,CAAC;AAOF,eAAO,MAAM,wBAAwB,GAAI,eAAe,MAAM,EAAE,OAAO,qBAAqB,GAAG,IAAI,SAOlG,CAAC;AA0EF,eAAO,MAAM,YAAY,GACrB,eAAe,MAAM,EACrB,OAAO,OAAO,KACf,OAAO,CAAC;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAsF5C,CAAC;AAEF,eAAO,MAAM,aAAa,GACtB,eAAe,MAAM,EACrB,UAAU,cAAc,EACxB,SAAS,MAAM,KAChB,OAAO,CAAC,WAAW,CASrB,CAAC"}

package/dist/record.js

@@ -2,6 +2,7 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import * as v from 'valibot';
 import { sha256Hex, stableStringify } from "./json.js";
+import { getNextManifestSequence } from "./manifest-update.js";
 import { updateManifestForEntry } from "./manifest-update.js";
 import { resolvePatchRecord } from "./patch-resolver.js";
 import { appendEntryToReadIndex, saveReadIndex } from "./read-index.js";
@@ -105,7 +106,7 @@ export const appendRecord = async (workspaceRoot, input) => {
                 id: existingId,
             };
         }
-        const nextSequence = manifest.lastSequence + 1;
+        const nextSequence = getNextManifestSequence(manifest.lastSequence);
         const { idempotencyKey: _idempotencyKey, ...recordWithoutIdempotencyKey } = normalizedRecord;
         const entryWithoutId = {
             ...recordWithoutIdempotencyKey,

package/dist/runtime-config.d.ts

@@ -0,0 +1,12 @@
+export type LedgerRuntimeConfig = {
+    readonly blobHashConcurrency: number;
+    readonly coverageFileStatConcurrency: number;
+    readonly maxPatchBytes: number;
+    readonly readIndexRebuildBatchSize: number;
+    readonly readIndexRebuildConcurrency: number;
+    readonly scanBatchSize: number;
+    readonly scanConcurrency: number;
+};
+export declare const validateLedgerRuntimeConfig: (env?: NodeJS.ProcessEnv) => void;
+export declare const getLedgerRuntimeConfig: (env?: NodeJS.ProcessEnv) => LedgerRuntimeConfig;
+//# sourceMappingURL=runtime-config.d.ts.map

package/dist/runtime-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-config.d.ts","sourceRoot":"","sources":["../src/runtime-config.ts"],"names":[],"mappings":"AAgCA,MAAM,MAAM,mBAAmB,GAAG;IAC9B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,2BAA2B,EAAE,MAAM,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,yBAAyB,EAAE,MAAM,CAAC;IAC3C,QAAQ,CAAC,2BAA2B,EAAE,MAAM,CAAC;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CACpC,CAAC;AAuDF,eAAO,MAAM,2BAA2B,GAAI,MAAK,MAAM,CAAC,UAAwB,SAE/E,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,MAAK,MAAM,CAAC,UAAwB,KAAG,mBAgB7E,CAAC"}

package/dist/runtime-config.js

@@ -0,0 +1,83 @@
+const DEFAULT_SCAN_BATCH_SIZE = 32;
+const DEFAULT_SCAN_CONCURRENCY = 16;
+const DEFAULT_MAX_PATCH_BYTES = 10 * 1024 * 1024;
+const RUNTIME_CONFIG_ENV_VARS = [
+    'USHMAN_LEDGER_BLOB_HASH_CONCURRENCY',
+    'USHMAN_LEDGER_COVERAGE_FILE_STAT_CONCURRENCY',
+    'USHMAN_LEDGER_MAX_PATCH_BYTES',
+    'USHMAN_LEDGER_READ_INDEX_REBUILD_BATCH_SIZE',
+    'USHMAN_LEDGER_READ_INDEX_REBUILD_CONCURRENCY',
+    'USHMAN_LEDGER_SCAN_BATCH_SIZE',
+    'USHMAN_LEDGER_SCAN_CONCURRENCY',
+];
+const parsePositiveIntegerEnv = ({ defaultValue, env, envVar, }) => {
+    const rawValue = env[envVar];
+    if (!rawValue) {
+        return defaultValue;
+    }
+    if (!/^[1-9]\d*$/u.test(rawValue)) {
+        throw new Error(`Invalid ${envVar} value: ${rawValue}. Expected a positive integer.`);
+    }
+    return Number.parseInt(rawValue, 10);
+};
+let processEnvRuntimeConfigCache;
+const getRuntimeConfigSignature = (env) => RUNTIME_CONFIG_ENV_VARS.map((envVar) => `${envVar}=${env[envVar] ?? ''}`).join('\u0000');
+const buildLedgerRuntimeConfig = (env) => {
+    const scanBatchSize = parsePositiveIntegerEnv({
+        defaultValue: DEFAULT_SCAN_BATCH_SIZE,
+        env,
+        envVar: 'USHMAN_LEDGER_SCAN_BATCH_SIZE',
+    });
+    const scanConcurrency = parsePositiveIntegerEnv({
+        defaultValue: DEFAULT_SCAN_CONCURRENCY,
+        env,
+        envVar: 'USHMAN_LEDGER_SCAN_CONCURRENCY',
+    });
+    return {
+        blobHashConcurrency: parsePositiveIntegerEnv({
+            defaultValue: scanConcurrency,
+            env,
+            envVar: 'USHMAN_LEDGER_BLOB_HASH_CONCURRENCY',
+        }),
+        coverageFileStatConcurrency: parsePositiveIntegerEnv({
+            defaultValue: scanConcurrency,
+            env,
+            envVar: 'USHMAN_LEDGER_COVERAGE_FILE_STAT_CONCURRENCY',
+        }),
+        maxPatchBytes: parsePositiveIntegerEnv({
+            defaultValue: DEFAULT_MAX_PATCH_BYTES,
+            env,
+            envVar: 'USHMAN_LEDGER_MAX_PATCH_BYTES',
+        }),
+        readIndexRebuildBatchSize: parsePositiveIntegerEnv({
+            defaultValue: scanBatchSize,
+            env,
+            envVar: 'USHMAN_LEDGER_READ_INDEX_REBUILD_BATCH_SIZE',
+        }),
+        readIndexRebuildConcurrency: parsePositiveIntegerEnv({
+            defaultValue: scanConcurrency,
+            env,
+            envVar: 'USHMAN_LEDGER_READ_INDEX_REBUILD_CONCURRENCY',
+        }),
+        scanBatchSize,
+        scanConcurrency,
+    };
+};
+export const validateLedgerRuntimeConfig = (env = process.env) => {
+    void getLedgerRuntimeConfig(env);
+};
+export const getLedgerRuntimeConfig = (env = process.env) => {
+    if (env !== process.env) {
+        return buildLedgerRuntimeConfig(env);
+    }
+    const signature = getRuntimeConfigSignature(env);
+    if (processEnvRuntimeConfigCache?.signature === signature) {
+        return processEnvRuntimeConfigCache.config;
+    }
+    const config = buildLedgerRuntimeConfig(env);
+    processEnvRuntimeConfigCache = {
+        config,
+        signature,
+    };
+    return config;
+};

package/dist/storage/filesystem.d.ts

@@ -5,6 +5,7 @@ export declare const LEDGER_ROOT_SEGMENTS: readonly [".lab", "ledger"];
 export declare const LEDGER_STALE_TEMP_MS = 60000;
 type AtomicWriteTestHook = {
     readonly beforeRename?: () => Promise<void>;
+    readonly beforeWrite?: () => Promise<void>;
     readonly retainOnThrow?: boolean;
 };
 export type LedgerPaths = {

package/dist/storage/filesystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/storage/filesystem.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../src/storage/filesystem.ts"],"names":[],"mappings":"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"}

package/dist/storage/filesystem.js

@@ -35,6 +35,13 @@ const runAtomicWriteTestHook = async (filePath) => {
         throw error;
     }
 };
+const runAtomicWriteWriteTestHook = async (filePath) => {
+    const { hook } = getAtomicWriteTestHook(filePath);
+    if (!hook?.beforeWrite) {
+        return;
+    }
+    await hook.beforeWrite();
+};
 export const resolveLedgerPaths = (workspaceRoot) => {
     const root = path.join(workspaceRoot, ...LEDGER_ROOT_SEGMENTS);
     return {
@@ -115,6 +122,7 @@ export const createAtomicTextFileWriter = async (filePath) => {
     const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}.${randomUUID()}`;
     const handle = await open(tempPath, 'w');
     let completed = false;
+    let pendingWriteError;
     let writeChain = Promise.resolve();
     const finalizeHandle = async () => {
         if (completed) {
@@ -125,21 +133,40 @@ export const createAtomicTextFileWriter = async (filePath) => {
     };
     const waitForWrites = async () => {
         await writeChain;
+        if (pendingWriteError) {
+            throw pendingWriteError;
+        }
     };
     return {
         abort: async () => {
             if (!(await finalizeHandle())) {
                 return;
             }
-            await waitForWrites();
+            let writeError;
+            try {
+                await waitForWrites();
+            }
+            catch (error) {
+                writeError = error;
+            }
             await handle.close();
             await rm(tempPath, { force: true });
+            if (writeError) {
+                throw writeError;
+            }
         },
         close: async () => {
             if (!(await finalizeHandle())) {
                 return;
             }
-            await waitForWrites();
+            try {
+                await waitForWrites();
+            }
+            catch (error) {
+                await handle.close();
+                await rm(tempPath, { force: true });
+                throw error;
+            }
             try {
                 await handle.sync();
             }
@@ -160,9 +187,12 @@ export const createAtomicTextFileWriter = async (filePath) => {
                 if (completed || chunk.length === 0) {
                     return;
                 }
+                await runAtomicWriteWriteTestHook(filePath);
                 await handle.writeFile(chunk, 'utf8');
             });
-            writeChain = nextWrite.then(() => undefined, () => undefined);
+            writeChain = nextWrite.catch((error) => {
+                pendingWriteError ??= error;
+            });
             await nextWrite;
         },
     };

package/dist/text-lines.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Visit each logical line in `text`, normalizing trailing `\r` from CRLF input.
+ *
+ * The final unterminated line is still visited, which keeps diff parsing stable for
+ * patch content that does not end with a trailing newline.
+ */
+export declare const forEachLine: (text: string, visit: (line: string) => void) => void;
+//# sourceMappingURL=text-lines.d.ts.map

package/dist/text-lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-lines.d.ts","sourceRoot":"","sources":["../src/text-lines.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,EAAE,OAAO,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,SAatE,CAAC"}

package/dist/text-lines.js

@@ -0,0 +1,20 @@
+/**
+ * Visit each logical line in `text`, normalizing trailing `\r` from CRLF input.
+ *
+ * The final unterminated line is still visited, which keeps diff parsing stable for
+ * patch content that does not end with a trailing newline.
+ */
+export const forEachLine = (text, visit) => {
+    let lineStart = 0;
+    for (let index = 0; index <= text.length; index += 1) {
+        if (index !== text.length && text.charCodeAt(index) !== 10) {
+            continue;
+        }
+        let line = text.slice(lineStart, index);
+        if (line.endsWith('\r')) {
+            line = line.slice(0, -1);
+        }
+        visit(line);
+        lineStart = index + 1;
+    }
+};

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const LEDGER_LIBRARY_VERSION = "1.2.0";
+export declare const LEDGER_LIBRARY_VERSION: string;
 //# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,UAAU,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB,QAAsB,CAAC"}