@remnic/core 9.45.3 → 9.45.5

package/dist/{chunk-7XC2HX75.js → chunk-GYPQL6XN.js}

@@ -16,7 +16,7 @@ import {
 import {
   MAGIC_HEADER_SIZE,
   isEncryptedFile
-} from "./chunk-5TFP4CUL.js";
+} from "./chunk-XQ3HXAQH.js";
 
 // src/offline-sync.ts
 import { createHash, randomUUID } from "crypto";
@@ -175,6 +175,63 @@ function normalizeFileStates(input) {
   }
   return input.map((entry, index) => normalizeFileState(entry, `baseFiles[${index}]`));
 }
+function normalizeDeletionRevisions(input, fieldPrefix) {
+  if (input === void 0) return void 0;
+  if (!Array.isArray(input)) {
+    throw new Error(`${fieldPrefix} must be an array`);
+  }
+  const deletions = input.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`${fieldPrefix}[${index}] must be an object`);
+    }
+    const obj = entry;
+    return {
+      path: normalizeRelativePath(obj.path, `${fieldPrefix}[${index}].path`),
+      mtimeMs: assertOfflineSyncMtimeMs(obj.mtimeMs, `${fieldPrefix}[${index}].mtimeMs`)
+    };
+  });
+  assertUniquePaths(deletions, fieldPrefix);
+  return deletions.sort(compareByPath);
+}
+function snapshotBuilderDeletions(options) {
+  const deletions = normalizeDeletionRevisions(options.deletions, "deletions");
+  if (deletions === void 0) return void 0;
+  if (deletions.length === 0) return deletions;
+  const presentPaths = new Set(options.files.map((file) => file.path.toLowerCase()));
+  const scopedPaths = options.paths ? new Set(options.paths.map((relPath) => relPath.toLowerCase())) : void 0;
+  return deletions.filter((deletion) => (scopedPaths === void 0 || scopedPaths.has(deletion.path.toLowerCase())) && !presentPaths.has(deletion.path.toLowerCase()) && !(options.excludeNodeLocalState === false ? shouldExcludeRelPath(deletion.path, options.includeTranscripts) : shouldExcludePushRelPath(
+    deletion.path,
+    options.includeTranscripts,
+    options.userExcludeRegexps
+  )));
+}
+async function filterOfflineSyncDeletionRevisions(options) {
+  const deletions = normalizeDeletionRevisions(options.deletions, "deletions");
+  if (deletions === void 0) throw new Error("deletions must be an array");
+  if (deletions.length === 0) return deletions;
+  const root = await prepareSafeArchiveRoot(
+    path.resolve(options.root),
+    "filterOfflineSyncDeletionRevisions",
+    "root"
+  );
+  const includeTranscripts = options.includeTranscripts !== false;
+  const filtered = [];
+  for (const deletion of deletions) {
+    if (shouldExcludePushRelPath(deletion.path, includeTranscripts, options.userExcludeRegexps)) {
+      continue;
+    }
+    const filePath = path.join(root.abs, ...deletion.path.split("/"));
+    const present = await lstat(filePath).then(
+      () => true,
+      (error) => {
+        if (error.code === "ENOENT") return false;
+        throw error;
+      }
+    );
+    if (!present) filtered.push(deletion);
+  }
+  return filtered;
+}
 function normalizeOfflineSyncSnapshot(input, options = {}) {
   if (!input || typeof input !== "object" || Array.isArray(input)) {
     throw new Error("offline sync snapshot must be an object");
@@ -193,16 +250,18 @@ function normalizeOfflineSyncSnapshot(input, options = {}) {
     throw new Error("offline sync snapshot files must be an array");
   }
   const files = obj.files.map((entry, index) => normalizeFileRecord(entry, `files[${index}]`, options.requireContent === true)).filter((file) => !shouldIgnoreIncomingRuntimePath(file.path)).sort(compareByPath);
-  assertUniquePaths(files, "offline sync snapshot");
+  const deletions = normalizeDeletionRevisions(obj.deletions, "deletions")?.filter((deletion) => !shouldIgnoreIncomingRuntimePath(deletion.path));
+  const entries = deletions && deletions.length > 0 ? [...files, ...deletions] : files;
+  assertUniquePaths(entries, "offline sync snapshot");
   if (!includeTranscripts) {
-    const transcriptPath = files.find((file) => file.path.split("/")[0] === "transcripts")?.path;
+    const transcriptPath = entries.find((entry) => entry.path.split("/")[0] === "transcripts")?.path;
     if (transcriptPath) {
       throw new Error(
         `offline sync snapshot includeTranscripts is false but contains transcript path: ${transcriptPath}`
       );
     }
   }
-  const excludedPath = files.find((file) => shouldExcludeRelPath(file.path, true))?.path;
+  const excludedPath = entries.find((entry) => shouldExcludeRelPath(entry.path, true))?.path;
   if (excludedPath) {
     throw new Error(`offline sync snapshot contains excluded path: ${excludedPath}`);
   }
@@ -212,7 +271,8 @@ function normalizeOfflineSyncSnapshot(input, options = {}) {
     createdAt,
     sourceId,
     includeTranscripts,
-    files
+    files,
+    ...deletions === void 0 ? {} : { deletions }
   };
 }
 function normalizeOfflineSyncChangeset(input) {
@@ -257,10 +317,12 @@ function normalizeOfflineSyncChangeset(input) {
       };
     }
     if (type === "delete") {
+      const mtimeMs = change.mtimeMs === void 0 ? void 0 : assertOfflineSyncMtimeMs(change.mtimeMs, `changes[${index}].mtimeMs`);
       return {
         type: "delete",
         path: relPath,
-        baseSha256: assertSha256(change.baseSha256, `changes[${index}].baseSha256`)
+        baseSha256: assertSha256(change.baseSha256, `changes[${index}].baseSha256`),
+        ...mtimeMs === void 0 ? {} : { mtimeMs }
       };
     }
     throw new Error(`changes[${index}].type must be "upsert" or "delete"`);
@@ -313,7 +375,12 @@ function assertUniquePaths(entries, context) {
     seen.add(key);
   }
 }
+function isInternalRemnicStatePath(relPosix) {
+  const normalized = relPosix.includes("\\") ? relPosix.replaceAll("\\", "/") : relPosix;
+  return normalized === ".remnic" || normalized.startsWith(".remnic/") || normalized.endsWith("/.remnic") || normalized.includes("/.remnic/");
+}
 function shouldExcludeRelPath(relPosix, includeTranscripts) {
+  if (isInternalRemnicStatePath(relPosix)) return true;
   const parts = relPosix.split("/");
   if (parts.some((part) => DEFAULT_TRANSFER_EXCLUDE_DIRS.has(part))) return true;
   if (parts.some((part) => part === SYNC_INTERNAL_DIR)) return true;
@@ -366,6 +433,7 @@ function parseOfflineSyncExcludes(raw) {
   return globs;
 }
 function shouldIgnoreIncomingRuntimePath(relPosix) {
+  if (isInternalRemnicStatePath(relPosix)) return true;
   const parts = relPosix.split("/");
   const basename = parts[parts.length - 1] ?? "";
   return isCanonicalRuntimeStatePath(parts) && basename.includes(".tmp-");
@@ -521,13 +589,22 @@ async function buildOfflineSyncSnapshot(options) {
   const files = [];
   for await (const file of iterateOfflineSyncSnapshotFileRecords(options)) files.push(file);
   throwIfOfflineSyncAborted(options.signal);
+  const sortedFiles = files.sort(compareByPath);
+  const deletions = snapshotBuilderDeletions({
+    deletions: options.deletions,
+    files: sortedFiles,
+    includeTranscripts,
+    excludeNodeLocalState: options.excludeNodeLocalState,
+    userExcludeRegexps: options.userExcludeRegexps
+  });
   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)
+    files: sortedFiles,
+    ...deletions === void 0 ? {} : { deletions }
   };
 }
 async function buildOfflineSyncSnapshotFromBase(options) {
@@ -576,13 +653,22 @@ async function buildOfflineSyncSnapshotFromBase(options) {
   }
   await walk(root.abs);
   throwIfOfflineSyncAborted(options.signal);
+  const sortedFiles = files.sort(compareByPath);
+  const deletions = snapshotBuilderDeletions({
+    deletions: options.deletions,
+    files: sortedFiles,
+    includeTranscripts,
+    excludeNodeLocalState: options.excludeNodeLocalState,
+    userExcludeRegexps: options.userExcludeRegexps
+  });
   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)
+    files: sortedFiles,
+    ...deletions === void 0 ? {} : { deletions }
   };
 }
 async function buildOfflineSyncSnapshotForPaths(options) {
@@ -617,13 +703,23 @@ async function buildOfflineSyncSnapshotForPaths(options) {
     }));
   }
   throwIfOfflineSyncAborted(options.signal);
+  const sortedFiles = files.sort(compareByPath);
+  const deletions = snapshotBuilderDeletions({
+    deletions: options.deletions,
+    files: sortedFiles,
+    paths: [...seen],
+    includeTranscripts,
+    excludeNodeLocalState: options.excludeNodeLocalState,
+    userExcludeRegexps: options.userExcludeRegexps
+  });
   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)
+    files: sortedFiles,
+    ...deletions === void 0 ? {} : { deletions }
   };
 }
 async function readOfflineSyncFileContentChunk(options) {
@@ -695,6 +791,7 @@ async function buildOfflineSyncChangeset(options) {
     root: options.root,
     sourceId: options.sourceId,
     baseFiles: options.baseFiles,
+    deletions: options.deletions,
     baseCapturedAt: options.baseCapturedAt,
     includeContent: false,
     includeTranscripts,
@@ -708,6 +805,7 @@ async function buildOfflineSyncChangeset(options) {
     sourceId: options.sourceId,
     baseFiles: options.baseFiles,
     currentFiles: current.files,
+    deletions: current.deletions,
     excludePaths: options.excludePaths,
     includeTranscripts,
     now: options.now,
@@ -728,6 +826,8 @@ async function buildOfflineSyncChangesetFromSnapshot(options) {
     normalizeFileStates(options.currentFiles),
     includeTranscripts
   ));
+  const deletions = normalizeDeletionRevisions(options.deletions, "deletions");
+  const deletionMtimeByPath = deletions === void 0 ? void 0 : new Map(deletions.map((deletion) => [deletion.path, deletion.mtimeMs]));
   const changes = [];
   for (const relPath of unionPaths(base, currentMap)) {
     if (excludedPaths.has(relPath)) continue;
@@ -759,10 +859,12 @@ async function buildOfflineSyncChangesetFromSnapshot(options) {
       continue;
     }
     if (!currentEntry && baseEntry) {
+      const mtimeMs = deletionMtimeByPath?.get(relPath);
       changes.push({
         type: "delete",
         path: relPath,
-        baseSha256: baseEntry.sha256
+        baseSha256: baseEntry.sha256,
+        ...mtimeMs === void 0 ? {} : { mtimeMs }
       });
     }
   }
@@ -843,6 +945,7 @@ async function applyOfflineSyncSnapshot(options) {
     snapshot.includeTranscripts
   ));
   const incomingMap = byPath(snapshot.files);
+  const deletionMtimeByPath = snapshot.deletions === void 0 ? void 0 : new Map(snapshot.deletions.map((deletion) => [deletion.path, deletion.mtimeMs]));
   const incomingBuffers = verifyRecordContents(snapshot.files, "offline sync snapshot", {
     requireContent: false
   });
@@ -858,6 +961,19 @@ async function applyOfflineSyncSnapshot(options) {
   })).files;
   const currentMap = byPath(currentFiles);
   const deferredPaths = new Set(options.deferredPaths ?? []);
+  if (deletionMtimeByPath && options.recordDeletionRevision) {
+    for (const [relPath, mtimeMs] of deletionMtimeByPath) {
+      if (currentMap.has(relPath) || deferredPaths.has(relPath) || matchesOfflineSyncDefaultExclude(relPath)) {
+        continue;
+      }
+      await options.recordDeletionRevision({
+        root: root.abs,
+        path: relPath,
+        filePath: await resolveSafeArchiveTarget(root, relPath),
+        mtimeMs
+      });
+    }
+  }
   const nextBase = new Map(baseMap);
   const conflicts = [];
   let upserted = 0;
@@ -968,7 +1084,12 @@ async function applyOfflineSyncSnapshot(options) {
       continue;
     }
     if (shouldPreferIncomingOfflineRuntimeFile(relPath) && (base || shouldDeleteAbsentIncomingOfflineRuntimeFile(relPath))) {
-      await deleteSafeFile(root, relPath, options.deleteFile);
+      await deleteSafeFile(
+        root,
+        relPath,
+        options.deleteFile,
+        deletionMtimeByPath?.get(relPath)
+      );
       nextBase.delete(relPath);
       deleted += 1;
       continue;
@@ -979,7 +1100,12 @@ async function applyOfflineSyncSnapshot(options) {
       continue;
     }
     if (base && currentEntry.sha256 === base.sha256) {
-      await deleteSafeFile(root, relPath, options.deleteFile);
+      await deleteSafeFile(
+        root,
+        relPath,
+        options.deleteFile,
+        deletionMtimeByPath?.get(relPath)
+      );
       nextBase.delete(relPath);
       deleted += 1;
       continue;
@@ -1088,11 +1214,19 @@ async function applyOfflineSyncChangeset(options) {
       continue;
     }
     if (!currentEntry) {
+      if (change.mtimeMs !== void 0 && options.recordDeletionRevision) {
+        await options.recordDeletionRevision({
+          root: root.abs,
+          path: change.path,
+          filePath: await resolveSafeArchiveTarget(root, change.path),
+          mtimeMs: change.mtimeMs
+        });
+      }
       skipped += 1;
       continue;
     }
     if (currentEntry.sha256 === change.baseSha256) {
-      await deleteSafeFile(root, change.path, options.deleteFile);
+      await deleteSafeFile(root, change.path, options.deleteFile, change.mtimeMs);
       currentMap.delete(change.path);
       appliedDeletes += 1;
       continue;
@@ -1630,10 +1764,15 @@ async function writeOfflineUploadContent(options) {
     content: options.content
   });
 }
-async function deleteSafeFile(root, relPath, deleteFile) {
+async function deleteSafeFile(root, relPath, deleteFile, mtimeMs) {
   const target = await resolveSafeArchiveTarget(root, relPath);
   if (deleteFile) {
-    await deleteFile({ root: root.abs, path: relPath, filePath: target });
+    await deleteFile({
+      root: root.abs,
+      path: relPath,
+      filePath: target,
+      ...mtimeMs === void 0 ? {} : { mtimeMs }
+    });
     return;
   }
   await unlink(target).catch((error) => {
@@ -1735,8 +1874,10 @@ export {
   OFFLINE_SYNC_SNAPSHOT_BASE_MAX_BODY_BYTES,
   OFFLINE_SYNC_MAX_MTIME_MS,
   globToRegExp,
+  filterOfflineSyncDeletionRevisions,
   normalizeOfflineSyncSnapshot,
   normalizeOfflineSyncChangeset,
+  isInternalRemnicStatePath,
   compileOfflineSyncExcludeGlobs,
   parseOfflineSyncExcludes,
   shouldPreferIncomingOfflineRuntimeFile,
@@ -1760,4 +1901,4 @@ export {
   normalizeOfflineSyncState,
   fileStatesFromSnapshot
 };
-//# sourceMappingURL=chunk-7XC2HX75.js.map
+//# sourceMappingURL=chunk-GYPQL6XN.js.map