@mu-crew/mu 3.12.0 → 3.13.0

package/dist/chunk-3BARPJLY.js

@@ -0,0 +1,44 @@
+import { createRequire as __muCreateRequire } from "node:module"; const require = __muCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};
+//# sourceMappingURL=chunk-3BARPJLY.js.map

package/dist/{chunk-R2SVBZAB.js → chunk-45KQLMEL.js}

@@ -1,7 +1,8 @@
+import { createRequire as __muCreateRequire } from "node:module"; const require = __muCreateRequire(import.meta.url);
 import {
   defaultStateDir,
   xdgStateHome
-} from "./chunk-L2ABBTYG.js";
+} from "./chunk-WI6AWCMK.js";
 
 // src/capture.ts
 var UNRESOLVED = "<unresolved>";
@@ -768,6 +769,9 @@ CREATE TABLE IF NOT EXISTS sync_peers (
 -- when ingest read that segment cleanly to its end (src/segments.ts
 -- segmentCaughtUp). Keyed like sync_peers; a watermark write without a
 -- clean read deletes the row. A cache: losing it costs one full read.
+-- The value may carry tab-separated resume fields after the key
+-- (src/segment-resume.ts): byte offset and sha256 state for ingest
+-- to read only appended bytes.
 -- Additive, so no schema bump: an older mu ignores it, and any
 -- watermark it writes can no longer match a stale fingerprint.
 CREATE TABLE IF NOT EXISTS sync_fingerprints (
@@ -1788,22 +1792,118 @@ function readManifest(segment) {
 }
 
 // src/segments.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import {
   appendFileSync,
-  closeSync,
+  closeSync as closeSync2,
   existsSync as existsSync2,
   mkdirSync as mkdirSync2,
-  openSync,
+  openSync as openSync2,
   readdirSync,
-  readFileSync as readFileSync2,
-  readSync,
-  statSync,
+  readFileSync as readFileSync3,
+  readSync as readSync2,
+  statSync as statSync2,
   writeFileSync as writeFileSync2
 } from "fs";
 import { tmpdir } from "os";
 import { join as join3, resolve as resolve2, sep } from "path";
 import { crc32 } from "zlib";
+
+// src/compare.ts
+function compareStrings(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/segment-resume.ts
+import { createHash as createHash2 } from "crypto";
+import { closeSync, fstatSync, openSync, readFileSync as readFileSync2, readSync, statSync } from "fs";
+function usableShaState(state, length) {
+  if (typeof state !== "object" || state === null) return null;
+  const { h, n, tail } = state;
+  if (typeof h !== "string" || !/^[0-9a-f]{64}$/.test(h)) return null;
+  if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 0 || n !== length) return null;
+  if (typeof tail !== "string") return null;
+  const raw = Buffer.from(tail, "base64");
+  if (raw.length !== n % 64 || raw.toString("base64") !== tail) return null;
+  return { h, n, tail };
+}
+function encodeFingerprint(key, resume) {
+  if (resume === null) return key;
+  const { lines, size, lastHlc, state } = resume;
+  return [key, lines, size, lastHlc, state.h, state.tail].join("	");
+}
+function decodeFingerprint(raw) {
+  const [key = "", lines, size, lastHlc, h, tail] = raw.split("	");
+  if (h === void 0 || tail === void 0 || lines === void 0 || size === void 0) {
+    return { key, resume: null };
+  }
+  const n = Number(size);
+  const count = Number(lines);
+  if (!Number.isSafeInteger(n) || n <= 0 || !Number.isSafeInteger(count) || count <= 0) {
+    return { key, resume: null };
+  }
+  if (!lastHlc || !/^[0-9a-f]{64}$/.test(h)) return { key, resume: null };
+  return { key, resume: { lines: count, size: n, lastHlc, state: { h, n, tail } } };
+}
+function readAppended(path, resume, manifestSha) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const size = fstatSync(fd).size;
+    if (size <= resume.size) return null;
+    const bytes = Buffer.alloc(size - resume.size);
+    for (let got = 0; got < bytes.length; ) {
+      const n = readSync(fd, bytes, got, bytes.length - got, resume.size + got);
+      if (n === 0) return null;
+      got += n;
+    }
+    const state = sha256Update(resume.state, bytes);
+    return sha256Digest(state) === manifestSha ? { bytes, state } : null;
+  } finally {
+    closeSync(fd);
+  }
+}
+function segmentFingerprint(path) {
+  try {
+    const { size, mtimeMs } = statSync(path);
+    const manifest = readFileSync2(manifestPath(path));
+    const sha = createHash2("sha256").update(manifest).digest("hex");
+    let count = null;
+    let parsed = null;
+    try {
+      parsed = JSON.parse(manifest.toString("utf8"));
+      count = parsed?.count;
+    } catch {
+    }
+    return { key: `${size} ${mtimeMs} ${sha}`, count, manifest: parsed };
+  } catch {
+    return null;
+  }
+}
+function recordedFingerprint(db, watermarkKey) {
+  const row = prepareCached(
+    db,
+    "SELECT fingerprint FROM sync_fingerprints WHERE machine_id = ?"
+  ).get(watermarkKey);
+  return row?.fingerprint ?? null;
+}
+function segmentCaughtUp(db, watermarkKey, path, lines) {
+  const recorded = recordedFingerprint(db, watermarkKey);
+  if (recorded === null) return false;
+  const now = segmentFingerprint(path);
+  return now !== null && now.count === lines && now.key === decodeFingerprint(recorded).key;
+}
+function resumePoint(db, watermarkKey, lines) {
+  const recorded = recordedFingerprint(db, watermarkKey);
+  const resume = recorded === null ? null : decodeFingerprint(recorded).resume;
+  return resume !== null && resume.lines === lines ? resume : null;
+}
+
+// src/segments.ts
 var SEGMENT_FORMAT_VERSION = 1;
 var SEGMENT_EXT2 = ".jsonl";
 function syncDir() {
@@ -1983,7 +2083,7 @@ async function flushSegment(db, dir = syncDir(), opts) {
       };
     }
   }
-  const lockName = createHash2("sha256").update(`${dir}${machineId}`).digest("hex").slice(0, 16);
+  const lockName = createHash3("sha256").update(`${dir}${machineId}`).digest("hex").slice(0, 16);
   return withFileLock(
     join3(locksDir(), `segment-${lockName}.lock`),
     `segment:${machineId}`,
@@ -2105,7 +2205,7 @@ function trustedTail(path, machineId) {
   const { count, lastHlc, size, mtimeMs, shaState } = m;
   let stat2;
   try {
-    stat2 = statSync(path);
+    stat2 = statSync2(path);
   } catch {
     return null;
   }
@@ -2119,17 +2219,17 @@ function trustedTail(path, machineId) {
 }
 function readLastLine(path, size) {
   if (size === 0) return null;
-  const fd = openSync(path, "r");
+  const fd = openSync2(path, "r");
   try {
     const last = Buffer.alloc(1);
-    readSync(fd, last, 0, 1, size - 1);
+    readSync2(fd, last, 0, 1, size - 1);
     if (last[0] !== 10) return null;
     const chunks = [];
     let end = size - 1;
     while (end > 0) {
       const start = Math.max(0, end - 64 * 1024);
       const buf = Buffer.alloc(end - start);
-      readSync(fd, buf, 0, buf.length, start);
+      readSync2(fd, buf, 0, buf.length, start);
       const nl = buf.lastIndexOf(10);
       if (nl >= 0) {
         chunks.unshift(buf.subarray(nl + 1));
@@ -2140,43 +2240,15 @@ function readLastLine(path, size) {
     }
     return Buffer.concat(chunks).toString("utf8");
   } finally {
-    closeSync(fd);
-  }
-}
-function segmentFingerprint(path) {
-  try {
-    const { size, mtimeMs } = statSync(path);
-    const manifest = readFileSync2(manifestPath(path));
-    const sha = createHash2("sha256").update(manifest).digest("hex");
-    let count = null;
-    try {
-      count = JSON.parse(manifest.toString("utf8")).count;
-    } catch {
-    }
-    return { key: `${size} ${mtimeMs} ${sha}`, count };
-  } catch {
-    return null;
+    closeSync2(fd);
   }
 }
-function recordedFingerprint(db, watermarkKey) {
-  const row = prepareCached(
-    db,
-    "SELECT fingerprint FROM sync_fingerprints WHERE machine_id = ?"
-  ).get(watermarkKey);
-  return row?.fingerprint ?? null;
-}
-function segmentCaughtUp(db, watermarkKey, path, lines) {
-  const recorded = recordedFingerprint(db, watermarkKey);
-  if (recorded === null) return false;
-  const now = segmentFingerprint(path);
-  return now !== null && now.count === lines && now.key === recorded;
-}
 function segmentLineCount(path) {
   return readSegmentTail(path).count;
 }
 function readSegmentTail(path) {
   if (!existsSync2(path)) return { count: 0, lastHlc: null, goodLines: [], defect: null };
-  const lines = segmentLines(readFileSync2(path, "utf8"));
+  const lines = segmentLines(readFileSync3(path, "utf8"));
   let lastHlc = null;
   let count = 0;
   let defect = null;
@@ -2203,14 +2275,14 @@ function segmentLines(raw) {
   return lines;
 }
 function writeManifest(path, machine, count, lastHlc, incremental) {
-  let stat2 = statSync(path);
+  let stat2 = statSync2(path);
   let shaState;
   if (incremental !== null && stat2.size === incremental.size + incremental.appended.length) {
     shaState = sha256Update(incremental.state, incremental.appended);
   } else {
-    const bytes = readFileSync2(path);
+    const bytes = readFileSync3(path);
     shaState = sha256Update(sha256Initial(), bytes);
-    stat2 = statSync(path);
+    stat2 = statSync2(path);
   }
   writeManifestFile(path, {
     v: SEGMENT_FORMAT_VERSION,
@@ -2227,11 +2299,14 @@ function verifyAgainstManifest(segment) {
   const manifest = readManifest(segment);
   if (manifest === null) return { ok: true };
   if (!existsSync2(segment)) return { ok: false, reason: "segment missing but manifest present" };
-  const sha = createHash2("sha256").update(readFileSync2(segment)).digest("hex");
-  if (sha === manifest.sha256) return { ok: true };
+  return checkBytesAgainstManifest(segment, manifest, readFileSync3(segment));
+}
+function checkBytesAgainstManifest(segment, manifest, bytes) {
+  const sha = createHash3("sha256").update(bytes).digest("hex");
+  if (sha === manifest.sha256) return { ok: true, exact: true };
   const tail = readSegmentTail(segment);
   if (tail.count >= manifest.count) {
-    return { ok: true };
+    return { ok: true, exact: false };
   }
   return {
     ok: false,
@@ -2250,13 +2325,13 @@ function discoverPeers(dir, selfMachineId) {
     if (machineId === selfMachineId && !conflictCopy) continue;
     const path = join3(dir, name);
     try {
-      if (!statSync(path).isFile()) continue;
+      if (!statSync2(path).isFile()) continue;
     } catch {
       continue;
     }
     peers.push({ machineId, watermarkKey: conflictCopy ? stem : machineId, path, conflictCopy });
   }
-  return peers.sort((a, b) => a.path.localeCompare(b.path));
+  return peers.sort((a, b) => compareStrings(a.path, b.path));
 }
 function peerWatermarkKey(peer) {
   return peer.watermarkKey ?? peer.machineId;
@@ -2304,52 +2379,68 @@ function ingestSegment(db, peer, opts) {
   const defects = [];
   const watermarkKey = peerWatermarkKey(peer);
   const start = getWatermark(db, watermarkKey);
-  if (opts?.verify !== true && segmentCaughtUp(db, watermarkKey, peer.path, start)) {
-    return {
-      machineId: peer.machineId,
-      path: peer.path,
-      read: 0,
-      applied: 0,
-      changed: 0,
-      watermark: start,
-      defects,
-      truncatedAt: null
-    };
-  }
-  if (!existsSync2(peer.path)) {
-    return {
-      machineId: peer.machineId,
-      path: peer.path,
-      read: 0,
-      applied: 0,
-      changed: 0,
-      watermark: start,
-      defects,
-      truncatedAt: null
-    };
-  }
+  const nothing = {
+    machineId: peer.machineId,
+    path: peer.path,
+    read: 0,
+    applied: 0,
+    changed: 0,
+    watermark: start,
+    defects,
+    truncatedAt: null
+  };
+  if (opts?.verify !== true && segmentCaughtUp(db, watermarkKey, peer.path, start)) return nothing;
+  if (!existsSync2(peer.path)) return nothing;
   const fingerprint = segmentFingerprint(peer.path);
-  const verified = verifyAgainstManifest(peer.path);
-  if (!verified.ok) {
-    defects.push({ kind: "manifest-mismatch", line: 0, detail: verified.reason });
+  const resume = opts?.verify !== true && fingerprint?.manifest != null && start > 0 ? resumePoint(db, watermarkKey, start) : null;
+  const appended = resume !== null && fingerprint?.manifest != null ? readAppended(peer.path, resume, fingerprint.manifest.sha256) : null;
+  let lines;
+  let base;
+  let seedHlc = null;
+  let nextResume = null;
+  let resumeState = null;
+  let resumeSize = 0;
+  if (resume !== null && appended !== null) {
+    lines = segmentLines(appended.bytes.toString("utf8"));
+    base = resume.lines;
+    seedHlc = resume.lastHlc;
+    resumeState = appended.bytes[appended.bytes.length - 1] === 10 ? appended.state : null;
+    resumeSize = appended.state.n;
+  } else {
+    const manifest = readManifest(peer.path);
+    const bytes = readFileSync3(peer.path);
+    if (manifest !== null) {
+      const verified = checkBytesAgainstManifest(peer.path, manifest, bytes);
+      if (!verified.ok) {
+        defects.push({ kind: "manifest-mismatch", line: 0, detail: verified.reason });
+      } else if (verified.exact) {
+        const state = usableShaState(manifest.shaState, bytes.length);
+        if (state !== null && bytes[bytes.length - 1] === 10 && sha256Digest(state) === manifest.sha256) {
+          resumeState = state;
+          resumeSize = bytes.length;
+        }
+      }
+    }
+    lines = segmentLines(bytes.toString("utf8"));
+    base = 0;
+    if (start > 0 && start <= lines.length) {
+      const prior = lines[start - 1];
+      if (prior !== void 0) {
+        const decoded = decodeLine(prior);
+        if (decoded.ok) seedHlc = decoded.line.hlc;
+      }
+    }
   }
-  const lines = segmentLines(readFileSync2(peer.path, "utf8"));
+  const total = base + lines.length;
   let applied = 0;
   let changed = 0;
   let watermark = start;
   let truncatedAt = null;
-  let previousHlc = null;
-  if (start > 0 && start <= lines.length) {
-    const prior = lines[start - 1];
-    if (prior !== void 0) {
-      const decoded = decodeLine(prior);
-      if (decoded.ok) previousHlc = decoded.line.hlc;
-    }
-  }
+  let previousHlc = seedHlc;
   const run = db.transaction(() => {
-    for (let index = start; index < lines.length; index++) {
+    for (let index = start - base; index < lines.length; index++) {
       const raw = lines[index];
-      const lineNo = index + 1;
+      const lineNo = base + index + 1;
       if (raw === void 0 || raw.trim() === "") {
         defects.push({ kind: "malformed-shape", line: lineNo, detail: "blank line" });
         truncatedAt = lineNo;
@@ -2415,8 +2506,16 @@ function ingestSegment(db, peer, opts) {
       previousHlc = op.hlc;
       watermark = lineNo;
     }
-    const clean = defects.length === 0 && watermark === lines.length;
-    setWatermark(db, watermarkKey, watermark, clean ? fingerprint?.key ?? null : null);
+    const clean = defects.length === 0 && watermark === total;
+    if (clean && resumeState !== null && previousHlc !== null) {
+      nextResume = { lines: total, size: resumeSize, lastHlc: previousHlc, state: resumeState };
+    }
+    setWatermark(
+      db,
+      watermarkKey,
+      watermark,
+      clean && fingerprint !== null ? encodeFingerprint(fingerprint.key, nextResume) : null
+    );
   });
   run.immediate();
   return {
@@ -2491,7 +2590,7 @@ async function syncPass(db, dir = syncDir()) {
 }
 
 // src/sync.ts
-import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { existsSync as existsSync3, statSync as statSync3 } from "fs";
 import Database2 from "better-sqlite3";
 var SyncPeerNotFoundError = class extends Error {
   constructor(ref, known) {
@@ -2533,7 +2632,7 @@ function peerStatuses(db, dir) {
   const rows = discoverPeers(dir, self).map((peer) => {
     let lastSeenMs = null;
     try {
-      lastSeenMs = statSync2(peer.path).mtimeMs;
+      lastSeenMs = statSync3(peer.path).mtimeMs;
     } catch {
       lastSeenMs = null;
     }
@@ -2775,6 +2874,7 @@ export {
   repairTaskPair,
   applyOp,
   applyOps,
+  compareStrings,
   readManifest,
   SEGMENT_FORMAT_VERSION,
   syncDir,
@@ -2805,4 +2905,4 @@ export {
   ingestFromDb,
   transportNextSteps
 };
-//# sourceMappingURL=chunk-R2SVBZAB.js.map
+//# sourceMappingURL=chunk-45KQLMEL.js.map