@akagilnc/pi-workflow-roles 0.1.4204 → 0.1.4228

package/dist/ledger-session-read.js

@@ -24,47 +24,78 @@ function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
- * Read session JSONL with honest live-tail semantics:
- * a malformed line is tolerated only when it is an unfinished final
- * fragment at EOF (no record terminator after it). Any malformed line
- * completed by a line terminator must fail loudly with file and 1-based
- * line context — even when no non-empty record follows — never silently
- * under-count.
- *
- * Loud failures throw LedgerSessionJsonlError carrying prefixRows so the
- * single parse kernel can still expose facts obtained before the bad line.
+ * Sole line-level scan of a session volume (single parse kernel, two readings).
+ * Keeps live-tail semantics: a malformed line is reported only when a record
+ * terminator completed it; an unfinished final fragment at EOF ends the scan.
+ * This reading never throws on a bad line — `readLedgerSessionJsonl` puts the
+ * loud failure back on top for the consumers that require it.
  */
-export async function readLedgerSessionJsonl(path) {
+export async function readLedgerSessionJsonlLines(path) {
     const text = await readFile(path, "utf8");
     // split keeps a trailing empty segment iff text ends with "\n", so
     // index < lines.length - 1 means this segment was terminated.
     const lines = text.split("\n");
-    const rows = [];
+    const out = [];
     for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (!line.trim())
+        const raw = lines[index];
+        if (!raw.trim())
             continue;
+        const lineNumber = index + 1;
         let row;
         try {
-            row = JSON.parse(line);
+            row = JSON.parse(raw);
         }
         catch (error) {
             if (!(error instanceof SyntaxError))
                 throw error;
             const completedByTerminator = index < lines.length - 1;
-            if (completedByTerminator) {
-                throw new LedgerSessionJsonlError(`malformed JSONL record in ${path} at line ${index + 1}: ${error.message}`, { path, line: index + 1, prefixRows: rows });
-            }
-            // unfinished fragment at EOF — keep prior complete rows
-            break;
+            // unfinished fragment at EOF — not a line at all
+            if (!completedByTerminator)
+                break;
+            out.push({
+                line: lineNumber,
+                raw,
+                error: `malformed JSONL record in ${path} at line ${lineNumber}: ${error.message}`,
+            });
+            continue;
         }
         // Syntactically complete line: must be a session object. Silent omission
         // would under-count ledger evidence (failure honesty).
         if (!isRecord(row)) {
             const kind = row === null ? "null" : Array.isArray(row) ? "array" : typeof row;
-            throw new LedgerSessionJsonlError(`complete non-object JSONL record in ${path} at line ${index + 1}: expected object, got ${kind}`, { path, line: index + 1, prefixRows: rows });
+            out.push({
+                line: lineNumber,
+                raw,
+                error: `complete non-object JSONL record in ${path} at line ${lineNumber}: expected object, got ${kind}`,
+            });
+            continue;
+        }
+        out.push({ line: lineNumber, raw, row });
+    }
+    return out;
+}
+/**
+ * Read session JSONL with honest live-tail semantics:
+ * a malformed line is tolerated only when it is an unfinished final
+ * fragment at EOF (no record terminator after it). Any malformed line
+ * completed by a line terminator must fail loudly with file and 1-based
+ * line context — even when no non-empty record follows — never silently
+ * under-count.
+ *
+ * Loud failures throw LedgerSessionJsonlError carrying prefixRows so the
+ * single parse kernel can still expose facts obtained before the bad line.
+ */
+export async function readLedgerSessionJsonl(path) {
+    const rows = [];
+    for (const line of await readLedgerSessionJsonlLines(path)) {
+        if (line.row === undefined) {
+            throw new LedgerSessionJsonlError(line.error ?? `unreadable JSONL record in ${path} at line ${line.line}`, {
+                path,
+                line: line.line,
+                prefixRows: rows,
+            });
         }
-        rows.push(row);
+        rows.push(line.row);
     }
     return rows;
 }