@remnic/core 9.69.86 → 9.69.88

package/dist/{chunk-UVYI6VIX.js → chunk-DQEMWVMT.js}

@@ -246,4 +246,4 @@ export {
   decryptCapsuleFile,
   decryptCapsuleFileInMemory
 };
-//# sourceMappingURL=chunk-UVYI6VIX.js.map
+//# sourceMappingURL=chunk-DQEMWVMT.js.map

package/dist/{chunk-DQISIT63.js → chunk-DZ42MDZE.js}

@@ -6,10 +6,10 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   gatewayTaskChainOptions
-} from "./chunk-ZTHGFTMW.js";
+} from "./chunk-TKC5LZ43.js";
 import {
   extractJsonCandidates
-} from "./chunk-RGMVMVMF.js";
+} from "./chunk-YBA52OKG.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -491,4 +491,4 @@ export {
   createVerdictCache,
   createDeferCountMap
 };
-//# sourceMappingURL=chunk-DQISIT63.js.map
+//# sourceMappingURL=chunk-DZ42MDZE.js.map

package/dist/{chunk-5ELENZTA.js → chunk-EDIH6X2P.js}

@@ -1,6 +1,6 @@
 import {
   isGenericRecallExcludedPath
-} from "./chunk-7G6WUOLB.js";
+} from "./chunk-66DKTOBY.js";
 import {
   normalizeProjectionPreview
 } from "./chunk-SCU65EZI.js";
@@ -209,4 +209,4 @@ export {
   browsePatternMatches,
   runMemoryBrowse
 };
-//# sourceMappingURL=chunk-5ELENZTA.js.map
+//# sourceMappingURL=chunk-EDIH6X2P.js.map

package/dist/{chunk-3BTFBQLO.js → chunk-EFHNFTWB.js}

@@ -1,15 +1,22 @@
+import {
+  resolveSafeArchiveTarget
+} from "./chunk-GCGJW34D.js";
+import {
+  isCensusMtimeMs
+} from "./chunk-LQWOFU6L.js";
 import {
   throwIfAborted
 } from "./chunk-BTTPKDIL.js";
 import {
   MAGIC_HEADER_SIZE,
   isEncryptedFile
-} from "./chunk-JN72EPOE.js";
+} from "./chunk-MAAL6OZV.js";
 
 // src/offline-sync-file-io.ts
 import { createHash } from "crypto";
 import { createReadStream } from "fs";
 import { open } from "fs/promises";
+import { lstat, utimes } from "fs/promises";
 async function shouldExcludeOfflineSyncFile(excludeFile, target) {
   return excludeFile ? await excludeFile(target) : false;
 }
@@ -54,12 +61,51 @@ async function plainFileDigest(filePath) {
   }
   return hash.digest("hex");
 }
+var SYNC_INTERNAL_DIR = ".offline-sync";
+var OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS = 1e3;
+function assertNonNegativeFinite(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new Error(`${field} must be a non-negative finite number`);
+  }
+  return value;
+}
+function assertOfflineSyncMtimeMs(value, field) {
+  const mtimeMs = assertNonNegativeFinite(value, field);
+  if (!isCensusMtimeMs(mtimeMs)) {
+    throw new Error(`${field} must be within JavaScript Date range`);
+  }
+  return mtimeMs;
+}
+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 targetMtimeMs = assertOfflineSyncMtimeMs(mtimeMs, "mtimeMs");
+  if (Math.abs(targetStat.mtimeMs - targetMtimeMs) <= OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS) {
+    return true;
+  }
+  const mtime = new Date(targetMtimeMs);
+  await utimes(target, mtime, mtime);
+  return true;
+}
 
 export {
   shouldExcludeOfflineSyncFile,
   sha256OfflineSyncFile,
   isEncryptedOfflineSyncFile,
   readPlainOfflineSyncFileChunk,
-  plainFileDigest
+  plainFileDigest,
+  SYNC_INTERNAL_DIR,
+  OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS,
+  assertNonNegativeFinite,
+  assertOfflineSyncMtimeMs,
+  setSafeFileMtime
 };
-//# sourceMappingURL=chunk-3BTFBQLO.js.map
+//# sourceMappingURL=chunk-EFHNFTWB.js.map

package/dist/chunk-EFHNFTWB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/offline-sync-file-io.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { createReadStream } from \"node:fs\";\nimport { open } from \"node:fs/promises\";\nimport { throwIfAborted } from \"./abort-error.js\";\nimport { MAGIC_HEADER_SIZE, isEncryptedFile } from \"./secure-store/secure-fs.js\";\n\nexport interface OfflineSyncFileTarget {\n  root: string;\n  path: string;\n  filePath: string;\n}\n\nexport type OfflineSyncExcludeFile = (target: OfflineSyncFileTarget) => boolean | Promise<boolean>;\nexport async function shouldExcludeOfflineSyncFile(\n  excludeFile: OfflineSyncExcludeFile | undefined,\n  target: OfflineSyncFileTarget\n): Promise<boolean> {\n  return excludeFile ? await excludeFile(target) : false;\n}\n\nexport async function sha256OfflineSyncFile(\n  filePath: string,\n  signal?: AbortSignal\n): Promise<{ sha256: string; bytes: number }> {\n  const hash = createHash(\"sha256\");\n  let bytes = 0;\n  for await (const chunk of createReadStream(filePath)) {\n    throwIfAborted(signal, \"offline sync request aborted\");\n    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);\n    hash.update(buffer);\n    bytes += buffer.length;\n  }\n  throwIfAborted(signal, \"offline sync request aborted\");\n  return { sha256: hash.digest(\"hex\"), bytes };\n}\n\nexport async function isEncryptedOfflineSyncFile(filePath: string): Promise<boolean> {\n  const handle = await open(filePath, \"r\");\n  try {\n    const header = Buffer.alloc(MAGIC_HEADER_SIZE);\n    const { bytesRead } = await handle.read(header, 0, header.length, 0);\n    return bytesRead >= MAGIC_HEADER_SIZE && isEncryptedFile(header);\n  } finally {\n    await handle.close();\n  }\n}\n\nexport async function readPlainOfflineSyncFileChunk(options: {\n  filePath: string;\n  offset: number;\n  length: number;\n  bytes: number;\n}): Promise<Buffer> {\n  const chunkBytes = Math.min(options.length, options.bytes - options.offset);\n  const chunk = Buffer.alloc(chunkBytes);\n  if (chunkBytes === 0) return chunk;\n  const handle = await open(options.filePath, \"r\");\n  try {\n    const { bytesRead } = await handle.read(chunk, 0, chunk.length, options.offset);\n    return bytesRead === chunk.length ? chunk : chunk.subarray(0, bytesRead);\n  } finally {\n    await handle.close();\n  }\n}\n\n/** Streamed whole-file sha256 for plain-file chunk reads — the value the\n * file-content response contract exposes as x-remnic-file-sha256. Deliberately\n * UNCACHED: identity keys like (path, size, mtimeMs) are spoofable (a rewrite\n * that preserves size and mtime would serve a stale digest, defeating the\n * uploader's verify-before-idempotent-skip check). One bounded-memory hash\n * pass per chunk request; content reads stay windowed. */\nexport async function plainFileDigest(filePath: string): Promise<string> {\n  const hash = createHash(\"sha256\");\n  for await (const piece of createReadStream(filePath)) {\n    hash.update(piece as Buffer);\n  }\n  return hash.digest(\"hex\");\n}\n\nimport { lstat, utimes } from \"node:fs/promises\";\nimport { isCensusMtimeMs } from \"./census-validation.js\";\nimport { resolveSafeArchiveTarget, type SafeArchiveRoot } from \"./transfer/fs-utils.js\";\n\n/** Sync-internal directory spooling partial uploads and coordination state. */\nexport const SYNC_INTERNAL_DIR = \".offline-sync\";\n\nexport const OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS = 1_000;\n\nexport function assertNonNegativeFinite(value: unknown, field: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value) || value < 0) {\n    throw new Error(`${field} must be a non-negative finite number`);\n  }\n  return value;\n}\n\nexport function assertOfflineSyncMtimeMs(value: unknown, field: string): number {\n  const mtimeMs = assertNonNegativeFinite(value, field);\n  if (!isCensusMtimeMs(mtimeMs)) {\n    throw new Error(`${field} must be within JavaScript Date range`);\n  }\n  return mtimeMs;\n}\n\nexport async function setSafeFileMtime(\n  root: SafeArchiveRoot,\n  relPath: string,\n  mtimeMs: number | undefined,\n): Promise<boolean> {\n  if (mtimeMs === undefined) return true;\n  const target = await resolveSafeArchiveTarget(root, relPath);\n  const targetStat = await lstat(target).catch((error: unknown) => {\n    if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return null;\n    throw error;\n  });\n  if (!targetStat) return false;\n  if (targetStat.isSymbolicLink()) {\n    throw new Error(`offline sync target is a symlink: ${relPath}`);\n  }\n  const targetMtimeMs = assertOfflineSyncMtimeMs(mtimeMs, \"mtimeMs\");\n  if (Math.abs(targetStat.mtimeMs - targetMtimeMs) <= OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS) {\n    return true;\n  }\n  const mtime = new Date(targetMtimeMs);\n  await utimes(target, mtime, mtime);\n  return true;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-C3QXITIP.js → chunk-EQUD7FP4.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-FEHIOYML.js";
 import {
   composeMemoryEnvelope
-} from "./chunk-GDYU6VF4.js";
+} from "./chunk-5AYUHSAU.js";
 import {
   displayErrorDetail
 } from "./chunk-RL6NEVXT.js";
@@ -1463,4 +1463,4 @@ export {
   serializeDecisionRecord,
   parseDecisionRecord
 };
-//# sourceMappingURL=chunk-C3QXITIP.js.map
+//# sourceMappingURL=chunk-EQUD7FP4.js.map

package/dist/chunk-ETUZFFPU.js

@@ -0,0 +1,218 @@
+import {
+  SYNC_INTERNAL_DIR,
+  setSafeFileMtime
+} from "./chunk-EFHNFTWB.js";
+import {
+  resolveSafeArchiveTarget
+} from "./chunk-GCGJW34D.js";
+
+// src/offline-sync-upload-staging.ts
+import { createHash, randomUUID } from "crypto";
+import { lstat, mkdir, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from "fs/promises";
+import path from "path";
+var OFFLINE_SYNC_UPLOAD_STAGING_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+function hashText(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function offlineUploadRelPath(options) {
+  const key = hashText([options.sourceId, options.relPath, options.sha256, String(options.bytes)].join("\0"));
+  return `${SYNC_INTERNAL_DIR}/uploads/${key}.part`;
+}
+async function offlineUploadPath(root, options) {
+  const relPath = offlineUploadRelPath(options);
+  return {
+    kind: "single",
+    relPath,
+    filePath: await resolveSafeArchiveTarget(root, relPath)
+  };
+}
+async function offlineUploadChunkPath(root, options) {
+  const uploadRelPath = offlineUploadRelPath(options);
+  const relPath = `${uploadRelPath}/${String(options.offset).padStart(20, "0")}.part`;
+  return {
+    kind: "chunks",
+    relPath,
+    filePath: await resolveSafeArchiveTarget(root, relPath)
+  };
+}
+async function writeOfflineUploadChunk(options) {
+  if ((options.writeFile || options.writeStagingFile) && !options.readFile) {
+    throw new Error("offline sync upload chunk storage hooks require readFile");
+  }
+  const uploadRoot = {
+    ...await offlineUploadPath(options.root, options),
+    kind: "chunks"
+  };
+  if (options.offset === 0) {
+    await rm(uploadRoot.filePath, { recursive: true, force: true }).catch(() => {
+    });
+  } else {
+    const existing = await stat(uploadRoot.filePath).catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (!existing || !existing.isDirectory()) {
+      throw new Error(`offline sync upload is missing initial chunk for ${options.relPath}`);
+    }
+  }
+  const chunk = await offlineUploadChunkPath(options.root, { ...options, offset: options.offset });
+  const writeStagingFile = options.writeStagingFile ?? options.writeFile;
+  if (writeStagingFile) {
+    await writeOfflineUploadContent({
+      root: options.root,
+      relPath: chunk.relPath,
+      filePath: chunk.filePath,
+      content: options.content,
+      writeFile: writeStagingFile
+    });
+    return uploadRoot;
+  }
+  await mkdir(path.dirname(chunk.filePath), { recursive: true });
+  const existingChunk = await lstat(chunk.filePath).catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (existingChunk?.isSymbolicLink()) {
+    throw new Error(`offline sync upload chunk is a symlink: ${chunk.relPath}`);
+  }
+  await writeFile(chunk.filePath, options.content, { mode: 384 });
+  return uploadRoot;
+}
+async function pruneOfflineUploadStaging(root) {
+  const uploadsRelPath = `${SYNC_INTERNAL_DIR}/uploads`;
+  const uploadsPath = await resolveSafeArchiveTarget(root, uploadsRelPath);
+  const entries = await readdir(uploadsPath, { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  });
+  const now = Date.now();
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (!/^[a-f0-9]{64}\.part$/i.test(entry.name)) return;
+      const relPath = `${uploadsRelPath}/${entry.name}`;
+      const filePath = await resolveSafeArchiveTarget(root, relPath);
+      const info = await lstat(filePath).catch((error) => {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      });
+      if (!info) return;
+      if (now - info.mtimeMs <= OFFLINE_SYNC_UPLOAD_STAGING_MAX_AGE_MS) return;
+      await rm(filePath, { recursive: true, force: true });
+    })
+  );
+}
+async function* readOfflineUploadStagingChunks(options) {
+  if (options.upload.kind === "single") {
+    yield await readOfflineUploadContent({
+      root: options.root,
+      relPath: options.upload.relPath,
+      filePath: options.upload.filePath,
+      readFile: options.readFile
+    });
+    return;
+  }
+  const entries = await readdir(options.upload.filePath);
+  const chunkNames = entries.filter((entry) => /^\d{20}\.part$/.test(entry)).sort();
+  if (chunkNames.length === 0) {
+    throw new Error(`offline sync upload is missing chunks for ${options.upload.relPath}`);
+  }
+  let expectedOffset = 0;
+  for (const chunkName of chunkNames) {
+    const offset = Number(chunkName.slice(0, 20));
+    if (!Number.isSafeInteger(offset) || offset !== expectedOffset) {
+      throw new Error(
+        `offline sync upload offset mismatch for ${options.upload.relPath}: expected ${expectedOffset}, got ${offset}`
+      );
+    }
+    const relPath = `${options.upload.relPath}/${chunkName}`;
+    const filePath = await resolveSafeArchiveTarget(options.root, relPath);
+    const content = await readOfflineUploadContent({
+      root: options.root,
+      relPath,
+      filePath,
+      readFile: options.readFile
+    });
+    expectedOffset += content.length;
+    yield content;
+  }
+}
+async function digestOfflineUploadStagingContent(options) {
+  const hash = createHash("sha256");
+  let bytes = 0;
+  for await (const chunk of readOfflineUploadStagingChunks(options)) {
+    hash.update(chunk);
+    bytes += chunk.length;
+  }
+  return { sha256: hash.digest("hex"), bytes };
+}
+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 });
+  const tmp = path.join(path.dirname(target), `.remnic-sync.${process.pid}.${randomUUID()}.tmp`);
+  const handle = await open(tmp, "w", 384);
+  try {
+    for await (const chunk of chunks) {
+      if (chunk.length > 0) await handle.write(chunk);
+    }
+    await handle.close();
+    const targetStat = await lstat(target).catch((error) => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (targetStat?.isSymbolicLink()) {
+      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(() => {
+    });
+    await unlink(tmp).catch(() => {
+    });
+    throw error;
+  }
+}
+async function cleanupOfflineUpload(upload) {
+  if (upload.kind === "chunks") {
+    await rm(upload.filePath, { recursive: true, force: true });
+    return;
+  }
+  await unlink(upload.filePath).catch((error) => {
+    if (error.code === "ENOENT") return;
+    throw error;
+  });
+}
+async function readOfflineUploadContent(options) {
+  if (options.readFile) {
+    return options.readFile({
+      root: options.root.abs,
+      path: options.relPath,
+      filePath: options.filePath
+    });
+  }
+  return readFile(options.filePath);
+}
+async function writeOfflineUploadContent(options) {
+  await options.writeFile({
+    root: options.root.abs,
+    path: options.relPath,
+    filePath: options.filePath,
+    content: options.content
+  });
+}
+
+export {
+  hashText,
+  writeOfflineUploadChunk,
+  pruneOfflineUploadStaging,
+  digestOfflineUploadStagingContent,
+  writeSafeFileFromUpload,
+  cleanupOfflineUpload
+};
+//# sourceMappingURL=chunk-ETUZFFPU.js.map

package/dist/chunk-ETUZFFPU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/offline-sync-upload-staging.ts"],"sourcesContent":["// Offline-sync upload staging: chunked upload spool under\n// `.offline-sync/uploads/` (issue #2033). Extracted from offline-sync.ts so\n// the god-file line-count ratchet does not grow; behavior is unchanged.\nimport { createHash, randomUUID } from \"node:crypto\";\nimport { lstat, mkdir, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { SYNC_INTERNAL_DIR, setSafeFileMtime } from \"./offline-sync-file-io.js\";\nimport type { OfflineSyncFileTarget } from \"./offline-sync-file-io.js\";\nimport type {\n  OfflineSyncFileStagingWriteTarget,\n  OfflineSyncFileWriteChunksTarget,\n  OfflineSyncFileWriteTarget,\n} from \"./offline-sync.js\";\nimport { type SafeArchiveRoot, resolveSafeArchiveTarget } from \"./transfer/fs-utils.js\";\n\nconst OFFLINE_SYNC_UPLOAD_STAGING_MAX_AGE_MS = 24 * 60 * 60 * 1000;\n\nexport function hashText(value: string): string {\n  return createHash(\"sha256\").update(value).digest(\"hex\");\n}\n\ninterface OfflineUploadStaging {\n  kind: \"single\" | \"chunks\";\n  relPath: string;\n  filePath: string;\n}\n\nfunction offlineUploadRelPath(options: {\n  sourceId: string;\n  relPath: string;\n  sha256: string;\n  bytes: number;\n}): string {\n  const key = hashText([options.sourceId, options.relPath, options.sha256, String(options.bytes)].join(\"\\0\"));\n  return `${SYNC_INTERNAL_DIR}/uploads/${key}.part`;\n}\n\nasync function offlineUploadPath(\n  root: SafeArchiveRoot,\n  options: {\n    sourceId: string;\n    relPath: string;\n    sha256: string;\n    bytes: number;\n  }\n): Promise<OfflineUploadStaging> {\n  const relPath = offlineUploadRelPath(options);\n  return {\n    kind: \"single\",\n    relPath,\n    filePath: await resolveSafeArchiveTarget(root, relPath),\n  };\n}\n\nasync function offlineUploadChunkPath(\n  root: SafeArchiveRoot,\n  options: {\n    sourceId: string;\n    relPath: string;\n    sha256: string;\n    bytes: number;\n    offset: number;\n  }\n): Promise<OfflineUploadStaging> {\n  const uploadRelPath = offlineUploadRelPath(options);\n  const relPath = `${uploadRelPath}/${String(options.offset).padStart(20, \"0\")}.part`;\n  return {\n    kind: \"chunks\",\n    relPath,\n    filePath: await resolveSafeArchiveTarget(root, relPath),\n  };\n}\n\nexport async function writeOfflineUploadChunk(options: {\n  root: SafeArchiveRoot;\n  sourceId: string;\n  relPath: string;\n  sha256: string;\n  bytes: number;\n  offset: number;\n  content: Buffer;\n  readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;\n  writeFile?: (target: OfflineSyncFileWriteTarget) => Promise<void>;\n  writeStagingFile?: (target: OfflineSyncFileStagingWriteTarget) => Promise<void>;\n}): Promise<OfflineUploadStaging> {\n  if ((options.writeFile || options.writeStagingFile) && !options.readFile) {\n    throw new Error(\"offline sync upload chunk storage hooks require readFile\");\n  }\n  const uploadRoot = {\n    ...(await offlineUploadPath(options.root, options)),\n    kind: \"chunks\" as const,\n  };\n  if (options.offset === 0) {\n    await rm(uploadRoot.filePath, { recursive: true, force: true }).catch(() => {});\n  } else {\n    const existing = await stat(uploadRoot.filePath).catch((error: unknown) => {\n      if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return null;\n      throw error;\n    });\n    if (!existing || !existing.isDirectory()) {\n      throw new Error(`offline sync upload is missing initial chunk for ${options.relPath}`);\n    }\n  }\n  const chunk = await offlineUploadChunkPath(options.root, { ...options, offset: options.offset });\n\n  const writeStagingFile = options.writeStagingFile ?? options.writeFile;\n  if (writeStagingFile) {\n    // Storage-backed services provide these hooks so secure-store deployments\n    // keep staged partial uploads encrypted at rest without mutating indexes.\n    await writeOfflineUploadContent({\n      root: options.root,\n      relPath: chunk.relPath,\n      filePath: chunk.filePath,\n      content: options.content,\n      writeFile: writeStagingFile,\n    });\n    return uploadRoot;\n  }\n\n  await mkdir(path.dirname(chunk.filePath), { recursive: true });\n  const existingChunk = await lstat(chunk.filePath).catch((error: unknown) => {\n    if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return null;\n    throw error;\n  });\n  if (existingChunk?.isSymbolicLink()) {\n    throw new Error(`offline sync upload chunk is a symlink: ${chunk.relPath}`);\n  }\n  await writeFile(chunk.filePath, options.content, { mode: 0o600 });\n  return uploadRoot;\n}\n\nexport async function pruneOfflineUploadStaging(root: SafeArchiveRoot): Promise<void> {\n  const uploadsRelPath = `${SYNC_INTERNAL_DIR}/uploads`;\n  const uploadsPath = await resolveSafeArchiveTarget(root, uploadsRelPath);\n  const entries = await readdir(uploadsPath, { withFileTypes: true }).catch((error: unknown) => {\n    if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return [];\n    throw error;\n  });\n  const now = Date.now();\n  await Promise.all(\n    entries.map(async (entry) => {\n      if (!/^[a-f0-9]{64}\\.part$/i.test(entry.name)) return;\n      const relPath = `${uploadsRelPath}/${entry.name}`;\n      const filePath = await resolveSafeArchiveTarget(root, relPath);\n      const info = await lstat(filePath).catch((error: unknown) => {\n        if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return null;\n        throw error;\n      });\n      if (!info) return;\n      if (now - info.mtimeMs <= OFFLINE_SYNC_UPLOAD_STAGING_MAX_AGE_MS) return;\n      await rm(filePath, { recursive: true, force: true });\n    })\n  );\n}\n\nasync function* readOfflineUploadStagingChunks(options: {\n  root: SafeArchiveRoot;\n  upload: OfflineUploadStaging;\n  readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;\n}): AsyncGenerator<Buffer> {\n  if (options.upload.kind === \"single\") {\n    yield await readOfflineUploadContent({\n      root: options.root,\n      relPath: options.upload.relPath,\n      filePath: options.upload.filePath,\n      readFile: options.readFile,\n    });\n    return;\n  }\n\n  const entries = await readdir(options.upload.filePath);\n  const chunkNames = entries.filter((entry) => /^\\d{20}\\.part$/.test(entry)).sort();\n  if (chunkNames.length === 0) {\n    throw new Error(`offline sync upload is missing chunks for ${options.upload.relPath}`);\n  }\n  let expectedOffset = 0;\n  for (const chunkName of chunkNames) {\n    const offset = Number(chunkName.slice(0, 20));\n    if (!Number.isSafeInteger(offset) || offset !== expectedOffset) {\n      throw new Error(\n        `offline sync upload offset mismatch for ${options.upload.relPath}: expected ${expectedOffset}, got ${offset}`\n      );\n    }\n    const relPath = `${options.upload.relPath}/${chunkName}`;\n    const filePath = await resolveSafeArchiveTarget(options.root, relPath);\n    const content = await readOfflineUploadContent({\n      root: options.root,\n      relPath,\n      filePath,\n      readFile: options.readFile,\n    });\n    expectedOffset += content.length;\n    yield content;\n  }\n}\n\nexport async function digestOfflineUploadStagingContent(options: {\n  root: SafeArchiveRoot;\n  upload: OfflineUploadStaging;\n  readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;\n}): Promise<{ sha256: string; bytes: number }> {\n  const hash = createHash(\"sha256\");\n  let bytes = 0;\n  for await (const chunk of readOfflineUploadStagingChunks(options)) {\n    hash.update(chunk);\n    bytes += chunk.length;\n  }\n  return { sha256: hash.digest(\"hex\"), bytes };\n}\n\nexport async function writeSafeFileFromUpload(\n  root: SafeArchiveRoot,\n  relPath: string,\n  upload: OfflineUploadStaging,\n  readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>,\n  writeFileChunks?: (target: OfflineSyncFileWriteChunksTarget) => Promise<void>,\n  mtimeMs?: number\n): Promise<void> {\n  const target = await resolveSafeArchiveTarget(root, relPath);\n  const chunks = readOfflineUploadStagingChunks({ root, upload, readFile });\n  if (writeFileChunks) {\n    await writeFileChunks({ root: root.abs, path: relPath, filePath: target, chunks });\n    await setSafeFileMtime(root, relPath, mtimeMs);\n    return;\n  }\n\n  await mkdir(path.dirname(target), { recursive: true });\n  const tmp = path.join(path.dirname(target), `.remnic-sync.${process.pid}.${randomUUID()}.tmp`);\n  const handle = await open(tmp, \"w\", 0o600);\n  try {\n    for await (const chunk of chunks) {\n      if (chunk.length > 0) await handle.write(chunk);\n    }\n    await handle.close();\n    const targetStat = await lstat(target).catch((error: unknown) => {\n      if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return null;\n      throw error;\n    });\n    if (targetStat?.isSymbolicLink()) {\n      throw new Error(`offline sync target is a symlink: ${relPath}`);\n    }\n    await rename(tmp, target);\n    await setSafeFileMtime(root, relPath, mtimeMs);\n  } catch (error) {\n    await handle.close().catch(() => {});\n    await unlink(tmp).catch(() => {});\n    throw error;\n  }\n}\n\nexport async function cleanupOfflineUpload(upload: OfflineUploadStaging): Promise<void> {\n  if (upload.kind === \"chunks\") {\n    await rm(upload.filePath, { recursive: true, force: true });\n    return;\n  }\n  await unlink(upload.filePath).catch((error: unknown) => {\n    if ((error as NodeJS.ErrnoException).code === \"ENOENT\") return;\n    throw error;\n  });\n}\n\nasync function readOfflineUploadContent(options: {\n  root: SafeArchiveRoot;\n  relPath: string;\n  filePath: string;\n  readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;\n}): Promise<Buffer> {\n  if (options.readFile) {\n    return options.readFile({\n      root: options.root.abs,\n      path: options.relPath,\n      filePath: options.filePath,\n    });\n  }\n  return readFile(options.filePath);\n}\n\nasync function writeOfflineUploadContent(options: {\n  root: SafeArchiveRoot;\n  relPath: string;\n  filePath: string;\n  content: Buffer;\n  writeFile: (target: OfflineSyncFileWriteTarget) => Promise<void>;\n}): Promise<void> {\n  await options.writeFile({\n    root: options.root.abs,\n    path: options.relPath,\n    filePath: options.filePath,\n    content: options.content,\n  });\n}\n"],"mappings":"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","names":["readFile"]}

package/dist/{chunk-YNDLCWXS.js → chunk-EZ25VE3G.js}

@@ -1,9 +1,9 @@
-import {
-  diffGraphSnapshots
-} from "./chunk-AUDJPF4N.js";
 import {
   graphSnapshotFromMemoryDir
 } from "./chunk-44442YCH.js";
+import {
+  diffGraphSnapshots
+} from "./chunk-AUDJPF4N.js";
 
 // src/dashboard-runtime.ts
 import { createHash, timingSafeEqual } from "crypto";
@@ -370,4 +370,4 @@ var GraphDashboardServer = class {
 export {
   GraphDashboardServer
 };
-//# sourceMappingURL=chunk-YNDLCWXS.js.map
+//# sourceMappingURL=chunk-EZ25VE3G.js.map

package/dist/{chunk-IA3X2Y4K.js → chunk-FJLQXMTU.js}

@@ -1,9 +1,9 @@
 import {
   StorageManager
-} from "./chunk-S55WTPFJ.js";
+} from "./chunk-STEOT4DI.js";
 import {
   composeMemoryEnvelope
-} from "./chunk-GDYU6VF4.js";
+} from "./chunk-5AYUHSAU.js";
 import {
   isErrnoCode
 } from "./chunk-KNA3BXXL.js";
@@ -546,4 +546,4 @@ export {
   setSemanticRulePromotionTestHooks,
   promoteSemanticRuleFromMemory
 };
-//# sourceMappingURL=chunk-IA3X2Y4K.js.map
+//# sourceMappingURL=chunk-FJLQXMTU.js.map

package/dist/{chunk-TY446V34.js → chunk-FKD656D2.js}

@@ -1,7 +1,7 @@
 import {
   canonicalCategoryForAlias,
   categoryAliasCoercion
-} from "./chunk-IBGEHKQ6.js";
+} from "./chunk-LW3HKRL7.js";
 
 // src/access-observe-write-category.ts
 function splitCanonicalWriteRequest(request) {
@@ -22,4 +22,4 @@ function splitCanonicalWriteRequest(request) {
 export {
   splitCanonicalWriteRequest
 };
-//# sourceMappingURL=chunk-TY446V34.js.map
+//# sourceMappingURL=chunk-FKD656D2.js.map

package/dist/{chunk-CLXTDOKV.js → chunk-FUNBJQYR.js}

@@ -1,6 +1,6 @@
 import {
   gatherConsoleState
-} from "./chunk-G6SVZWPB.js";
+} from "./chunk-PZX3AQLF.js";
 
 // src/console/tui.ts
 var ANSI_CLEAR_HOME = "\x1B[2J\x1B[H";
@@ -242,4 +242,4 @@ export {
   renderFrame,
   stripAnsi
 };
-//# sourceMappingURL=chunk-CLXTDOKV.js.map
+//# sourceMappingURL=chunk-FUNBJQYR.js.map

package/dist/{chunk-CLSYE5OZ.js → chunk-G2STTRYB.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-345MEMRU.js";
 import {
   MAGIC_BYTES
-} from "./chunk-JN72EPOE.js";
+} from "./chunk-MAAL6OZV.js";
 
 // src/okf/lint.ts
 import fs from "fs";
@@ -202,4 +202,4 @@ export {
   publishBundle,
   rejectSymlinkPath
 };
-//# sourceMappingURL=chunk-CLSYE5OZ.js.map
+//# sourceMappingURL=chunk-G2STTRYB.js.map

package/dist/{chunk-SQDKX4RW.js → chunk-GWM6T5EQ.js}

@@ -1,6 +1,6 @@
 import {
   isNamespaceKind
-} from "./chunk-WB2I2EQK.js";
+} from "./chunk-P2ODTYOF.js";
 import {
   EngramAccessInputError
 } from "./chunk-3MUKQQ7A.js";
@@ -40,4 +40,4 @@ export {
   positiveIntQueryParam,
   optionalNamespaceKindQueryParam
 };
-//# sourceMappingURL=chunk-SQDKX4RW.js.map
+//# sourceMappingURL=chunk-GWM6T5EQ.js.map

package/dist/{chunk-AXDOF4VI.js → chunk-GZDTVYK2.js}

@@ -1,6 +1,6 @@
 import {
   resolveCorpusNamespaceRoots
-} from "./chunk-CRKWSSS4.js";
+} from "./chunk-5MNUBT7T.js";
 import {
   capabilityAllowsNamespace
 } from "./chunk-IG747LRN.js";
@@ -200,4 +200,4 @@ async function readAggregateExtractionWatermark(options) {
 export {
   readAggregateExtractionWatermark
 };
-//# sourceMappingURL=chunk-AXDOF4VI.js.map
+//# sourceMappingURL=chunk-GZDTVYK2.js.map

package/dist/{chunk-55FCXCXJ.js → chunk-H56VY4BY.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-62OKGIJA.js";
 import {
   parseActivityConfig
-} from "./chunk-QOPB6KE3.js";
+} from "./chunk-3TB2XQ3C.js";
 import {
   parseLocationConfig
 } from "./chunk-QNJQCLI6.js";
@@ -15,10 +15,10 @@ import {
   PRE_ACTION_GATE_DEFAULT_TIMEOUT_MS,
   normalizeActionIntent,
   sanitizePayloadString
-} from "./chunk-QWUJWBZ5.js";
+} from "./chunk-Z3O53WZR.js";
 import {
   parseSubjectRuntimeConfig
-} from "./chunk-WIKO4SCR.js";
+} from "./chunk-LHRQBMJN.js";
 import {
   parseRecallStandingBlock,
   parseStandingBlockFreshDays,
@@ -46,7 +46,7 @@ import {
 } from "./chunk-H4WG3UQZ.js";
 import {
   parseExtractionFields
-} from "./chunk-OEBLZZKK.js";
+} from "./chunk-7XG7KMIW.js";
 import {
   parseExternalWikiRoots
 } from "./chunk-NDNTNE3S.js";
@@ -129,7 +129,7 @@ import {
 } from "./chunk-PQVCH2AE.js";
 import {
   STRUCTURED_ATTRIBUTE_LIMITS
-} from "./chunk-GDYU6VF4.js";
+} from "./chunk-5AYUHSAU.js";
 import {
   parseConvergeConfig
 } from "./chunk-6MINUTGJ.js";
@@ -138,7 +138,7 @@ import {
 } from "./chunk-7RJUVTVF.js";
 import {
   parseOfflineSyncExcludes
-} from "./chunk-WQZZDN5M.js";
+} from "./chunk-4NSLQ7EU.js";
 import {
   excludeSupportPassportPrivateMemories
 } from "./chunk-PWPIERBM.js";
@@ -5510,4 +5510,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-55FCXCXJ.js.map
+//# sourceMappingURL=chunk-H56VY4BY.js.map

package/dist/{chunk-OM5BIPBR.js → chunk-H5BJWPUI.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-KJTKLXTH.js";
 import {
   StorageManager
-} from "./chunk-S55WTPFJ.js";
+} from "./chunk-STEOT4DI.js";
 import {
   assertInjectedStorageRooted
-} from "./chunk-JE334SIA.js";
+} from "./chunk-22DYJLFN.js";
 import {
   MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS,
   buildLifecycleEventsForMemory,
@@ -28,7 +28,7 @@ import {
 } from "./chunk-FFAZ2XFU.js";
 import {
   probeEncryptedRegularFileHeader
-} from "./chunk-JN72EPOE.js";
+} from "./chunk-MAAL6OZV.js";
 import {
   isErrnoCode
 } from "./chunk-KNA3BXXL.js";
@@ -260,4 +260,4 @@ export {
   backupExistingLedger,
   rebuildMemoryLifecycleLedger
 };
-//# sourceMappingURL=chunk-OM5BIPBR.js.map
+//# sourceMappingURL=chunk-H5BJWPUI.js.map

package/dist/{chunk-7QK5TUTW.js → chunk-HLB7GKGG.js}

@@ -1,7 +1,7 @@
 import {
   SupportPassportError,
   getOperation
-} from "./chunk-SVZWVZ7E.js";
+} from "./chunk-QB57WIS6.js";
 import {
   abortError,
   isAbortError
@@ -499,4 +499,4 @@ export {
   buildSupportPassportPublicRequestHandler,
   composeSupportPassportExternalRequestHandlers
 };
-//# sourceMappingURL=chunk-7QK5TUTW.js.map
+//# sourceMappingURL=chunk-HLB7GKGG.js.map

package/dist/{chunk-CHDGJJV6.js → chunk-HWLIMQE2.js}

@@ -1,6 +1,6 @@
 import {
   readAllEdges
-} from "./chunk-2U3R3DDH.js";
+} from "./chunk-5FAGCOZD.js";
 import {
   readEdgeConfidence
 } from "./chunk-2LSZVONP.js";
@@ -162,4 +162,4 @@ export {
   parseGraphSnapshotSince,
   buildGraphSnapshot
 };
-//# sourceMappingURL=chunk-CHDGJJV6.js.map
+//# sourceMappingURL=chunk-HWLIMQE2.js.map