@remnic/core 9.69.87 → 9.69.89

package/dist/{chunk-6NQ4LSMS.js → chunk-MGZMC6WN.js}

@@ -13,16 +13,13 @@ import {
 import {
   importSqlite
 } from "./chunk-PYHOAXTI.js";
-import {
-  backupMemoryDir
-} from "./chunk-2NLLXCJG.js";
 import {
   exportJsonBundle
 } from "./chunk-UP6MOYCB.js";
 import {
   exportOkfBundle,
   parseIncludeStatus
-} from "./chunk-EHS5MJEF.js";
+} from "./chunk-KTKHO3UI.js";
 import {
   exportSqlite
 } from "./chunk-BV2TIZ4F.js";
@@ -32,12 +29,12 @@ import {
 import {
   importJsonBundle
 } from "./chunk-2DL3OFLD.js";
+import {
+  backupMemoryDir
+} from "./chunk-OWHERGF2.js";
 import {
   exportMarkdownBundle
 } from "./chunk-765K3SAT.js";
-import {
-  RoutingRulesStore
-} from "./chunk-TBUEE7XF.js";
 import {
   buildReplayNormalizerRegistry,
   clampBatchSize,
@@ -47,6 +44,9 @@ import {
   isReplaySource,
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
+import {
+  RoutingRulesStore
+} from "./chunk-TBUEE7XF.js";
 import {
   TailscaleHelper
 } from "./chunk-SZDLX763.js";
@@ -58,16 +58,13 @@ import {
 } from "./chunk-IIFFC3RL.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-L6UZEAID.js";
+} from "./chunk-NJVR724O.js";
 import {
   rebuildObservations
 } from "./chunk-DQTCGVFK.js";
 import {
   archiveObservations
 } from "./chunk-YLBE6PLR.js";
-import {
-  runCompatChecks
-} from "./chunk-2524MOWK.js";
 import {
   getBulkImportSource,
   listBulkImportSources,
@@ -76,10 +73,13 @@ import {
 } from "./chunk-HSSERO3E.js";
 import {
   lintOkfDir
-} from "./chunk-CLSYE5OZ.js";
+} from "./chunk-G2STTRYB.js";
+import {
+  runCompatChecks
+} from "./chunk-2524MOWK.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-JKMHZF3Q.js";
+} from "./chunk-YSWJXOOL.js";
 import {
   getUtilityLearningStatus,
   learnUtilityPromotionWeights
@@ -93,15 +93,15 @@ import {
 } from "./chunk-OJP3N7UK.js";
 import {
   promoteSemanticRuleFromMemory
-} from "./chunk-EQ6YOIKO.js";
+} from "./chunk-ST2RQUXC.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-LS3XH3UE.js";
+} from "./chunk-IYIBGSHJ.js";
 import {
   buildResumeBundleFromState,
   getResumeBundleStatus,
   recordResumeBundle
-} from "./chunk-SY5KDWGU.js";
+} from "./chunk-2WLMWP2T.js";
 import {
   getWorkProductLedgerStatus,
   recordWorkProductLedgerEntry,
@@ -113,10 +113,6 @@ import {
 import {
   parseXrayCliOptions
 } from "./chunk-DBYAY6UW.js";
-import {
-  readRuntimePolicySnapshot,
-  sanitizeRuntimePolicyValues
-} from "./chunk-2LA3H54D.js";
 import {
   formatNamespaceMaintenanceHealthText,
   runBenchmarkRecall,
@@ -125,7 +121,7 @@ import {
   runOperatorInventory,
   runOperatorRepair,
   runOperatorSetup
-} from "./chunk-4IIMMZZK.js";
+} from "./chunk-PULDSMCJ.js";
 import {
   analyzeSessionIntegrity,
   applySessionRepair,
@@ -140,6 +136,10 @@ import {
   renderPatternExplain,
   renderPatternsList
 } from "./chunk-3T74IZB3.js";
+import {
+  readRuntimePolicySnapshot,
+  sanitizeRuntimePolicyValues
+} from "./chunk-2LA3H54D.js";
 import {
   GITHUB_CONNECTOR_ID,
   GMAIL_CONNECTOR_ID,
@@ -171,12 +171,12 @@ import {
 } from "./chunk-4IHBN6WU.js";
 import {
   GraphDashboardServer
-} from "./chunk-YNDLCWXS.js";
+} from "./chunk-EZ25VE3G.js";
 import {
   rebuildMemoryProjection,
   repairMemoryProjection,
   verifyMemoryProjection
-} from "./chunk-VX6GCKBS.js";
+} from "./chunk-7WBSMXGC.js";
 import {
   buildConnectorRowsFromDefinitions,
   parseConnectorsListOptions,
@@ -197,7 +197,7 @@ import {
 } from "./chunk-6TBIWIAG.js";
 import {
   parseConfig
-} from "./chunk-3GQC3NMB.js";
+} from "./chunk-H56VY4BY.js";
 import {
   applyManagedRegion,
   expandVaultTemplateTokens,
@@ -210,7 +210,7 @@ import {
 import {
   EngramAccessHttpServer,
   MeetingsInputError
-} from "./chunk-LF5IGOOD.js";
+} from "./chunk-JYM4Y6SO.js";
 import {
   WearablesInputError
 } from "./chunk-V7IZKJI3.js";
@@ -220,10 +220,10 @@ import {
   loadChatSession,
   processChatMessage,
   sessionBelongsToPrincipal
-} from "./chunk-CWHV574S.js";
+} from "./chunk-JUT3OR2L.js";
 import {
   EngramAccessService
-} from "./chunk-FOH7AMMI.js";
+} from "./chunk-CALBQ2NG.js";
 import {
   WorkStorage
 } from "./chunk-MPC7TYTZ.js";
@@ -243,7 +243,7 @@ import {
 } from "./chunk-KN6CIN7I.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-UA5DX5C3.js";
+} from "./chunk-AZIOEOK4.js";
 import {
   getObjectiveStateStoreStatus
 } from "./chunk-HM7RHKS4.js";
@@ -252,7 +252,7 @@ import {
 } from "./chunk-66DKTOBY.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-DZ525SNQ.js";
+} from "./chunk-7QE46QXI.js";
 import {
   getCueAnchorStoreStatus
 } from "./chunk-BMWN7B3Y.js";
@@ -261,18 +261,18 @@ import {
   readMemoryGovernanceRunArtifact,
   restoreMemoryGovernanceRun,
   runMemoryGovernance
-} from "./chunk-VLLD4TOB.js";
+} from "./chunk-NMZVDRVP.js";
 import {
   listNamespaces,
   runNamespaceMigration,
   verifyNamespaces
-} from "./chunk-JGSQ6P4D.js";
+} from "./chunk-2FX374UI.js";
 import {
   resolveNamespaceChildRoot
 } from "./chunk-3UXOZBHV.js";
 import {
   analyzeGraphHealth
-} from "./chunk-ICZQG4XE.js";
+} from "./chunk-5FAGCOZD.js";
 import {
   hostSecretRefResolver,
   loadHostSecretRefResolver,
@@ -300,10 +300,10 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   getCausalTrajectoryStoreStatus
-} from "./chunk-N4S4NUX5.js";
+} from "./chunk-B3O3IRZN.js";
 import {
   meetingIdDate
-} from "./chunk-FRCESVV6.js";
+} from "./chunk-4HUCP4R4.js";
 import {
   isValidTranscriptDate
 } from "./chunk-UHVXE24Y.js";
@@ -330,7 +330,7 @@ import {
 } from "./chunk-353C5UNV.js";
 import {
   composeMemoryEnvelope
-} from "./chunk-GDYU6VF4.js";
+} from "./chunk-5AYUHSAU.js";
 import {
   buildActionConfidenceInputFromOptions,
   evaluateActionConfidence,
@@ -338,7 +338,7 @@ import {
 } from "./chunk-Z2YFLXHU.js";
 import {
   STATE_FILE_MAX_DECRYPT_BYTES
-} from "./chunk-JE334SIA.js";
+} from "./chunk-22DYJLFN.js";
 import {
   inferMemoryStatus,
   isArchivedMemoryPath,
@@ -391,7 +391,7 @@ import {
 import {
   SECURE_STORE_ENVELOPE_OVERHEAD_BYTES,
   probeEncryptedRegularFileHeader
-} from "./chunk-JN72EPOE.js";
+} from "./chunk-MAAL6OZV.js";
 import {
   RECALL_FALLBACK_DIRS
 } from "./chunk-VS2IYZRU.js";
@@ -6698,7 +6698,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           }
         }
         if (sourceArchive.endsWith(".enc")) {
-          const { isEncryptedCapsuleFile } = await import("./capsule-crypto-7FJQINUR.js");
+          const { isEncryptedCapsuleFile } = await import("./capsule-crypto-GWVG7LGC.js");
           const encDetected = await isEncryptedCapsuleFile(sourceArchive).catch(() => true);
           if (encDetected) {
             throw new Error(
@@ -6706,7 +6706,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
             );
           }
         }
-        const { mergeCapsule } = await import("./capsule-merge-3MNURAQ3.js");
+        const { mergeCapsule } = await import("./capsule-merge-ZCXUPLNJ.js");
         const result = await mergeCapsule({
           sourceArchive,
           targetRoot: memoryDir,
@@ -6861,7 +6861,7 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           const { parseExportBundle } = await import("./transfer/types.js");
           let decryptedBuf;
           try {
-            const { decryptCapsuleFileInMemory } = await import("./capsule-crypto-7FJQINUR.js");
+            const { decryptCapsuleFileInMemory } = await import("./capsule-crypto-GWVG7LGC.js");
             decryptedBuf = await decryptCapsuleFileInMemory(archivePath, memoryDir);
           } catch (decErr) {
             const msg = decErr instanceof Error ? decErr.message : String(decErr);
@@ -9351,7 +9351,7 @@ Semantic consolidation complete. clusters=${result.clustersFound}, consolidated=
           console.error("--verb is required. Must be one of: keep-a, keep-b, merge, both-valid, needs-more-context");
           process.exit(1);
         }
-        const { isValidResolutionVerb, executeResolution } = await import("./resolution-DNX7FO7A.js");
+        const { isValidResolutionVerb, executeResolution } = await import("./resolution-K4A3VPKZ.js");
         if (!isValidResolutionVerb(verb)) {
           console.error(`Invalid verb: ${verb}. Must be one of: keep-a, keep-b, merge, both-valid, needs-more-context`);
           process.exit(1);
@@ -9903,13 +9903,13 @@ Legacy identity-anchor files are untouched. Verify the migration result`);
       ).action(async (...args) => {
         const options = args[0] ?? {};
         if (options.stateOnly === true) {
-          const { gatherConsoleState } = await import("./state-ITXJKXRE.js");
+          const { gatherConsoleState } = await import("./state-JB47KHYV.js");
           const snapshot = await gatherConsoleState(orchestrator);
           console.log(JSON.stringify(snapshot, null, 2));
           return;
         }
         if (typeof options.trace === "string" && options.trace.length > 0) {
-          const { replayTrace, parseSpeedFlag } = await import("./trace-ZFVRH4GO.js");
+          const { replayTrace, parseSpeedFlag } = await import("./trace-LXXCMZJA.js");
           const { expandTildePath: expandTildePath2 } = await import("./utils/path.js");
           const tracePath = expandTildePath2(options.trace);
           let speed;
@@ -9937,10 +9937,10 @@ Legacy identity-anchor files are untouched. Verify the migration result`);
           }
           return;
         }
-        const { runConsoleTui } = await import("./tui-55UJMJX7.js");
+        const { runConsoleTui } = await import("./tui-2Z5WOV7L.js");
         let recorder = null;
         if (typeof options.recordTrace === "string" && options.recordTrace.length > 0) {
-          const { openTraceRecorder } = await import("./trace-ZFVRH4GO.js");
+          const { openTraceRecorder } = await import("./trace-LXXCMZJA.js");
           const { expandTildePath: expandTildePath2 } = await import("./utils/path.js");
           recorder = await openTraceRecorder(
             expandTildePath2(options.recordTrace)
@@ -9954,7 +9954,7 @@ Legacy identity-anchor files are untouched. Verify the migration result`);
         } finally {
           if (recorder) {
             const CLOSE_TIMEOUT_MS = 2e3;
-            const { flushWithTimeout } = await import("./trace-ZFVRH4GO.js");
+            const { flushWithTimeout } = await import("./trace-LXXCMZJA.js");
             const flushResult = await flushWithTimeout(
               (signal) => recorder.close(signal),
               CLOSE_TIMEOUT_MS
@@ -10136,4 +10136,4 @@ export {
   listMemoryMarkdownFilePaths,
   registerCli
 };
-//# sourceMappingURL=chunk-6NQ4LSMS.js.map
+//# sourceMappingURL=chunk-MGZMC6WN.js.map

package/dist/chunk-MSAI3Q7D.js

@@ -0,0 +1,372 @@
+import {
+  EMBEDDING_SHARD_DIR_BASENAME,
+  applyEmbeddingGenerationRemoval,
+  applyEmbeddingGenerationTransaction,
+  embeddingGenerationMembership,
+  embeddingShardDirOf,
+  isEmbeddingGenerationDirPath
+} from "./chunk-AXGJMDBS.js";
+import {
+  EMBEDDING_SHARD_FILE_PATTERN
+} from "./chunk-TYT4TEQV.js";
+import {
+  resolveSafeArchiveTarget
+} from "./chunk-GCGJW34D.js";
+import {
+  EmbeddingIndexStorageError
+} from "./chunk-UCPGOUDZ.js";
+
+// src/offline-sync-changeset-generations.ts
+import { lstat, readdir } from "fs/promises";
+var EMBEDDING_MARKER_BASENAME = "embeddings.json";
+async function pathExists(absPath) {
+  try {
+    await lstat(absPath);
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+var SHA256_PATTERN = /^[0-9a-f]{64}$/;
+function normalizeChangesetGenerations(raw, changes) {
+  if (raw === void 0) return void 0;
+  if (!Array.isArray(raw)) {
+    throw new Error("offline sync changeset embeddingGenerations must be an array");
+  }
+  const dirs = /* @__PURE__ */ new Set();
+  const generations = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error("offline sync changeset embeddingGenerations entries must be objects");
+    }
+    const record = entry;
+    const shardDir = typeof record.shardDir === "string" ? record.shardDir : "";
+    if (!isEmbeddingGenerationDirPath(shardDir)) {
+      throw new Error(`offline sync changeset embeddingGenerations shardDir must be a canonical embeddings generation dir: ${shardDir}`);
+    }
+    if (dirs.has(shardDir)) {
+      throw new Error(`offline sync changeset embeddingGenerations has a duplicate shardDir: ${shardDir}`);
+    }
+    if (!Array.isArray(record.members) || record.members.length === 0) {
+      throw new Error(`offline sync changeset embeddingGenerations ${shardDir} must list its complete member set`);
+    }
+    const memberPaths = /* @__PURE__ */ new Set();
+    const members = [];
+    for (const rawMember of record.members) {
+      if (!rawMember || typeof rawMember !== "object" || Array.isArray(rawMember)) {
+        throw new Error(`offline sync changeset embeddingGenerations ${shardDir} members must be objects`);
+      }
+      const member = rawMember;
+      const memberPath = typeof member.path === "string" ? member.path : "";
+      if (embeddingShardDirOf(memberPath) !== shardDir) {
+        throw new Error(`offline sync changeset embeddingGenerations member ${memberPath} does not belong to generation ${shardDir}`);
+      }
+      if (memberPaths.has(memberPath)) {
+        throw new Error(`offline sync changeset embeddingGenerations ${shardDir} has a duplicate member: ${memberPath}`);
+      }
+      if (typeof member.sha256 !== "string" || !SHA256_PATTERN.test(member.sha256)) {
+        throw new Error(`offline sync changeset embeddingGenerations member ${memberPath} sha256 must be a lowercase sha256 hex digest`);
+      }
+      if (typeof member.bytes !== "number" || !Number.isInteger(member.bytes) || member.bytes < 0) {
+        throw new Error(`offline sync changeset embeddingGenerations member ${memberPath} bytes must be a non-negative integer`);
+      }
+      memberPaths.add(memberPath);
+      members.push({ path: memberPath, sha256: member.sha256, bytes: member.bytes });
+    }
+    dirs.add(shardDir);
+    generations.push({ shardDir, members });
+  }
+  const memberByPath = /* @__PURE__ */ new Map();
+  for (const generation of generations) {
+    for (const member of generation.members) memberByPath.set(member.path, member);
+  }
+  for (const change of changes) {
+    const membership = embeddingGenerationMembership(change.path);
+    if (!membership) continue;
+    const manifested = memberByPath.get(change.path);
+    if (change.type === "upsert") {
+      if (membership.kind !== "shard") continue;
+      if (!manifested) {
+        throw new Error(`offline sync changeset upserts of embedding shards require a manifest entry: ${change.path}`);
+      }
+      if (manifested.sha256 !== change.file.sha256 || manifested.bytes !== change.file.bytes) {
+        throw new Error(`offline sync changeset manifest member ${change.path} does not match the upserted record`);
+      }
+      continue;
+    }
+    if (manifested) {
+      throw new Error(`offline sync changeset delete of ${change.path} contradicts its manifest membership`);
+    }
+  }
+  return generations;
+}
+function deferGenerationConflicts(dirChanges, currentMap, reason) {
+  const conflicts = [];
+  const conflictedPaths = /* @__PURE__ */ new Set();
+  for (const change of dirChanges) {
+    conflictedPaths.add(change.path);
+    conflicts.push({
+      path: change.path,
+      reason,
+      ...change.type === "upsert" ? { incomingSha256: change.file.sha256 } : {},
+      ...change.baseSha256 !== void 0 ? { baseSha256: change.baseSha256 } : {},
+      localSha256: currentMap.get(change.path)?.sha256
+    });
+  }
+  return { conflicts, conflictedPaths };
+}
+async function applyChangesetEmbeddingGenerations(options) {
+  const result = {
+    transactionHandled: /* @__PURE__ */ new Set(),
+    conflicts: [],
+    conflictedPaths: /* @__PURE__ */ new Set(),
+    appliedUpserts: 0,
+    appliedDeletes: 0,
+    writtenStates: /* @__PURE__ */ new Map(),
+    removedPaths: /* @__PURE__ */ new Set()
+  };
+  const manifest = new Map(
+    (options.changeset.embeddingGenerations ?? []).map((generation) => [generation.shardDir, generation])
+  );
+  const shardUpsertChanges = /* @__PURE__ */ new Map();
+  const markerUpsertChanges = /* @__PURE__ */ new Map();
+  const deleteChangesByDir = /* @__PURE__ */ new Map();
+  const dirChanges = /* @__PURE__ */ new Map();
+  for (const change of options.changeset.changes) {
+    const membership = embeddingGenerationMembership(change.path);
+    if (!membership) continue;
+    const dir = membership.shardDir;
+    if (!dirChanges.has(dir)) dirChanges.set(dir, []);
+    dirChanges.get(dir).push(change);
+    if (change.type === "upsert") {
+      if (membership.kind === "shard") {
+        if (!shardUpsertChanges.has(dir)) shardUpsertChanges.set(dir, []);
+        shardUpsertChanges.get(dir).push(change);
+      } else {
+        if (!markerUpsertChanges.has(dir)) markerUpsertChanges.set(dir, []);
+        markerUpsertChanges.get(dir).push(change);
+      }
+    } else {
+      if (!deleteChangesByDir.has(dir)) deleteChangesByDir.set(dir, []);
+      deleteChangesByDir.get(dir).push(change);
+    }
+  }
+  if ((shardUpsertChanges.size > 0 || markerUpsertChanges.size > 0) && options.customIoPresent && !(options.io.writeStagingFile && options.io.readStagingFile)) {
+    throw new EmbeddingIndexStorageError(
+      "refusing to replace embedding generation: custom storage IO requires both writeStagingFile and readStagingFile hooks; unencrypted raw staging would plaintext-downgrade the index"
+    );
+  }
+  const runTransaction = async (shardDirRel, input) => {
+    const transaction = await applyEmbeddingGenerationTransaction({
+      ...input,
+      root: options.root,
+      io: options.io,
+      now: options.now
+    });
+    if (transaction.deferredLocalDivergence) {
+      const deferred = deferGenerationConflicts(
+        dirChanges.get(shardDirRel) ?? [],
+        options.currentMap,
+        "embedding_generation_diverged"
+      );
+      result.conflicts.push(...deferred.conflicts);
+      for (const conflicted of deferred.conflictedPaths) result.conflictedPaths.add(conflicted);
+      return transaction;
+    }
+    result.appliedUpserts += transaction.upserted;
+    result.appliedDeletes += transaction.deleted;
+    for (const [relPath, state] of transaction.writtenStates) {
+      result.writtenStates.set(relPath, state);
+      result.transactionHandled.add(relPath);
+    }
+    for (const relPath of transaction.removedPaths) {
+      result.removedPaths.add(relPath);
+      result.transactionHandled.add(relPath);
+    }
+    return transaction;
+  };
+  const manifestedInput = (shardDirRel, generation) => {
+    const upsertByPath = new Map(
+      (shardUpsertChanges.get(shardDirRel) ?? []).map((change) => [change.path, change])
+    );
+    const memberByPath = new Map(generation.members.map((member) => [member.path, member]));
+    const incomingShardPaths = generation.members.map((member) => member.path).sort();
+    const tombstones = (deleteChangesByDir.get(shardDirRel) ?? []).filter((change) => change.type === "delete");
+    const baseStates = /* @__PURE__ */ new Map();
+    for (const member of generation.members) {
+      const change = upsertByPath.get(member.path);
+      if (change) {
+        if (change.baseSha256 !== void 0) baseStates.set(member.path, { sha256: change.baseSha256 });
+        continue;
+      }
+      baseStates.set(member.path, { sha256: member.sha256 });
+    }
+    for (const change of tombstones) {
+      baseStates.set(change.path, { sha256: change.baseSha256 });
+    }
+    return {
+      shardDirRel,
+      incomingShardPaths,
+      incomingMarker: null,
+      incomingMarkerPresent: markerUpsertChanges.has(shardDirRel),
+      incomingShardStates: new Map(
+        incomingShardPaths.map((relPath) => [relPath, {
+          path: relPath,
+          sha256: upsertByPath.get(relPath)?.file.sha256 ?? memberByPath.get(relPath).sha256,
+          bytes: memberByPath.get(relPath).bytes,
+          mtimeMs: options.now
+        }])
+      ),
+      incomingBuffers: options.incomingBuffers,
+      baseStates,
+      // Manifested deletes are pre-authorized removals: the retry after a
+      // response loss must re-apply idempotently instead of diverging
+      // (#3150 review), and the swept members need their deletion revisions
+      // recorded after the swap (the per-file loop never sees them). The
+      // map is present whenever tombstones exist — even when none carries
+      // mtimeMs — so the recording pass runs and defaults to `now`.
+      justifiedRemovals: new Set(tombstones.map((change) => change.path)),
+      deletionMtimeByPath: tombstones.length === 0 ? void 0 : new Map(
+        tombstones.filter((change) => change.mtimeMs !== void 0).map((change) => [change.path, change.mtimeMs])
+      ),
+      // All-manifested members base-less = the sender claims a fresh
+      // creation; an existing local generation must match exactly or defer.
+      freshCreateClaim: baseStates.size === 0
+    };
+  };
+  const stateDirSuffix = `/${EMBEDDING_SHARD_DIR_BASENAME}`;
+  const allDirs = /* @__PURE__ */ new Set([
+    ...shardUpsertChanges.keys(),
+    ...markerUpsertChanges.keys(),
+    ...deleteChangesByDir.keys()
+  ]);
+  for (const shardDirRel of [...allDirs].sort()) {
+    const generation = manifest.get(shardDirRel);
+    if (shardUpsertChanges.has(shardDirRel) || generation && deleteChangesByDir.has(shardDirRel)) {
+      if (!generation) {
+        const deferred = deferGenerationConflicts(
+          dirChanges.get(shardDirRel) ?? [],
+          options.currentMap,
+          "embedding_generation_manifest_required"
+        );
+        result.conflicts.push(...deferred.conflicts);
+        for (const conflicted of deferred.conflictedPaths) result.conflictedPaths.add(conflicted);
+        continue;
+      }
+      await runTransaction(shardDirRel, manifestedInput(shardDirRel, generation));
+      continue;
+    }
+    if (markerUpsertChanges.has(shardDirRel)) {
+      const markerChange = (markerUpsertChanges.get(shardDirRel) ?? [])[0];
+      if (!markerChange) continue;
+      const stateDirRel2 = shardDirRel.slice(0, -stateDirSuffix.length);
+      const markerRel2 = `${stateDirRel2}/${EMBEDDING_MARKER_BASENAME}`;
+      const transaction = await runTransaction(shardDirRel, {
+        shardDirRel,
+        incomingShardPaths: [],
+        incomingMarker: {
+          path: markerRel2,
+          sha256: markerChange.file.sha256,
+          buffer: options.incomingBuffers.get(markerRel2) ?? null
+        },
+        incomingMarkerPresent: false,
+        incomingShardStates: /* @__PURE__ */ new Map(),
+        incomingBuffers: options.incomingBuffers,
+        baseStates: markerChange.baseSha256 === void 0 ? void 0 : /* @__PURE__ */ new Map([[markerRel2, { sha256: markerChange.baseSha256 }]])
+      });
+      if (!transaction.deferredLocalDivergence) result.transactionHandled.add(markerRel2);
+      continue;
+    }
+    const deletes = deleteChangesByDir.get(shardDirRel) ?? [];
+    const deletePaths = new Set(deletes.map((change) => change.path));
+    const stateDirRel = shardDirRel.slice(0, -stateDirSuffix.length);
+    const markerRel = `${stateDirRel}/${EMBEDDING_MARKER_BASENAME}`;
+    const localMembers = [];
+    if (await pathExists(await resolveSafeArchiveTarget(options.root, markerRel))) localMembers.push(markerRel);
+    let localShardNames = [];
+    try {
+      localShardNames = (await readdir(await resolveSafeArchiveTarget(options.root, shardDirRel))).filter((name) => EMBEDDING_SHARD_FILE_PATTERN.test(name));
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    for (const name of localShardNames) localMembers.push(`${shardDirRel}/${name}`);
+    if (localMembers.length === 0) continue;
+    if (!localMembers.every((relPath) => deletePaths.has(relPath))) {
+      const deferred = deferGenerationConflicts(deletes, options.currentMap, "embedding_generation_manifest_required");
+      result.conflicts.push(...deferred.conflicts);
+      for (const conflicted of deferred.conflictedPaths) result.conflictedPaths.add(conflicted);
+      continue;
+    }
+    const tombstones = deletes.filter((change) => change.type === "delete");
+    const removal = await applyEmbeddingGenerationRemoval({
+      root: options.root,
+      shardDirRel,
+      io: { deleteFile: options.io.deleteFile, readFile: options.io.readFile },
+      deletionMtimeByPath: new Map(
+        tombstones.filter((change) => change.mtimeMs !== void 0).map((change) => [change.path, change.mtimeMs])
+      ),
+      baseStates: new Map(tombstones.map((change) => [change.path, { sha256: change.baseSha256 }])),
+      now: options.now
+    });
+    if (removal.deferredLocalDivergence) {
+      const deferred = deferGenerationConflicts(deletes, options.currentMap, "embedding_generation_diverged");
+      result.conflicts.push(...deferred.conflicts);
+      for (const conflicted of deferred.conflictedPaths) result.conflictedPaths.add(conflicted);
+      continue;
+    }
+    result.appliedDeletes += removal.deleted;
+    for (const relPath of removal.removedPaths) {
+      result.removedPaths.add(relPath);
+      result.transactionHandled.add(relPath);
+    }
+  }
+  return result;
+}
+function buildChangesetGenerationManifest(options) {
+  const currentByPath = new Map(options.currentFiles.map((state) => [state.path, state]));
+  const baseByPath = new Map(options.baseFiles.map((state) => [state.path, state]));
+  const touchedDirs = /* @__PURE__ */ new Map();
+  for (const change of options.changes) {
+    const membership = embeddingGenerationMembership(change.path);
+    if (membership) {
+      if (!touchedDirs.has(membership.shardDir)) touchedDirs.set(membership.shardDir, []);
+      touchedDirs.get(membership.shardDir).push(change);
+    }
+  }
+  const generations = [];
+  for (const [shardDirRel, changes] of [...touchedDirs].sort(([left], [right]) => left.localeCompare(right))) {
+    const memberPaths = /* @__PURE__ */ new Set();
+    for (const relPath of currentByPath.keys()) {
+      const membership = embeddingGenerationMembership(relPath);
+      if (membership?.shardDir === shardDirRel) memberPaths.add(relPath);
+    }
+    for (const relPath of baseByPath.keys()) {
+      const membership = embeddingGenerationMembership(relPath);
+      if (membership?.shardDir === shardDirRel) memberPaths.add(relPath);
+    }
+    for (const change of changes) memberPaths.add(change.path);
+    let omitted = false;
+    for (const relPath of memberPaths) {
+      if (options.isExcluded(relPath)) {
+        omitted = true;
+        break;
+      }
+    }
+    if (omitted) continue;
+    const members = [...memberPaths].filter((relPath) => currentByPath.has(relPath)).sort().map((relPath) => {
+      const state = currentByPath.get(relPath);
+      return { path: state.path, sha256: state.sha256, bytes: state.bytes };
+    });
+    if (members.length === 0) continue;
+    generations.push({ shardDir: shardDirRel, members });
+  }
+  return generations;
+}
+
+export {
+  normalizeChangesetGenerations,
+  applyChangesetEmbeddingGenerations,
+  buildChangesetGenerationManifest
+};
+//# sourceMappingURL=chunk-MSAI3Q7D.js.map