@remnic/core 1.1.29 → 1.1.31

package/dist/{chunk-AMVN77EU.js → chunk-U7EJOMFC.js}

@@ -17,6 +17,7 @@ import {
 
 // src/offline-sync.ts
 import { createHash, randomUUID } from "crypto";
+import { createReadStream } from "fs";
 import {
   lstat,
   mkdir,
@@ -27,6 +28,7 @@ import {
   rm,
   stat,
   unlink,
+  utimes,
   writeFile
 } from "fs/promises";
 import path from "path";
@@ -36,8 +38,11 @@ var OFFLINE_SYNC_STATE_VERSION = 1;
 var OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES = 64 * 1024 * 1024;
 var OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES = 8 * 1024 * 1024;
 var OFFLINE_SYNC_APPLY_MAX_BODY_BYTES = 16 * 1024 * 1024;
+var OFFLINE_SYNC_SNAPSHOT_BASE_MAX_BODY_BYTES = 64 * 1024 * 1024;
+var OFFLINE_SYNC_MAX_MTIME_MS = 864e13;
 var SYNC_INTERNAL_DIR = ".offline-sync";
 var OFFLINE_SYNC_UPLOAD_STAGING_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS = 1e3;
 var EXCLUDED_FILE_NAMES = /* @__PURE__ */ new Set([
   ".sync-state.json"
 ]);
@@ -72,6 +77,13 @@ function assertNonNegativeFinite(value, field) {
   }
   return value;
 }
+function assertOfflineSyncMtimeMs(value, field) {
+  const mtimeMs = assertNonNegativeFinite(value, field);
+  if (mtimeMs > OFFLINE_SYNC_MAX_MTIME_MS) {
+    throw new Error(`${field} must be within JavaScript Date range`);
+  }
+  return mtimeMs;
+}
 function assertBoolean(value, field) {
   if (typeof value !== "boolean") {
     throw new Error(`${field} must be a boolean`);
@@ -94,7 +106,7 @@ function normalizeFileState(input, fieldPrefix) {
     path: relPath,
     sha256: assertSha256(obj.sha256, `${fieldPrefix}.sha256`),
     bytes: assertNonNegativeInteger(obj.bytes, `${fieldPrefix}.bytes`),
-    mtimeMs: assertNonNegativeFinite(obj.mtimeMs, `${fieldPrefix}.mtimeMs`)
+    mtimeMs: assertOfflineSyncMtimeMs(obj.mtimeMs, `${fieldPrefix}.mtimeMs`)
   };
 }
 function normalizeFileRecord(input, fieldPrefix, requireContent) {
@@ -276,20 +288,72 @@ function isCanonicalRuntimeStatePath(parts) {
   if (parts[0] === "state") return true;
   return parts[0] === "namespaces" && parts.length >= 4 && parts[2] === "state";
 }
+var REMOTE_AUTHORITATIVE_RUNTIME_STATE_FILES = /* @__PURE__ */ new Set([
+  ".artifact-write-version.log",
+  ".memory-status-version.log",
+  "buffer.json",
+  "embeddings.json",
+  "index_time.json",
+  "last_recall.json",
+  "memory-lifecycle-ledger.jsonl",
+  "recall_impressions.jsonl"
+]);
+function shouldPreferIncomingOfflineRuntimeFile(relPosix) {
+  const parts = relPosix.split("/");
+  const basename = parts[parts.length - 1] ?? "";
+  return isCanonicalRuntimeStatePath(parts) && REMOTE_AUTHORITATIVE_RUNTIME_STATE_FILES.has(basename);
+}
 function filterBaseFilesForMode(files, includeTranscripts) {
   return files.filter((file) => !shouldExcludeRelPath(file.path, includeTranscripts));
 }
+function canReuseFastBaseFileState(baseEntry, st, baseCapturedAtMs) {
+  if (baseEntry.bytes !== st.size) return false;
+  if (Math.abs(baseEntry.mtimeMs - st.mtimeMs) > OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS) {
+    return false;
+  }
+  if (baseCapturedAtMs === null) return false;
+  return st.ctimeMs - baseCapturedAtMs <= OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS;
+}
+async function canReuseFastBaseFileStateFromDisk(baseEntry, filePath, st, baseCapturedAtMs) {
+  if (!canReuseFastBaseFileState(baseEntry, st, baseCapturedAtMs)) return false;
+  return !await fileIsSecureStoreEncrypted(filePath).catch(() => true);
+}
 async function readOfflineSyncFileRecord(options) {
   const relPath = validateArchiveRelativePath(options.relPath, "offlineSyncFile.path");
-  const bytes = options.readFile ? await options.readFile({ root: options.root.abs, path: relPath, filePath: options.filePath }) : await readFile(options.filePath);
-  const digest = sha256Buffer(bytes);
+  let content = null;
+  let digest;
+  if (options.includeContent) {
+    content = options.readFile ? await options.readFile({ root: options.root.abs, path: relPath, filePath: options.filePath }) : await readFile(options.filePath);
+    digest = sha256Buffer(content);
+  } else if (options.readFileDigest) {
+    digest = await options.readFileDigest({ root: options.root.abs, path: relPath, filePath: options.filePath });
+  } else if (options.readFile) {
+    content = await options.readFile({ root: options.root.abs, path: relPath, filePath: options.filePath });
+    digest = sha256Buffer(content);
+    content = null;
+  } else {
+    digest = await sha256File(options.filePath);
+  }
   const st = await stat(options.filePath);
   return {
     path: relPath,
     sha256: digest.sha256,
     bytes: digest.bytes,
     mtimeMs: st.mtimeMs,
-    ...options.includeContent ? { contentBase64: bytes.toString("base64") } : {}
+    ...content ? { contentBase64: content.toString("base64") } : {}
+  };
+}
+async function sha256File(filePath) {
+  const hash = createHash("sha256");
+  let bytes = 0;
+  for await (const chunk of createReadStream(filePath)) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    hash.update(buffer);
+    bytes += buffer.length;
+  }
+  return {
+    sha256: hash.digest("hex"),
+    bytes
   };
 }
 async function fileIsSecureStoreEncrypted(filePath) {
@@ -314,10 +378,58 @@ async function readPlainFileContentChunk(options) {
     await handle.close();
   }
 }
+async function* iterateOfflineSyncSnapshotFileRecords(options) {
+  const rootAbs = path.resolve(options.root);
+  const root = await prepareSafeArchiveRoot(rootAbs, "iterateOfflineSyncSnapshotFileRecords", "root");
+  const includeTranscripts = options.includeTranscripts !== false;
+  async function* walk(dirAbs) {
+    let entries = await readdir(dirAbs, { withFileTypes: true });
+    entries = entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const abs = path.join(dirAbs, entry.name);
+      const relPosix = path.relative(root.abs, abs).split(path.sep).join("/");
+      if (shouldExcludeRelPath(relPosix, includeTranscripts)) continue;
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) {
+        yield* walk(abs);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      yield await readOfflineSyncFileRecord({
+        root,
+        relPath: relPosix,
+        filePath: abs,
+        includeContent: options.includeContent === true,
+        readFile: options.readFile,
+        readFileDigest: options.readFileDigest
+      });
+    }
+  }
+  yield* walk(root.abs);
+}
 async function buildOfflineSyncSnapshot(options) {
+  const includeTranscripts = options.includeTranscripts !== false;
+  const files = [];
+  for await (const file of iterateOfflineSyncSnapshotFileRecords(options)) files.push(file);
+  return {
+    format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
+    schemaVersion: 1,
+    createdAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    sourceId: normalizeSourceId(options.sourceId, "sourceId"),
+    includeTranscripts,
+    files: files.sort(compareByPath)
+  };
+}
+async function buildOfflineSyncSnapshotFromBase(options) {
   const rootAbs = path.resolve(options.root);
-  const root = await prepareSafeArchiveRoot(rootAbs, "buildOfflineSyncSnapshot", "root");
+  const root = await prepareSafeArchiveRoot(rootAbs, "buildOfflineSyncSnapshotFromBase", "root");
   const includeTranscripts = options.includeTranscripts !== false;
+  const base = byPath(filterBaseFilesForMode(
+    normalizeFileStates(options.baseFiles),
+    includeTranscripts
+  ));
+  const rawBaseCapturedAtMs = options.baseCapturedAt?.getTime();
+  const baseCapturedAtMs = rawBaseCapturedAtMs !== void 0 && Number.isFinite(rawBaseCapturedAtMs) ? rawBaseCapturedAtMs : null;
   const files = [];
   async function walk(dirAbs) {
     let entries = await readdir(dirAbs, { withFileTypes: true });
@@ -332,12 +444,19 @@ async function buildOfflineSyncSnapshot(options) {
         continue;
       }
       if (!entry.isFile()) continue;
+      const st = await stat(abs);
+      const baseEntry = base.get(relPosix);
+      if (options.includeContent !== true && baseEntry && baseCapturedAtMs !== null && await canReuseFastBaseFileStateFromDisk(baseEntry, abs, st, baseCapturedAtMs)) {
+        files.push(baseEntry);
+        continue;
+      }
       files.push(await readOfflineSyncFileRecord({
         root,
         relPath: relPosix,
         filePath: abs,
         includeContent: options.includeContent === true,
-        readFile: options.readFile
+        readFile: options.readFile,
+        readFileDigest: options.readFileDigest
       }));
     }
   }
@@ -375,7 +494,8 @@ async function buildOfflineSyncSnapshotForPaths(options) {
       relPath,
       filePath,
       includeContent: options.includeContent === true,
-      readFile: options.readFile
+      readFile: options.readFile,
+      readFileDigest: options.readFileDigest
     }));
   }
   return {
@@ -452,25 +572,45 @@ async function readOfflineSyncFileContentChunk(options) {
 }
 async function buildOfflineSyncChangeset(options) {
   const includeTranscripts = options.includeTranscripts !== false;
-  const excludedPaths = new Set(
-    (options.excludePaths ?? []).map((relPath) => normalizeRelativePath(relPath, "excludePaths[]"))
-  );
-  const base = byPath(filterBaseFilesForMode(
-    normalizeFileStates(options.baseFiles),
-    includeTranscripts
-  ));
-  const current = await buildOfflineSyncSnapshot({
+  const current = await buildOfflineSyncSnapshotFromBase({
     root: options.root,
     sourceId: options.sourceId,
+    baseFiles: options.baseFiles,
+    baseCapturedAt: options.baseCapturedAt,
     includeContent: false,
     includeTranscripts,
     now: options.now,
+    readFile: options.readFile,
+    readFileDigest: options.readFileDigest
+  });
+  return buildOfflineSyncChangesetFromSnapshot({
+    root: options.root,
+    sourceId: options.sourceId,
+    baseFiles: options.baseFiles,
+    currentFiles: current.files,
+    excludePaths: options.excludePaths,
+    includeTranscripts,
+    now: options.now,
     readFile: options.readFile
   });
-  const currentMap = byPath(current.files);
+}
+async function buildOfflineSyncChangesetFromSnapshot(options) {
+  const includeTranscripts = options.includeTranscripts !== false;
+  const excludedPaths = new Set(
+    (options.excludePaths ?? []).map((relPath) => normalizeRelativePath(relPath, "excludePaths[]"))
+  );
+  const base = byPath(filterBaseFilesForMode(
+    normalizeFileStates(options.baseFiles),
+    includeTranscripts
+  ));
+  const currentMap = byPath(filterBaseFilesForMode(
+    normalizeFileStates(options.currentFiles),
+    includeTranscripts
+  ));
   const changes = [];
   for (const relPath of unionPaths(base, currentMap)) {
     if (excludedPaths.has(relPath)) continue;
+    if (shouldPreferIncomingOfflineRuntimeFile(relPath)) continue;
     const baseEntry = base.get(relPath);
     const currentEntry = currentMap.get(relPath);
     if (currentEntry && currentEntry.sha256 !== baseEntry?.sha256) {
@@ -508,7 +648,7 @@ async function buildOfflineSyncChangeset(options) {
     schemaVersion: 1,
     createdAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
     sourceId: normalizeSourceId(options.sourceId, "sourceId"),
-    includeTranscripts: current.includeTranscripts,
+    includeTranscripts,
     changes: changes.sort(compareByPath)
   };
 }
@@ -523,22 +663,37 @@ function summarizeOfflineSyncChangeset(changeset) {
 }
 async function summarizeOfflineSyncPendingChanges(options) {
   const includeTranscripts = options.includeTranscripts !== false;
-  const base = byPath(filterBaseFilesForMode(
-    normalizeFileStates(options.baseFiles),
-    includeTranscripts
-  ));
-  const current = await buildOfflineSyncSnapshot({
+  const current = await buildOfflineSyncSnapshotFromBase({
     root: options.root,
     sourceId: options.sourceId,
+    baseFiles: options.baseFiles,
+    baseCapturedAt: options.baseCapturedAt,
     includeContent: false,
     includeTranscripts,
     now: options.now,
-    readFile: options.readFile
+    readFile: options.readFile,
+    readFileDigest: options.readFileDigest
   });
-  const currentMap = byPath(current.files);
+  return summarizeOfflineSyncPendingFiles({
+    baseFiles: options.baseFiles,
+    currentFiles: current.files,
+    includeTranscripts
+  });
+}
+function summarizeOfflineSyncPendingFiles(options) {
+  const includeTranscripts = options.includeTranscripts !== false;
+  const base = byPath(filterBaseFilesForMode(
+    normalizeFileStates(options.baseFiles),
+    includeTranscripts
+  ));
+  const currentMap = byPath(filterBaseFilesForMode(
+    normalizeFileStates(options.currentFiles),
+    includeTranscripts
+  ));
   let upserts = 0;
   let deletes = 0;
   for (const relPath of unionPaths(base, currentMap)) {
+    if (shouldPreferIncomingOfflineRuntimeFile(relPath)) continue;
     const baseEntry = base.get(relPath);
     const currentEntry = currentMap.get(relPath);
     if (currentEntry && currentEntry.sha256 !== baseEntry?.sha256) {
@@ -566,30 +721,61 @@ async function applyOfflineSyncSnapshot(options) {
     requireContent: false
   });
   const root = await ensureSyncRoot(options.root, "applyOfflineSyncSnapshot");
-  const current = await buildOfflineSyncSnapshot({
+  const currentFiles = options.currentFiles ? filterBaseFilesForMode(normalizeFileStates(options.currentFiles), snapshot.includeTranscripts).sort(compareByPath) : (await buildOfflineSyncSnapshot({
     root: root.abs,
     sourceId: "local",
     includeContent: false,
     includeTranscripts: snapshot.includeTranscripts,
-    readFile: options.readFile
-  });
-  const currentMap = byPath(current.files);
+    readFile: options.readFile,
+    readFileDigest: options.readFileDigest
+  })).files;
+  const currentMap = byPath(currentFiles);
+  const deferredPaths = new Set(options.deferredPaths ?? []);
   const nextBase = new Map(baseMap);
   const conflicts = [];
   let upserted = 0;
   let deleted = 0;
   let skipped = 0;
   let pendingLocal = 0;
+  const conflictIncomingBuffer = (relPath) => {
+    if (options.writeConflictCopies === false) return void 0;
+    const buffer = incomingBuffers.get(relPath);
+    if (buffer || options.allowMissingConflictContent === true) return buffer;
+    return requiredBuffer(incomingBuffers, relPath);
+  };
   for (const relPath of unionPaths(baseMap, incomingMap, currentMap)) {
     const base = baseMap.get(relPath);
     const incoming = incomingMap.get(relPath);
     const currentEntry = currentMap.get(relPath);
+    if (deferredPaths.has(relPath)) {
+      if (base) nextBase.set(relPath, base);
+      else nextBase.delete(relPath);
+      skipped += 1;
+      continue;
+    }
     if (incoming) {
       if (currentEntry?.sha256 === incoming.sha256) {
-        nextBase.set(relPath, toFileState(incoming));
+        if (await setSafeFileMtime(root, relPath, incoming.mtimeMs)) {
+          nextBase.set(relPath, toFileState(incoming));
+        } else {
+          if (base) nextBase.set(relPath, base);
+          else nextBase.delete(relPath);
+          pendingLocal += 1;
+        }
         skipped += 1;
         continue;
       }
+      if (shouldPreferIncomingOfflineRuntimeFile(relPath) && currentEntry && base && incoming.sha256 === base.sha256) {
+        nextBase.set(relPath, base);
+        skipped += 1;
+        continue;
+      }
+      if (shouldPreferIncomingOfflineRuntimeFile(relPath)) {
+        await writeSafeFile(root, relPath, requiredBuffer(incomingBuffers, relPath), options.writeFile, incoming.mtimeMs);
+        nextBase.set(relPath, toFileState(incoming));
+        upserted += 1;
+        continue;
+      }
       if (!currentEntry && base && incoming.sha256 === base.sha256) {
         nextBase.set(relPath, base);
         pendingLocal += 1;
@@ -603,7 +789,7 @@ async function applyOfflineSyncSnapshot(options) {
           reason: "local_deleted_remote_modified",
           baseSha256: base.sha256,
           incomingSha256: incoming.sha256,
-          incomingBuffer: options.writeConflictCopies === false ? incomingBuffers.get(relPath) : requiredBuffer(incomingBuffers, relPath),
+          incomingBuffer: conflictIncomingBuffer(relPath),
           writeConflictCopies: options.writeConflictCopies !== false,
           sourceId: snapshot.sourceId,
           writeFile: options.writeFile
@@ -612,13 +798,13 @@ async function applyOfflineSyncSnapshot(options) {
         continue;
       }
       if (!currentEntry && !base) {
-        await writeSafeFile(root, relPath, requiredBuffer(incomingBuffers, relPath), options.writeFile);
+        await writeSafeFile(root, relPath, requiredBuffer(incomingBuffers, relPath), options.writeFile, incoming.mtimeMs);
         nextBase.set(relPath, toFileState(incoming));
         upserted += 1;
         continue;
       }
       if (base && currentEntry && currentEntry.sha256 === base.sha256) {
-        await writeSafeFile(root, relPath, requiredBuffer(incomingBuffers, relPath), options.writeFile);
+        await writeSafeFile(root, relPath, requiredBuffer(incomingBuffers, relPath), options.writeFile, incoming.mtimeMs);
         nextBase.set(relPath, toFileState(incoming));
         upserted += 1;
         continue;
@@ -636,7 +822,7 @@ async function applyOfflineSyncSnapshot(options) {
         baseSha256: base?.sha256,
         localSha256: currentEntry?.sha256,
         incomingSha256: incoming.sha256,
-        incomingBuffer: options.writeConflictCopies === false ? incomingBuffers.get(relPath) : requiredBuffer(incomingBuffers, relPath),
+        incomingBuffer: conflictIncomingBuffer(relPath),
         writeConflictCopies: options.writeConflictCopies !== false,
         sourceId: snapshot.sourceId,
         writeFile: options.writeFile
@@ -649,6 +835,17 @@ async function applyOfflineSyncSnapshot(options) {
       skipped += 1;
       continue;
     }
+    if (shouldPreferIncomingOfflineRuntimeFile(relPath) && base) {
+      await deleteSafeFile(root, relPath, options.deleteFile);
+      nextBase.delete(relPath);
+      deleted += 1;
+      continue;
+    }
+    if (shouldPreferIncomingOfflineRuntimeFile(relPath)) {
+      pendingLocal += 1;
+      skipped += 1;
+      continue;
+    }
     if (base && currentEntry.sha256 === base.sha256) {
       await deleteSafeFile(root, relPath, options.deleteFile);
       nextBase.delete(relPath);
@@ -690,14 +887,16 @@ async function applyOfflineSyncChangeset(options) {
   const root = await ensureSyncRoot(options.root, "applyOfflineSyncChangeset");
   const records = changeset.changes.filter((change) => change.type === "upsert").map((change) => change.file);
   const incomingBuffers = verifyRecordContents(records, "offline sync changeset");
-  const current = await buildOfflineSyncSnapshot({
+  const currentFiles = options.currentFiles ? filterBaseFilesForMode(normalizeFileStates(options.currentFiles), changeset.includeTranscripts).sort(compareByPath) : (await buildOfflineSyncSnapshotForPaths({
     root: root.abs,
     sourceId: "local",
+    paths: changeset.changes.map((change) => change.path),
     includeContent: false,
     includeTranscripts: changeset.includeTranscripts,
-    readFile: options.readFile
-  });
-  const currentMap = byPath(current.files);
+    readFile: options.readFile,
+    readFileDigest: options.readFileDigest
+  })).files;
+  const currentMap = byPath(currentFiles);
   const conflicts = [];
   let appliedUpserts = 0;
   let appliedDeletes = 0;
@@ -706,12 +905,18 @@ async function applyOfflineSyncChangeset(options) {
     const currentEntry = currentMap.get(change.path);
     if (change.type === "upsert") {
       if (currentEntry?.sha256 === change.file.sha256) {
-        skipped += 1;
+        if (await setSafeFileMtime(root, change.path, change.file.mtimeMs)) {
+          skipped += 1;
+        } else {
+          await writeSafeFile(root, change.path, requiredBuffer(incomingBuffers, change.path), options.writeFile, change.file.mtimeMs);
+          currentMap.set(change.path, toFileState(change.file));
+          appliedUpserts += 1;
+        }
         continue;
       }
       if (!change.baseSha256) {
         if (!currentEntry) {
-          await writeSafeFile(root, change.path, requiredBuffer(incomingBuffers, change.path), options.writeFile);
+          await writeSafeFile(root, change.path, requiredBuffer(incomingBuffers, change.path), options.writeFile, change.file.mtimeMs);
           currentMap.set(change.path, toFileState(change.file));
           appliedUpserts += 1;
           continue;
@@ -730,7 +935,7 @@ async function applyOfflineSyncChangeset(options) {
         continue;
       }
       if (currentEntry?.sha256 === change.baseSha256) {
-        await writeSafeFile(root, change.path, requiredBuffer(incomingBuffers, change.path), options.writeFile);
+        await writeSafeFile(root, change.path, requiredBuffer(incomingBuffers, change.path), options.writeFile, change.file.mtimeMs);
         currentMap.set(change.path, toFileState(change.file));
         appliedUpserts += 1;
         continue;
@@ -771,7 +976,15 @@ async function applyOfflineSyncChangeset(options) {
     appliedDeletes,
     skipped,
     conflicts,
-    currentFiles: [...currentMap.values()].sort(compareByPath)
+    currentFiles: options.returnCurrentFiles === false ? [...currentMap.values()].sort(compareByPath) : (await buildOfflineSyncSnapshot({
+      root: root.abs,
+      sourceId: "local",
+      includeContent: false,
+      includeTranscripts: changeset.includeTranscripts,
+      readFile: options.readFile,
+      readFileDigest: options.readFileDigest
+    })).files,
+    ...options.returnCurrentFiles === false ? { currentFilesComplete: false } : {}
   };
 }
 function verifyRecordContents(records, context, options = {}) {
@@ -826,10 +1039,11 @@ function toFileState(file) {
     mtimeMs: file.mtimeMs
   };
 }
-async function writeSafeFile(root, relPath, content, writeFileHook) {
+async function writeSafeFile(root, relPath, content, writeFileHook, mtimeMs) {
   const target = await resolveSafeArchiveTarget(root, relPath);
   if (writeFileHook) {
     await writeFileHook({ root: root.abs, path: relPath, filePath: target, content });
+    await setSafeFileMtime(root, relPath, mtimeMs);
     return;
   }
   await mkdir(path.dirname(target), { recursive: true });
@@ -847,12 +1061,28 @@ async function writeSafeFile(root, relPath, content, writeFileHook) {
       throw new Error(`offline sync target is a symlink: ${relPath}`);
     }
     await rename(tmp, target);
+    await setSafeFileMtime(root, relPath, mtimeMs);
   } catch (error) {
     await unlink(tmp).catch(() => {
     });
     throw error;
   }
 }
+async function setSafeFileMtime(root, relPath, mtimeMs) {
+  if (mtimeMs === void 0) return true;
+  const target = await resolveSafeArchiveTarget(root, relPath);
+  const targetStat = await lstat(target).catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (!targetStat) return false;
+  if (targetStat.isSymbolicLink()) {
+    throw new Error(`offline sync target is a symlink: ${relPath}`);
+  }
+  const mtime = new Date(assertOfflineSyncMtimeMs(mtimeMs, "mtimeMs"));
+  await utimes(target, mtime, mtime);
+  return true;
+}
 async function applyOfflineSyncFileContentChunk(options) {
   const root = await ensureSyncRoot(options.root, "applyOfflineSyncFileContentChunk");
   const sourceId = normalizeSourceId(options.sourceId, "sourceId");
@@ -863,9 +1093,10 @@ async function applyOfflineSyncFileContentChunk(options) {
   }
   const sha256 = assertSha256(options.sha256, "sha256");
   const bytes = assertNonNegativeInteger(options.bytes, "bytes");
-  const mtimeMs = assertNonNegativeFinite(options.mtimeMs, "mtimeMs");
+  const mtimeMs = assertOfflineSyncMtimeMs(options.mtimeMs, "mtimeMs");
   const offset = options.offset === void 0 ? 0 : assertNonNegativeInteger(options.offset, "offset");
   const baseSha256 = options.baseSha256 === void 0 ? void 0 : assertSha256(options.baseSha256, "baseSha256");
+  const preferIncomingRuntimeFile = shouldPreferIncomingOfflineRuntimeFile(relPath);
   if (!Buffer.isBuffer(options.content)) {
     throw new Error("content must be a Buffer");
   }
@@ -886,8 +1117,85 @@ async function applyOfflineSyncFileContentChunk(options) {
   if (options.writeFile && !options.writeStagingFile) {
     throw new Error("offline sync upload storage hooks require writeStagingFile");
   }
+  const baseResult = {
+    path: relPath,
+    sha256,
+    bytes,
+    mtimeMs,
+    offset,
+    chunkBytes: options.content.length,
+    done: offset + options.content.length === bytes
+  };
+  const currentFileConflict = async (currentFile2) => {
+    if (!baseSha256 && currentFile2 && !preferIncomingRuntimeFile) {
+      const conflict = await recordConflict({
+        root,
+        relPath,
+        reason: "remote_exists_for_local_create",
+        localSha256: currentFile2.sha256,
+        incomingSha256: sha256,
+        writeConflictCopies: false,
+        sourceId,
+        writeFile: options.writeFile
+      });
+      return {
+        conflict,
+        currentFile: currentFile2
+      };
+    }
+    if (baseSha256 && currentFile2?.sha256 !== baseSha256 && !preferIncomingRuntimeFile) {
+      const conflict = await recordConflict({
+        root,
+        relPath,
+        reason: currentFile2 ? "remote_changed_for_local_update" : "remote_deleted_for_local_update",
+        baseSha256,
+        localSha256: currentFile2?.sha256,
+        incomingSha256: sha256,
+        writeConflictCopies: false,
+        sourceId,
+        writeFile: options.writeFile
+      });
+      return {
+        conflict,
+        ...currentFile2 ? { currentFile: currentFile2 } : {}
+      };
+    }
+    return null;
+  };
   if (offset === 0) {
     await pruneOfflineUploadStaging(root);
+    const currentSnapshot2 = await buildOfflineSyncSnapshotForPaths({
+      root: root.abs,
+      sourceId: "local",
+      paths: [relPath],
+      includeContent: false,
+      includeTranscripts,
+      readFile: options.readFile,
+      readFileDigest: options.readFileDigest
+    });
+    const currentFile2 = currentSnapshot2.files[0];
+    if (currentFile2?.sha256 === sha256) {
+      await setSafeFileMtime(root, relPath, mtimeMs);
+      return {
+        ...baseResult,
+        done: true,
+        chunkBytes: 0,
+        applied: false,
+        skipped: true,
+        currentFile: toFileState(currentFile2)
+      };
+    }
+    const conflictResult = await currentFileConflict(currentFile2 ? toFileState(currentFile2) : void 0);
+    if (conflictResult) {
+      return {
+        ...baseResult,
+        done: true,
+        chunkBytes: 0,
+        applied: false,
+        skipped: false,
+        ...conflictResult
+      };
+    }
   }
   const upload = await writeOfflineUploadChunk({
     root,
@@ -901,16 +1209,7 @@ async function applyOfflineSyncFileContentChunk(options) {
     writeFile: options.writeFile,
     writeStagingFile: options.writeStagingFile
   });
-  const done = offset + options.content.length === bytes;
-  const baseResult = {
-    path: relPath,
-    sha256,
-    bytes,
-    mtimeMs,
-    offset,
-    chunkBytes: options.content.length,
-    done
-  };
+  const done = baseResult.done;
   if (!done) {
     return {
       ...baseResult,
@@ -934,7 +1233,8 @@ async function applyOfflineSyncFileContentChunk(options) {
     paths: [relPath],
     includeContent: false,
     includeTranscripts,
-    readFile: options.readFile
+    readFile: options.readFile,
+    readFileDigest: options.readFileDigest
   });
   const currentFile = currentSnapshot.files[0];
   const uploadedState = {
@@ -945,53 +1245,24 @@ async function applyOfflineSyncFileContentChunk(options) {
   };
   try {
     if (currentFile?.sha256 === sha256) {
+      await setSafeFileMtime(root, relPath, mtimeMs);
       return {
         ...baseResult,
         applied: false,
         skipped: true,
-        currentFile: toFileState(currentFile)
+        currentFile: uploadedState
       };
     }
-    if (!baseSha256 && currentFile) {
-      const conflict = await recordConflict({
-        root,
-        relPath,
-        reason: "remote_exists_for_local_create",
-        localSha256: currentFile.sha256,
-        incomingSha256: sha256,
-        writeConflictCopies: false,
-        sourceId,
-        writeFile: options.writeFile
-      });
+    const conflictResult = await currentFileConflict(currentFile ? toFileState(currentFile) : void 0);
+    if (conflictResult) {
       return {
         ...baseResult,
         applied: false,
         skipped: false,
-        conflict,
-        currentFile: toFileState(currentFile)
-      };
-    }
-    if (baseSha256 && currentFile?.sha256 !== baseSha256) {
-      const conflict = await recordConflict({
-        root,
-        relPath,
-        reason: currentFile ? "remote_changed_for_local_update" : "remote_deleted_for_local_update",
-        baseSha256,
-        localSha256: currentFile?.sha256,
-        incomingSha256: sha256,
-        writeConflictCopies: false,
-        sourceId,
-        writeFile: options.writeFile
-      });
-      return {
-        ...baseResult,
-        applied: false,
-        skipped: false,
-        conflict,
-        ...currentFile ? { currentFile: toFileState(currentFile) } : {}
+        ...conflictResult
       };
     }
-    await writeSafeFileFromUpload(root, relPath, upload, options.readFile, options.writeFileChunks);
+    await writeSafeFileFromUpload(root, relPath, upload, options.readFile, options.writeFileChunks, mtimeMs);
     return {
       ...baseResult,
       applied: true,
@@ -1137,11 +1408,12 @@ async function digestOfflineUploadStagingContent(options) {
   }
   return { sha256: hash.digest("hex"), bytes };
 }
-async function writeSafeFileFromUpload(root, relPath, upload, readFile2, writeFileChunks) {
+async function writeSafeFileFromUpload(root, relPath, upload, readFile2, writeFileChunks, mtimeMs) {
   const target = await resolveSafeArchiveTarget(root, relPath);
   const chunks = readOfflineUploadStagingChunks({ root, upload, readFile: readFile2 });
   if (writeFileChunks) {
     await writeFileChunks({ root: root.abs, path: relPath, filePath: target, chunks });
+    await setSafeFileMtime(root, relPath, mtimeMs);
     return;
   }
   await mkdir(path.dirname(target), { recursive: true });
@@ -1163,6 +1435,7 @@ async function writeSafeFileFromUpload(root, relPath, upload, readFile2, writeFi
       throw new Error(`offline sync target is a symlink: ${relPath}`);
     }
     await rename(tmp, target);
+    await setSafeFileMtime(root, relPath, mtimeMs);
   } catch (error) {
     await handle.close().catch(() => {
     });
@@ -1301,14 +1574,21 @@ export {
   OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
   OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES,
   OFFLINE_SYNC_APPLY_MAX_BODY_BYTES,
+  OFFLINE_SYNC_SNAPSHOT_BASE_MAX_BODY_BYTES,
+  OFFLINE_SYNC_MAX_MTIME_MS,
   normalizeOfflineSyncSnapshot,
   normalizeOfflineSyncChangeset,
+  shouldPreferIncomingOfflineRuntimeFile,
+  iterateOfflineSyncSnapshotFileRecords,
   buildOfflineSyncSnapshot,
+  buildOfflineSyncSnapshotFromBase,
   buildOfflineSyncSnapshotForPaths,
   readOfflineSyncFileContentChunk,
   buildOfflineSyncChangeset,
+  buildOfflineSyncChangesetFromSnapshot,
   summarizeOfflineSyncChangeset,
   summarizeOfflineSyncPendingChanges,
+  summarizeOfflineSyncPendingFiles,
   applyOfflineSyncSnapshot,
   applyOfflineSyncChangeset,
   applyOfflineSyncFileContentChunk,
@@ -1319,4 +1599,4 @@ export {
   normalizeOfflineSyncState,
   fileStatesFromSnapshot
 };
-//# sourceMappingURL=chunk-AMVN77EU.js.map
+//# sourceMappingURL=chunk-U7EJOMFC.js.map