@remnic/core 9.69.88 → 9.69.90

package/dist/chunk-A5ZYP4K5.js

@@ -0,0 +1,130 @@
+import {
+  memoryForResult
+} from "./chunk-D3V3UMET.js";
+import {
+  coerceNumber
+} from "./chunk-PQVCH2AE.js";
+import {
+  resolveRecallEnhancementCapabilities
+} from "./chunk-2EMROIXS.js";
+
+// src/rerank-outcome.ts
+var OUTCOME_STATE_UNOBSERVED = "UNOBSERVED";
+var OUTCOME_STATE_OBSERVED = "OBSERVED";
+function scaleTextScore(score) {
+  if (!Number.isFinite(score) || score <= 0) return 0;
+  if (score >= 1) return 1;
+  return score;
+}
+function finiteNonNegative(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return void 0;
+  return value;
+}
+function resolveOutcomeObservation(counters) {
+  if (!counters) return { state: OUTCOME_STATE_UNOBSERVED };
+  const successPresent = counters.success !== void 0;
+  const failPresent = counters.fail !== void 0;
+  if (!successPresent && !failPresent) return { state: OUTCOME_STATE_UNOBSERVED };
+  const success = finiteNonNegative(counters.success);
+  const fail = finiteNonNegative(counters.fail);
+  if (successPresent && success === void 0) return { state: OUTCOME_STATE_UNOBSERVED };
+  if (failPresent && fail === void 0) return { state: OUTCOME_STATE_UNOBSERVED };
+  const successes = success ?? 0;
+  const failures = fail ?? 0;
+  if (successes === 0 && failures === 0) return { state: OUTCOME_STATE_UNOBSERVED };
+  return {
+    state: OUTCOME_STATE_OBSERVED,
+    outcomeScore: successes / (successes + failures)
+  };
+}
+function blendOutcomeScore(textScore, observation, weight) {
+  if (weight === 0) return textScore;
+  const textUnit = scaleTextScore(textScore);
+  if (observation.state === OUTCOME_STATE_UNOBSERVED || observation.outcomeScore === void 0) {
+    return textUnit;
+  }
+  return (1 - weight) * textUnit + weight * observation.outcomeScore;
+}
+function assertOutcomeWeight(weight) {
+  if (!Number.isFinite(weight) || weight < 0 || weight > 1) {
+    throw new Error(
+      `outcomeBoostWeight must be a finite number in [0, 1] (got ${JSON.stringify(weight)}).`
+    );
+  }
+}
+function compareRanked(left, right) {
+  const leftScore = Number.isFinite(left.score) ? left.score : Number.NEGATIVE_INFINITY;
+  const rightScore = Number.isFinite(right.score) ? right.score : Number.NEGATIVE_INFINITY;
+  if (leftScore !== rightScore) return leftScore > rightScore ? -1 : 1;
+  if (left.originalIndex === right.originalIndex) return 0;
+  return left.originalIndex < right.originalIndex ? -1 : 1;
+}
+function rerankWithOutcomePrior(candidates, weight) {
+  assertOutcomeWeight(weight);
+  const ranked = candidates.map((candidate, originalIndex) => {
+    const observation = resolveOutcomeObservation({
+      success: candidate.success,
+      fail: candidate.fail
+    });
+    return {
+      item: candidate.item,
+      textScore: candidate.textScore,
+      score: blendOutcomeScore(candidate.textScore, observation, weight),
+      state: observation.state,
+      originalIndex
+    };
+  });
+  if (weight === 0) return ranked;
+  ranked.sort(compareRanked);
+  return ranked;
+}
+function outcomePriorBoostActive(config) {
+  const weight = config.outcomeBoostWeight;
+  return resolveRecallEnhancementCapabilities(config).outcomeBoost === true && typeof weight === "number" && Number.isFinite(weight) && weight > 0;
+}
+function applyOutcomePriorScores(results, memoryByPath, config) {
+  const weight = config.outcomeBoostWeight;
+  if (typeof weight !== "number" || !Number.isFinite(weight) || weight < 0) return;
+  assertOutcomeWeight(weight);
+  if (weight === 0) return;
+  const ranked = results.map((result, originalIndex) => {
+    const memory = memoryForResult(memoryByPath, result);
+    const observation = resolveOutcomeObservation(
+      memory ? { success: memory.frontmatter.mw_success, fail: memory.frontmatter.mw_fail } : void 0
+    );
+    return {
+      result,
+      originalIndex,
+      score: blendOutcomeScore(result.score, observation, weight)
+    };
+  });
+  ranked.sort(compareRanked);
+  const next = ranked.map(
+    (row) => row.score === row.result.score ? row.result : { ...row.result, score: row.score }
+  );
+  results.splice(0, results.length, ...next);
+}
+function parseOutcomeBoostWeight(raw) {
+  if (raw === void 0 || raw === null || raw === "") return 0;
+  const parsed = coerceNumber(raw, "outcomeBoostWeight");
+  if (parsed === void 0 || parsed < 0 || parsed > 1) {
+    throw new Error(
+      `outcomeBoostWeight must be a number in [0, 1] (got ${JSON.stringify(raw)}).`
+    );
+  }
+  return parsed;
+}
+
+export {
+  OUTCOME_STATE_UNOBSERVED,
+  OUTCOME_STATE_OBSERVED,
+  scaleTextScore,
+  resolveOutcomeObservation,
+  blendOutcomeScore,
+  rerankWithOutcomePrior,
+  outcomePriorBoostActive,
+  applyOutcomePriorScores,
+  parseOutcomeBoostWeight
+};
+//# sourceMappingURL=chunk-A5ZYP4K5.js.map

package/dist/chunk-A5ZYP4K5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/rerank-outcome.ts"],"sourcesContent":["/**\n * H1 outcome-prior blend (issue #1958). Scaffolding only — no experiment runner.\n *\n * Text scores map onto [0, 1] with a fixed clamp. The clamp is not a batch\n * min-max, so one candidate cannot move another's scale.\n *\n * UNOBSERVED (no past result) keeps that unit text score when the weight is\n * positive. It does not use the Memory Worth Laplace prior (s+1)/(s+f+2).\n * An observed result uses the maximum-likelihood rate success/(success+fail).\n *\n * Turning the blend on (enabled and weight > 0) clamps every candidate's text\n * score into [0, 1] before mixing, including UNOBSERVED items. Raw scores\n * outside that range can change order relative to the weight-0 path. Weight 0\n * does not clamp.\n *\n * Weight 0 is an identity on the raw input score: same values, same order.\n * The recall pipeline calls `applyOutcomePriorScores` only when\n * `outcomeBoostEnabled === true` and the weight is greater than 0, so the\n * production default stays on the existing sort.\n */\n\nimport {\n  type RecallEnhancementConfigProjection,\n  resolveRecallEnhancementCapabilities,\n} from \"./capabilities.js\";\nimport { coerceNumber } from \"./connectors/coerce.js\";\nimport { memoryForResult } from \"./recall-memory-map.js\";\nimport type { MemoryFile, QmdSearchResult } from \"./types.js\";\n\nexport const OUTCOME_STATE_UNOBSERVED = \"UNOBSERVED\" as const;\nexport const OUTCOME_STATE_OBSERVED = \"OBSERVED\" as const;\n\nexport type OutcomeObservationState =\n  | typeof OUTCOME_STATE_UNOBSERVED\n  | typeof OUTCOME_STATE_OBSERVED;\n\nexport interface OutcomeCounters {\n  success?: number;\n  fail?: number;\n}\n\nexport interface OutcomeObservation {\n  state: OutcomeObservationState;\n  /** Present only for OBSERVED. Maximum-likelihood rate in [0, 1]. */\n  outcomeScore?: number;\n}\n\nexport function scaleTextScore(score: number): number {\n  if (!Number.isFinite(score) || score <= 0) return 0;\n  if (score >= 1) return 1;\n  return score;\n}\n\nfunction finiteNonNegative(value: number | undefined): number | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"number\" || !Number.isFinite(value) || value < 0) return undefined;\n  return value;\n}\n\n/**\n * Both counters missing, explicit 0+0, or any present-but-invalid counter\n * (non-finite or negative) is UNOBSERVED. One counter present and positive\n * with the other missing is OBSERVED; the missing counter counts as 0.\n */\nexport function resolveOutcomeObservation(\n  counters: OutcomeCounters | undefined,\n): OutcomeObservation {\n  if (!counters) return { state: OUTCOME_STATE_UNOBSERVED };\n  const successPresent = counters.success !== undefined;\n  const failPresent = counters.fail !== undefined;\n  if (!successPresent && !failPresent) return { state: OUTCOME_STATE_UNOBSERVED };\n\n  const success = finiteNonNegative(counters.success);\n  const fail = finiteNonNegative(counters.fail);\n  if (successPresent && success === undefined) return { state: OUTCOME_STATE_UNOBSERVED };\n  if (failPresent && fail === undefined) return { state: OUTCOME_STATE_UNOBSERVED };\n\n  const successes = success ?? 0;\n  const failures = fail ?? 0;\n  if (successes === 0 && failures === 0) return { state: OUTCOME_STATE_UNOBSERVED };\n  return {\n    state: OUTCOME_STATE_OBSERVED,\n    outcomeScore: successes / (successes + failures),\n  };\n}\n\n/**\n * Weight 0 returns `textScore` unchanged. A positive weight clamps `textScore`\n * into [0, 1] first. UNOBSERVED stays on that clamped value. OBSERVED mixes it\n * with the success rate.\n */\nexport function blendOutcomeScore(\n  textScore: number,\n  observation: OutcomeObservation,\n  weight: number,\n): number {\n  if (weight === 0) return textScore;\n  const textUnit = scaleTextScore(textScore);\n  if (observation.state === OUTCOME_STATE_UNOBSERVED || observation.outcomeScore === undefined) {\n    return textUnit;\n  }\n  return (1 - weight) * textUnit + weight * observation.outcomeScore;\n}\n\nexport interface OutcomePriorCandidate<T> {\n  item: T;\n  textScore: number;\n  success?: number;\n  fail?: number;\n}\n\nexport interface OutcomePriorRanked<T> {\n  item: T;\n  textScore: number;\n  score: number;\n  state: OutcomeObservationState;\n  originalIndex: number;\n}\n\nfunction assertOutcomeWeight(weight: number): void {\n  if (!Number.isFinite(weight) || weight < 0 || weight > 1) {\n    throw new Error(\n      `outcomeBoostWeight must be a finite number in [0, 1] (got ${JSON.stringify(weight)}).`,\n    );\n  }\n}\n\nfunction compareRanked(\n  left: { score: number; originalIndex: number },\n  right: { score: number; originalIndex: number },\n): number {\n  const leftScore = Number.isFinite(left.score) ? left.score : Number.NEGATIVE_INFINITY;\n  const rightScore = Number.isFinite(right.score) ? right.score : Number.NEGATIVE_INFINITY;\n  if (leftScore !== rightScore) return leftScore > rightScore ? -1 : 1;\n  if (left.originalIndex === right.originalIndex) return 0;\n  return left.originalIndex < right.originalIndex ? -1 : 1;\n}\n\nexport function rerankWithOutcomePrior<T>(\n  candidates: readonly OutcomePriorCandidate<T>[],\n  weight: number,\n): OutcomePriorRanked<T>[] {\n  assertOutcomeWeight(weight);\n  const ranked = candidates.map((candidate, originalIndex) => {\n    const observation = resolveOutcomeObservation({\n      success: candidate.success,\n      fail: candidate.fail,\n    });\n    return {\n      item: candidate.item,\n      textScore: candidate.textScore,\n      score: blendOutcomeScore(candidate.textScore, observation, weight),\n      state: observation.state,\n      originalIndex,\n    };\n  });\n  if (weight === 0) return ranked;\n  ranked.sort(compareRanked);\n  return ranked;\n}\n\nexport function outcomePriorBoostActive(\n  config: RecallEnhancementConfigProjection & { outcomeBoostWeight?: number },\n): boolean {\n  const weight = config.outcomeBoostWeight;\n  return (\n    resolveRecallEnhancementCapabilities(config).outcomeBoost === true &&\n    typeof weight === \"number\" &&\n    Number.isFinite(weight) &&\n    weight > 0\n  );\n}\n\nexport function applyOutcomePriorScores(\n  results: QmdSearchResult[],\n  memoryByPath: ReadonlyMap<string, MemoryFile>,\n  config: { outcomeBoostWeight?: number },\n): void {\n  const weight = config.outcomeBoostWeight;\n  // Non-numbers, non-finite values, and negatives are a no-op. Zero is an\n  // identity. assertOutcomeWeight is the upper bound (> 1 throws); it is not\n  // a second copy of the positivity check.\n  if (typeof weight !== \"number\" || !Number.isFinite(weight) || weight < 0) return;\n  assertOutcomeWeight(weight);\n  if (weight === 0) return;\n  const ranked = results.map((result, originalIndex) => {\n    const memory = memoryForResult(memoryByPath, result);\n    const observation = resolveOutcomeObservation(\n      memory\n        ? { success: memory.frontmatter.mw_success, fail: memory.frontmatter.mw_fail }\n        : undefined,\n    );\n    return {\n      result,\n      originalIndex,\n      score: blendOutcomeScore(result.score, observation, weight),\n    };\n  });\n  ranked.sort(compareRanked);\n  const next = ranked.map((row) =>\n    row.score === row.result.score ? row.result : { ...row.result, score: row.score },\n  );\n  results.splice(0, results.length, ...next);\n}\n\n/**\n * Absent / null / exact empty string → 0. A present value that is not a\n * finite number in [0, 1] throws. Boolean false is not a zero weight.\n */\nexport function parseOutcomeBoostWeight(raw: unknown): number {\n  if (raw === undefined || raw === null || raw === \"\") return 0;\n  const parsed = coerceNumber(raw, \"outcomeBoostWeight\");\n  if (parsed === undefined || parsed < 0 || parsed > 1) {\n    throw new Error(\n      `outcomeBoostWeight must be a number in [0, 1] (got ${JSON.stringify(raw)}).`,\n    );\n  }\n  return parsed;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-AWG3TIAY.js → chunk-ACCOC6UM.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   StorageManager
-} from "./chunk-STEOT4DI.js";
+} from "./chunk-SCPHU3RW.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-XCB6QDL6.js";
@@ -765,4 +765,4 @@ export {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
 };
-//# sourceMappingURL=chunk-AWG3TIAY.js.map
+//# sourceMappingURL=chunk-ACCOC6UM.js.map

package/dist/{chunk-3JDA3XF5.js → chunk-AEGNDL24.js}

@@ -1,6 +1,6 @@
 import {
   EXTRACTION_RESPONSE_PLACEHOLDERS
-} from "./chunk-7LNHRQKR.js";
+} from "./chunk-JLIGUFPF.js";
 import {
   normalizeRecallTokens
 } from "./chunk-YCVB7X56.js";
@@ -69,4 +69,4 @@ export {
   extractionAttributes,
   extractionCueAnchors
 };
-//# sourceMappingURL=chunk-3JDA3XF5.js.map
+//# sourceMappingURL=chunk-AEGNDL24.js.map

package/dist/{chunk-2NAD4YCI.js → chunk-AEUMONCD.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-STEOT4DI.js";
+} from "./chunk-SCPHU3RW.js";
 import {
   getCachedRuleMemories,
   setCachedRuleMemories
@@ -119,4 +119,4 @@ export {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
 };
-//# sourceMappingURL=chunk-2NAD4YCI.js.map
+//# sourceMappingURL=chunk-AEUMONCD.js.map

package/dist/{chunk-C6U57KG4.js → chunk-AF5PW35O.js}

@@ -8,10 +8,10 @@ import {
 } from "./chunk-N7QV3CMX.js";
 import {
   offlineSyncStorageForSnapshot
-} from "./chunk-UP75KL3L.js";
+} from "./chunk-2JRB3Z5N.js";
 import {
   iterateOfflineSyncSnapshotFileRecords
-} from "./chunk-OCFXVDBZ.js";
+} from "./chunk-IVEHY2VT.js";
 import {
   createPersistedSupportPassportPrivateFileExclusion
 } from "./chunk-PWPIERBM.js";
@@ -250,4 +250,4 @@ export {
   retainExcludedClassifications,
   createOfflineSyncManifestStream
 };
-//# sourceMappingURL=chunk-C6U57KG4.js.map
+//# sourceMappingURL=chunk-AF5PW35O.js.map

package/dist/{chunk-IOSZHHJC.js → chunk-ANGZWYL2.js}

@@ -24,7 +24,7 @@ import {
 } from "./chunk-E4RMZGRS.js";
 import {
   RECALL_WHY_MCP_TOOLS
-} from "./chunk-AZSGSRIM.js";
+} from "./chunk-WHTMVTU4.js";
 import {
   sharedContextMcpTools
 } from "./chunk-JATHBCAV.js";
@@ -43,19 +43,19 @@ import {
 } from "./chunk-AB3A7EFH.js";
 import {
   applyToolOutputSchemas
-} from "./chunk-MCTM4YPL.js";
+} from "./chunk-2FLFJTCI.js";
 import {
   getOperation
-} from "./chunk-QB57WIS6.js";
+} from "./chunk-GXETU7AE.js";
 import {
   WHO_KNOWS_MCP_TOOLS
-} from "./chunk-6UQFJULG.js";
+} from "./chunk-VBNA2JEN.js";
 import {
   PROMOTION_CANDIDATES_MCP_TOOLS
 } from "./chunk-PO7NXNGC.js";
 import {
   validateRequest
-} from "./chunk-LW3HKRL7.js";
+} from "./chunk-3BTHXB7Z.js";
 import {
   assertOperationAllowed,
   capabilityAllowsOp,
@@ -4023,4 +4023,4 @@ export {
   MCP_MIGRATED_OPERATIONS,
   EngramMcpServer
 };
-//# sourceMappingURL=chunk-IOSZHHJC.js.map
+//# sourceMappingURL=chunk-ANGZWYL2.js.map

package/dist/{chunk-K6T33R4Q.js → chunk-AXGJMDBS.js}

@@ -1,12 +1,12 @@
+import {
+  EMBEDDING_SHARD_FILE_PATTERN
+} from "./chunk-TYT4TEQV.js";
 import {
   matchesOfflineSyncDefaultExclude
 } from "./chunk-4NSLQ7EU.js";
 import {
   resolveSafeArchiveTarget
 } from "./chunk-GCGJW34D.js";
-import {
-  EMBEDDING_SHARD_FILE_PATTERN
-} from "./chunk-TYT4TEQV.js";
 import {
   assertEmbeddingGenerationLockHeld,
   embeddingGenerationLockPath,
@@ -151,6 +151,7 @@ async function applyEmbeddingGenerationTransaction(input) {
     if (await store.recoverIfInterrupted(fence)) {
       await resolveSafeArchiveTarget(root, shardDirRel);
     }
+    const justifiedRemovals = input.justifiedRemovals ?? /* @__PURE__ */ new Set();
     const baseStates = baseStatesForGeneration(input.baseStates, shardDirRel);
     if (baseStates.size > 0) {
       const localCensus = await censusGenerationState(io, root, markerRel, markerAbs, shardDirAbs, shardDirRel);
@@ -158,10 +159,18 @@ async function applyEmbeddingGenerationTransaction(input) {
       const censusArr = [...localCensus].map(([relPath, sha256]) => ({ path: relPath, sha256 }));
       const deferrals = divergedEmbeddingGenerationDeferrals({
         incomingFiles: incomingGenerationStates(input),
-        baseFiles: baseArr,
+        // A pre-authorized removal keeps its base entry only while still on
+        // disk (digest auth): present members are compared normally — a
+        // daemon rewrite still defers — while an absent member is already
+        // applied and must not diverge the retry (#3150 review).
+        baseFiles: baseArr.filter((member) => !justifiedRemovals.has(member.path) || localCensus.has(member.path)),
         currentFiles: censusArr
       });
-      const addedOrRemovedSinceBase = censusArr.some((member) => !baseStates.has(member.path)) || baseArr.some((member) => !localCensus.has(member.path));
+      const incomingShardPaths = new Set(input.incomingShardPaths);
+      const addedOrRemovedSinceBase = censusArr.some((member) => !baseStates.has(member.path) && !justifiedRemovals.has(member.path) && // An incoming member found in the census is the apply's own
+      // already-published work (response-loss retry), not a local
+      // addition; its bytes were verified above.
+      !incomingShardPaths.has(member.path)) || baseArr.some((member) => !localCensus.has(member.path) && !justifiedRemovals.has(member.path));
       if (deferrals.length > 0 || addedOrRemovedSinceBase) {
         const handled = new Set(input.incomingShardPaths);
         if (input.incomingMarker) handled.add(input.incomingMarker.path);
@@ -180,6 +189,31 @@ async function applyEmbeddingGenerationTransaction(input) {
           deferredLocalDivergence: true
         };
       }
+    } else if (input.freshCreateClaim) {
+      const localCensus = await censusGenerationState(io, root, markerRel, markerAbs, shardDirAbs, shardDirRel);
+      if (localCensus.size > 0) {
+        const incomingArr = incomingGenerationStates(input).sort((left, right) => left.path.localeCompare(right.path));
+        const censusArr = [...localCensus].map(([relPath, sha256]) => ({ path: relPath, sha256 })).sort((left, right) => left.path.localeCompare(right.path));
+        const identical = censusArr.length === incomingArr.length && censusArr.every((member, index) => member.path === incomingArr[index]?.path && member.sha256 === incomingArr[index]?.sha256);
+        if (!identical) {
+          const handled = new Set(input.incomingShardPaths);
+          if (input.incomingMarker) handled.add(input.incomingMarker.path);
+          if (input.incomingMarkerPresent) handled.add(markerRel);
+          for (const relPath of localCensus.keys()) handled.add(relPath);
+          log.warn(
+            `embedding generation ${shardDirRel} deferred: base-less creation does not match the existing local generation under the mutation lock; nothing published, nothing removed`
+          );
+          return {
+            shardDirRel,
+            upserted: 0,
+            deleted: 0,
+            writtenStates: /* @__PURE__ */ new Map(),
+            removedPaths: /* @__PURE__ */ new Set(),
+            handledPaths: handled,
+            deferredLocalDivergence: true
+          };
+        }
+      }
     }
     const published = /* @__PURE__ */ new Map();
     let identity = null;
@@ -301,6 +335,23 @@ async function applyEmbeddingGenerationTransaction(input) {
           log.warn(`embedding generation ${shardDirRel}: marker cleanup deferred after publish: ${err}`);
         }
       }
+      if (input.deletionMtimeByPath !== void 0 && io.deleteFile) {
+        let firstTombstoneError = null;
+        for (const relPath of removedPaths) {
+          try {
+            await io.deleteFile({
+              root: root.abs,
+              path: relPath,
+              filePath: await resolveSafeArchiveTarget(root, relPath),
+              mtimeMs: input.deletionMtimeByPath.get(relPath) ?? input.now
+            });
+          } catch (err) {
+            firstTombstoneError ??= err;
+            log.warn(`embedding generation ${shardDirRel}: tombstone recording failed for ${relPath}: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        if (firstTombstoneError) throw firstTombstoneError;
+      }
       return {
         shardDirRel,
         upserted: published.size,
@@ -515,6 +566,103 @@ function divergedEmbeddingGenerationDeferrals(options) {
   }
   return deferred.sort((left, right) => left.localeCompare(right));
 }
+async function applyIncomingEmbeddingGenerations(options) {
+  const incomingGenerations = detectIncomingEmbeddingGenerations(options.incomingMap.keys());
+  const generationDirs = /* @__PURE__ */ new Set([
+    ...incomingGenerations.shardDirs,
+    ...incomingGenerations.legacyMarkerDirs
+  ]);
+  const deferredGenerationDirs = /* @__PURE__ */ new Set();
+  for (const deferredPath of options.deferredPaths) {
+    const membership = embeddingGenerationMembership(deferredPath);
+    if (membership) deferredGenerationDirs.add(membership.shardDir);
+  }
+  const transactionResults = [];
+  for (const shardDir of generationDirs) {
+    if (options.omittedGenerationDirs.has(shardDir)) {
+      throw new EmbeddingIndexStorageError(
+        `offline sync snapshot both includes and omits embedding generation ${shardDir}; refusing to apply`
+      );
+    }
+  }
+  if (generationDirs.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"
+    );
+  }
+  for (const shardDir of generationDirs) {
+    if (deferredGenerationDirs.has(shardDir)) continue;
+    if (incomingGenerations.legacyMarkerDirs.has(shardDir) && !incomingGenerations.shardDirs.has(shardDir)) {
+      const markerRel = [...options.incomingMap.keys()].find(
+        (relPath) => embeddingMarkerDirOf(relPath) === shardDir.slice(0, -`/${EMBEDDING_SHARD_DIR_BASENAME}`.length)
+      );
+      if (!markerRel) continue;
+      transactionResults.push(await applyEmbeddingGenerationTransaction({
+        root: options.root,
+        shardDirRel: shardDir,
+        incomingShardPaths: [],
+        incomingMarker: {
+          path: markerRel,
+          sha256: options.incomingMap.get(markerRel).sha256,
+          buffer: options.incomingBuffers.get(markerRel) ?? null
+        },
+        incomingMarkerPresent: false,
+        incomingShardStates: /* @__PURE__ */ new Map(),
+        incomingBuffers: options.incomingBuffers,
+        baseStates: options.baseMap,
+        io: options.io,
+        now: options.now
+      }));
+      continue;
+    }
+    transactionResults.push(await applyEmbeddingGenerationTransaction({
+      root: options.root,
+      shardDirRel: shardDir,
+      incomingShardPaths: [...options.incomingMap.keys()].filter((relPath) => embeddingShardDirOf(relPath) === shardDir).sort(),
+      incomingMarker: null,
+      incomingMarkerPresent: Boolean(
+        incomingGenerations.legacyMarkerDirs.has(shardDir)
+      ),
+      incomingShardStates: new Map(
+        [...options.incomingMap.values()].filter((state) => embeddingShardDirOf(state.path) === shardDir).map((state) => [state.path, state])
+      ),
+      incomingBuffers: options.incomingBuffers,
+      baseStates: options.baseMap,
+      io: options.io,
+      now: options.now
+    }));
+  }
+  const localGenerationDirs = /* @__PURE__ */ new Set();
+  for (const relPath of options.currentMap.keys()) {
+    const membership = embeddingGenerationMembership(relPath);
+    if (membership?.kind === "shard") localGenerationDirs.add(membership.shardDir);
+  }
+  for (const shardDir of localGenerationDirs) {
+    if (generationDirs.has(shardDir) || deferredGenerationDirs.has(shardDir) || options.omittedGenerationDirs.has(shardDir)) {
+      continue;
+    }
+    const localMembers = [...options.currentMap.keys()].filter(
+      (relPath) => embeddingGenerationMembership(relPath)?.shardDir === shardDir
+    );
+    if (localMembers.length === 0) continue;
+    const baseMembers = localMembers.filter((relPath) => options.baseMap.has(relPath));
+    const tombstonedMembers = options.deletionMtimeByPath === void 0 ? [] : [...options.deletionMtimeByPath.keys()].filter(
+      (relPath) => embeddingGenerationMembership(relPath)?.shardDir === shardDir
+    );
+    const tombstoneCovered = tombstonedMembers.length > 0;
+    const baseEvidenced = baseMembers.length > 0 && baseMembers.every((relPath) => !options.incomingMap.has(relPath));
+    if (!tombstoneCovered && !baseEvidenced) continue;
+    transactionResults.push(await applyEmbeddingGenerationRemoval({
+      root: options.root,
+      shardDirRel: shardDir,
+      io: { deleteFile: options.io.deleteFile, readFile: options.io.readFile },
+      deletionMtimeByPath: options.deletionMtimeByPath,
+      baseStates: options.baseMap,
+      now: options.now
+    }));
+  }
+  return { transactionResults, deferredGenerationDirs };
+}
 
 export {
   EMBEDDING_SHARD_DIR_BASENAME,
@@ -530,6 +678,7 @@ export {
   resolvePushEmbeddingGenerationState,
   storageBackedIndexStoreIo,
   applyEmbeddingGenerationRemoval,
-  divergedEmbeddingGenerationDeferrals
+  divergedEmbeddingGenerationDeferrals,
+  applyIncomingEmbeddingGenerations
 };
-//# sourceMappingURL=chunk-K6T33R4Q.js.map
+//# sourceMappingURL=chunk-AXGJMDBS.js.map