@remnic/core 10.0.84 → 10.0.86

package/dist/chunk-EQ4U73UH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extraction-quote-grounding.ts"],"sourcesContent":["/**\n * Quote-anchored source grounding.\n *\n * An extracted fact carries the exact words that support it in `quote`. A quote\n * that is a verbatim substring of the source (whitespace-normalized) is real\n * evidence: the claim only has to be supported by the text around that span,\n * not by word overlap against the whole conversation. Items without such a\n * quote never get an anchor here and stay on the whole-source rules.\n */\n\nimport type { ExtractionResult } from \"./types.js\";\nimport {\n  GROUNDING_MIN_SHARED_TOKENS,\n  areGroundingTokensCompatible,\n  entityNameStart,\n  hasDenialReporting,\n  hasNonAssertiveReporting,\n  isGroundedEntityName,\n  normalizedEntityIdentifierTokens,\n  sourceSentences,\n  tokenize,\n} from \"./extraction-source-grounding-helpers.js\";\n\n/** Shortest normalized quote that counts as evidence; \"the\" or \"I\" prove nothing. */\nexport const QUOTE_ANCHOR_MIN_CHARS = 12;\n/** Characters of context kept on each side of the quote inside its turn. */\nexport const QUOTE_ANCHOR_CONTEXT_CHARS = 400;\n/** Share of a claim's content words that must occur in the quote's window. */\nexport const QUOTE_ANCHOR_MIN_WINDOW_COVERAGE = 0.35;\n/** Share of a claim's content words that must occur anywhere in the source; the rest is invented. */\nexport const QUOTE_ANCHOR_MIN_SOURCE_COVERAGE = 0.75;\nconst QUOTE_ANCHOR_MAX_OCCURRENCES = 8;\nconst TURN_SEPARATOR = \"\\n\\n\";\nconst NEGATOR_PATTERN = /\\b(?:not|no|never|cannot|without|neither|nor)\\b|n't\\b/iu;\nconst EXCLUSION_PATTERN =\n  /\\b(?:exclu\\w*|avoid\\w*|omit\\w*|skip\\w*|ignor\\w*|forbid\\w*|prohibit\\w*|disallow\\w*|prevent\\w*|reject\\w*|refus\\w*|insufficient|instead|rather|unless|except)\\b/iu;\n\n/** A verbatim quote and the text around it inside its turn. */\nexport interface QuoteAnchor {\n  /** Whitespace-normalized quote, exactly as it appears in the source. */\n  quote: string;\n  /** `quote` with its turn-local context; `;` inside the quote is rewritten to `,`. */\n  window: string;\n}\n\nexport type TokenPool = (token: string) => boolean;\n\ntype Entity = ExtractionResult[\"entities\"][number];\ntype Relationship = NonNullable<ExtractionResult[\"relationships\"]>[number];\n\nfunction normalizeWhitespaceWithMap(source: string): { text: string; originalIndex: number[] } {\n  const chars: string[] = [];\n  const originalIndex: number[] = [];\n  let inSpace = false;\n  for (let index = 0; index < source.length; index += 1) {\n    const char = source[index]!;\n    if (/\\s/u.test(char)) {\n      if (inSpace) continue;\n      inSpace = true;\n      chars.push(\" \");\n    } else {\n      inSpace = false;\n      chars.push(char);\n    }\n    originalIndex.push(index);\n  }\n  return { text: chars.join(\"\"), originalIndex };\n}\n\nfunction turnStartOffsets(source: string, turns: readonly string[]): readonly number[] | undefined {\n  const offsets: number[] = [];\n  let at = 0;\n  for (const turn of turns) {\n    if (!source.startsWith(turn, at)) return undefined;\n    offsets.push(at);\n    at += turn.length + TURN_SEPARATOR.length;\n  }\n  return at - TURN_SEPARATOR.length === source.length ? offsets : undefined;\n}\n\nfunction findQuoteAnchors(quote: string, source: string, bounds?: readonly number[]): QuoteAnchor[] {\n  const needle = quote.replace(/\\s+/gu, \" \").trim();\n  if (needle.length < QUOTE_ANCHOR_MIN_CHARS) return [];\n  const normalized = normalizeWhitespaceWithMap(source);\n  const anchors: QuoteAnchor[] = [];\n  let from = 0;\n  while (anchors.length < QUOTE_ANCHOR_MAX_OCCURRENCES) {\n    const at = normalized.text.indexOf(needle, from);\n    if (at < 0) break;\n    from = at + 1;\n    const start = normalized.originalIndex[at]!;\n    const end = normalized.originalIndex[at + needle.length - 1]! + 1;\n\n    let before: string;\n    let after: string;\n    if (bounds === undefined) {\n      if (source.slice(start, end).includes(TURN_SEPARATOR)) continue;\n      before = source.slice(Math.max(0, start - QUOTE_ANCHOR_CONTEXT_CHARS), start);\n      const sepBefore = before.lastIndexOf(TURN_SEPARATOR);\n      if (sepBefore >= 0) before = before.slice(sepBefore + TURN_SEPARATOR.length);\n      else if (start > QUOTE_ANCHOR_CONTEXT_CHARS) before = before.replace(/^\\S+/u, \"\");\n      after = source.slice(end, end + QUOTE_ANCHOR_CONTEXT_CHARS);\n      const sepAfter = after.indexOf(TURN_SEPARATOR);\n      if (sepAfter >= 0) after = after.slice(0, sepAfter);\n      else if (source.length - end > QUOTE_ANCHOR_CONTEXT_CHARS) after = after.replace(/\\S+$/u, \"\");\n    } else {\n      let turnStart = 0;\n      let turnEnd = source.length;\n      for (const bound of bounds) {\n        if (bound <= start) turnStart = bound;\n        else {\n          turnEnd = bound - TURN_SEPARATOR.length;\n          break;\n        }\n      }\n      if (turnEnd < end) continue;\n      before = source.slice(Math.max(turnStart, start - QUOTE_ANCHOR_CONTEXT_CHARS), start);\n      if (start - QUOTE_ANCHOR_CONTEXT_CHARS > turnStart) before = before.replace(/^\\S+/u, \"\");\n      const contextEnd = Math.min(turnEnd, end + QUOTE_ANCHOR_CONTEXT_CHARS);\n      after = source.slice(end, contextEnd);\n      if (end + QUOTE_ANCHOR_CONTEXT_CHARS < turnEnd) after = after.replace(/\\S+$/u, \"\");\n    }\n\n    anchors.push({ quote: needle, window: `${before}${needle.replace(/;/gu, \",\")}${after}` });\n  }\n  return anchors;\n}\n\n/**\n * Returns one anchor per place `quote` occurs verbatim in `source`, or [] when\n * the quote is absent, too short, or not an exact substring. A quote that\n * spans a turn separator is not one turn's words and yields no anchor; windows\n * never extend past their turn.\n *\n * The quote is one evidence unit: a `;` inside it is rewritten to `,` in the\n * window so sentence splitting cannot cut it, or a claim that merges two of\n * its clauses could never be grounded in a single sentence.\n *\n * `source` may have been rewritten before grounding (temporal anchoring,\n * pronoun resolution) while the model quoted the original words. When the raw\n * quote is not found, `transformQuote` applies the same rewrite to the quote.\n *\n * `turns` are the texts `source` was joined from; when they tile `source`\n * exactly, quotes and windows cut at real turn boundaries instead of any\n * blank line. Without them, every `TURN_SEPARATOR` run is a boundary.\n */\nexport function quoteAnchors(\n  quote: string | undefined,\n  source: string,\n  transformQuote?: (quote: string) => string,\n  turns?: readonly string[],\n): QuoteAnchor[] {\n  if (typeof quote !== \"string\") return [];\n  const bounds = turns === undefined ? undefined : turnStartOffsets(source, turns);\n  const exact = findQuoteAnchors(quote, source, bounds);\n  if (exact.length > 0 || transformQuote === undefined) return exact;\n  return findQuoteAnchors(transformQuote(quote), source, bounds);\n}\n\nexport function tokenPool(tokens: ReadonlySet<string>): TokenPool {\n  const list = [...tokens];\n  return (token) => tokens.has(token) || list.some((poolToken) => areGroundingTokensCompatible(token, poolToken));\n}\n\nfunction hasNegation(text: string): boolean {\n  return NEGATOR_PATTERN.test(text.replace(/[\\u2018\\u2019]/gu, \"'\")) || hasDenialReporting(text);\n}\n\nconst CLAUSE_PATTERN = /[^;.!?\\n]+[;.!?]*/gu;\n/** Split \"X, and Y\" claim coordination without touching list commas. */\nconst CLAIM_COORD_SPLIT = /,\\s{1,8}(?:and|but|or|nor)\\s{1,8}/iu;\n\nfunction splitClaimClauses(content: string): string[] {\n  return (content.match(CLAUSE_PATTERN) ?? [content]).flatMap((clause) => {\n    const parts = clause\n      .split(CLAIM_COORD_SPLIT)\n      .map((part) => part.trim())\n      .filter((part) => part.length > 0);\n    return parts.length > 0 ? parts : [clause];\n  });\n}\n\nfunction clauseOverlap(clauseTokens: readonly string[], target: string) {\n  const has = tokenPool(tokenize(target));\n  const shared = clauseTokens.filter(has).length;\n  return { shared, ratio: clauseTokens.length === 0 ? 0 : shared / clauseTokens.length };\n}\n\n/** What a quote clause's first negator governs: the words after it. */\nfunction negatedScope(clause: string): string {\n  const match = NEGATOR_PATTERN.exec(clause.replace(/[\\u2018\\u2019]/gu, \"'\"));\n  return match ? clause.slice(match.index + match[0].length) : clause;\n}\n\n/**\n * True when the claim asserts what a quote clause denies or does not assert:\n * \"did not approve the budget\" or \"denied approving it\" restated as \"approved\n * the budget\", \"suspects Bob stole funds\" or \"Is Alice the CEO?\" restated as a\n * plain statement. The claim must restate the quote clause, and none of its\n * clauses that share a word with what the negator governs may keep the\n * negator, exclusion word, or reporting marker (\"do not X\" reworded as \"X is\n * excluded\", or \"Alice reviewed it, but she did not approve it\"). A negator in\n * a clause about something else does not count, so a claim that keeps one\n * quote negation can still misstate another quote clause, and a claim clause\n * that shares only the subject does not satisfy the check.\n */\nfunction misstatesQuote(content: string, quote: string): boolean {\n  const claimClauses = splitClaimClauses(content);\n  return (quote.match(CLAUSE_PATTERN) ?? []).some((quoteClause) => {\n    const needsNegation = hasNegation(quoteClause);\n    const needsReporting = quoteClause.trim().endsWith(\"?\") || hasNonAssertiveReporting(quoteClause);\n    if (!needsNegation && !needsReporting) return false;\n    const clauseTokens = [...tokenize(quoteClause)];\n    const whole = clauseOverlap(clauseTokens, content);\n    if (whole.shared < GROUNDING_MIN_SHARED_TOKENS || whole.ratio < 0.5) return false;\n    const clausesSharing = (tokens: readonly string[]) =>\n      claimClauses.filter((claimClause) => clauseOverlap(tokens, claimClause).shared > 0);\n    if (needsNegation) {\n      const scopeTokens = [...tokenize(negatedScope(quoteClause))];\n      const related = clausesSharing(scopeTokens.length > 0 ? scopeTokens : clauseTokens);\n      if (!related.some((text) => hasNegation(text) || EXCLUSION_PATTERN.test(text))) return true;\n    }\n    return needsReporting\n      && !clausesSharing(clauseTokens).some((text) => hasNonAssertiveReporting(text) || text.trim().endsWith(\"?\"));\n  });\n}\n\n/**\n * A claim is supported by a verbatim quote when it shares at least\n * GROUNDING_MIN_SHARED_TOKENS content words with the quote, a good part of its\n * words sit in the text around the quote, nearly all of them occur in the\n * source at all, and it does not invert a negated clause of the quote. Reworded\n * and lightly elaborated claims pass; claims that bring words the conversation\n * never used, or that have nothing to do with the quote, do not.\n */\nexport function isQuoteAnchoredClaim(content: string, anchor: QuoteAnchor, sourceHas: TokenPool): boolean {\n  const contentTokens = [...tokenize(content)];\n  if (contentTokens.length === 0) return false;\n  const quoteHas = tokenPool(tokenize(anchor.quote));\n  if (contentTokens.filter(quoteHas).length < GROUNDING_MIN_SHARED_TOKENS) return false;\n  const windowHas = tokenPool(tokenize(anchor.window));\n  if (contentTokens.filter(windowHas).length / contentTokens.length < QUOTE_ANCHOR_MIN_WINDOW_COVERAGE) {\n    return false;\n  }\n  return contentTokens.filter(sourceHas).length / contentTokens.length >= QUOTE_ANCHOR_MIN_SOURCE_COVERAGE\n    && !misstatesQuote(content, anchor.quote);\n}\n\n/** Keeps the entity facts (flat and sectioned) `isSupported` accepts; undefined when none remain. */\nexport function filterEntityFacts(entity: Entity, isSupported: (fact: string) => boolean): Entity | undefined {\n  const facts = entity.facts.filter(isSupported);\n  const structuredSections = entity.structuredSections?.flatMap((section) => {\n    const groundedFacts = section.facts.filter(isSupported);\n    return groundedFacts.length > 0 ? [{ ...section, facts: groundedFacts }] : [];\n  });\n  if (facts.length === 0 && (structuredSections === undefined || structuredSections.length === 0)) {\n    return undefined;\n  }\n  const { structuredSections: _structuredSections, ...entityWithoutSections } = entity;\n  return {\n    ...entityWithoutSections,\n    facts,\n    ...(structuredSections && structuredSections.length > 0 ? { structuredSections } : {}),\n  };\n}\n\n/**\n * Entities carry no quote of their own; the anchors of facts that kept support\n * them. Returns a fact predicate, or undefined when no anchor window names the entity.\n */\nexport function quoteAnchoredEntitySupport(\n  entity: Entity,\n  anchors: readonly QuoteAnchor[],\n  sourceHas: TokenPool,\n): ((fact: string) => boolean) | undefined {\n  const nameAnchors = anchors.filter((anchor) => isGroundedEntityName(entity.name, anchor.window));\n  if (nameAnchors.length === 0) return undefined;\n  return (fact) => nameAnchors.some((anchor) => isQuoteAnchoredClaim(fact, anchor, sourceHas));\n}\n\n/**\n * The label words and both names must sit in one anchor-window sentence, source\n * before target, so an invented label or a reversed edge never passes.\n */\nexport function isQuoteAnchoredRelationship(\n  relationship: Relationship,\n  anchors: readonly QuoteAnchor[],\n  sourceHas: TokenPool,\n): boolean {\n  const labelTokens = [...tokenize(relationship.label)];\n  if (labelTokens.length === 0) return false;\n  const relationText = [\n    normalizedEntityIdentifierTokens(relationship.source).join(\" \"),\n    relationship.label,\n    normalizedEntityIdentifierTokens(relationship.target).join(\" \"),\n  ].join(\" \");\n  return anchors.some((anchor) => {\n    const windowHas = tokenPool(tokenize(anchor.window));\n    return labelTokens.every(windowHas)\n      && sourceSentences(anchor.window).some((sentence) => {\n        const sourceStart = entityNameStart(relationship.source, sentence);\n        return sourceStart >= 0 && entityNameStart(relationship.target, sentence) > sourceStart;\n      })\n      && isQuoteAnchoredClaim(relationText, anchor, sourceHas);\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-3JPTUCD7.js → chunk-EUBDYOLD.js}

@@ -1,25 +1,25 @@
 import {
   ExtractionDrain,
   TurnIngestionCoordinator
-} from "./chunk-HLKUZW42.js";
+} from "./chunk-3CTKEXXF.js";
 import {
   headerConnector,
   renderExtractionConversation,
   resolveSourceConnector
-} from "./chunk-QZBTIYKD.js";
+} from "./chunk-BLSHFIR6.js";
 import {
   SmartBuffer
-} from "./chunk-XYP5WBDO.js";
+} from "./chunk-TQ4SCPGQ.js";
 import {
   shouldSkipImplicitExtraction
-} from "./chunk-RZH5RVJC.js";
+} from "./chunk-MTTYIXSU.js";
 import {
   selfDeps
-} from "./chunk-WAD32CZG.js";
+} from "./chunk-CC4V7HNP.js";
 import {
   describeError,
   groupTurnsByExtractionScope
-} from "./chunk-4KLQI3L2.js";
+} from "./chunk-UXXK523X.js";
 import {
   resolveMemoryLifecycleCapabilities
 } from "./chunk-C5LWPYS3.js";
@@ -46,38 +46,41 @@ var ClaimBufferStorage = class {
     this.claims = claims;
     this.key = key;
     this.ownerId = ownerId;
-    this.entry = entry;
+    this.seen = entry;
   }
   claims;
   key;
   ownerId;
-  entry;
+  seen;
   async loadBuffer() {
     const entries = /* @__PURE__ */ Object.create(null);
     entries[this.key] = {
-      turns: this.entry.turns,
-      retainedTurns: this.entry.retainedTurns,
-      lastExtractionAt: this.entry.lastExtractionAt,
-      extractionCount: this.entry.extractionCount
+      turns: this.seen.turns,
+      retainedTurns: this.seen.retainedTurns,
+      lastExtractionAt: this.seen.lastExtractionAt,
+      extractionCount: this.seen.extractionCount
     };
     return {
-      turns: this.entry.turns,
-      lastExtractionAt: this.entry.lastExtractionAt,
-      extractionCount: this.entry.extractionCount,
+      turns: this.seen.turns,
+      lastExtractionAt: this.seen.lastExtractionAt,
+      extractionCount: this.seen.extractionCount,
       entries
     };
   }
   async saveBuffer(state) {
     const entry = state.entries?.[this.key];
-    await this.claims.writeEntry(
-      this.key,
-      this.ownerId,
-      entry ?? { turns: [], lastExtractionAt: null, extractionCount: 0 },
-      this.entry
-    );
+    await this.writeProgress(entry ?? { turns: [], lastExtractionAt: null, extractionCount: 0 });
   }
   async saveBufferSession(key, entry) {
-    await this.claims.writeEntry(key, this.ownerId, entry, key === this.key ? this.entry : void 0);
+    if (key !== this.key) {
+      await this.claims.writeEntry(key, this.ownerId, entry, void 0);
+      return;
+    }
+    await this.writeProgress(entry);
+  }
+  async writeProgress(entry) {
+    await this.claims.writeEntry(this.key, this.ownerId, entry, this.seen);
+    this.seen = { ...entry, turns: [...entry.turns], retainedTurns: entry.retainedTurns ? [...entry.retainedTurns] : void 0 };
   }
   async deleteBufferSession() {
   }
@@ -330,12 +333,18 @@ function drainAbortSignal(callerSignal, abort) {
   return callerSignal ? AbortSignal.any([callerSignal, abort.signal]) : abort.signal;
 }
 async function runClaimDrain(ctx, options, heartbeat) {
+  const reconcileDrainedTurns = async () => {
+    const drained = await ctx.claims.drainedTurnsForOwner(ctx.key, ctx.ownerId);
+    if (drained !== null) await ctx.orchestrator.buffer.save({ key: ctx.key, drained });
+  };
   if (ctx.turns.length === 0) {
+    await reconcileDrainedTurns();
     const outcome2 = await ackEmptyClaim(ctx.claims, ctx.key, ctx.ownerId, ctx.turnsAtStart);
     options.onEvent?.({ type: "session_finished", key: ctx.key, outcome: outcome2 });
     return outcome2;
   }
   const { groupOutcomes, groupError } = await drainScopeGroups(ctx);
+  await reconcileDrainedTurns();
   const remaining = await ctx.claims.load(ctx.key);
   const { status, reason, turnsRemaining } = await settleDrainVerdict(
     ctx.claims,
@@ -440,4 +449,4 @@ export {
   ClaimBufferStorage,
   BufferDrainRunner
 };
-//# sourceMappingURL=chunk-3JPTUCD7.js.map
+//# sourceMappingURL=chunk-EUBDYOLD.js.map

package/dist/chunk-EUBDYOLD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/orchestration/buffer-drain-runner.ts"],"sourcesContent":["/** Claim-backed extraction-buffer drain (`remnic buffer drain` worker AND the */\n\nimport { hostname } from \"node:os\";\nimport type { BufferStorage } from \"../buffer-persistence.js\";\nimport { type ExtractionScopeGroup, describeError, groupTurnsByExtractionScope } from \"../buffer-turn-helpers.js\";\nimport { SmartBuffer } from \"../buffer.js\";\nimport { resolveMemoryLifecycleCapabilities } from \"../capabilities.js\";\nimport { shouldSkipImplicitExtraction } from \"../explicit-capture.js\";\nimport { log } from \"../logger.js\";\nimport type { ResolvedScopeProfilePlan } from \"../namespaces/scope-profiles.js\";\nimport type { Orchestrator } from \"../orchestrator.js\";\nimport { headerConnector, renderExtractionConversation, resolveSourceConnector } from \"../source-agent-qualifier.js\";\nimport type { BufferDrainClaims, DrainLease } from \"../storage/buffer-drain-claims.js\";\nimport type { BufferEntryState, BufferState, BufferTurn, PluginConfig } from \"../types.js\";\nimport { ExtractionDrain } from \"./extraction-drain.js\";\nimport type { ExtractionRunResult } from \"./extraction-run.js\";\nimport { selfDeps } from \"./self-deps.js\";\nimport { TurnIngestionCoordinator, type TurnIngestionDeps } from \"./turn-ingestion.js\";\n\nexport type DrainSessionStatus = \"drained\" | \"deferred\" | \"failed\" | \"skipped\";\n\nexport interface DrainSessionOutcome {\n  key: string;\n  status: DrainSessionStatus;\n  /** Turns the claim held when the drain started. */\n  turnsAtStart: number;\n  /** Turns still in the claim when the drain stopped. */\n  turnsRemaining: number;\n  /** Facts the extraction persisted during this run. */\n  persistedCount: number;\n  /** Durable outputs (memories + entities) the extraction wrote. */\n  durableOutputCount: number;\n  /** Why the session was skipped or deferred (machine-readable). */\n  reason?: string;\n  /** Current-policy denials: scope groups whose authorization no longer holds. */\n  denied?: { reason: string; turns: number }[];\n}\n\n/** Extraction results that mean \"current policy refuses this scope\": the\n * turns are valid backlog whose captured scope is no longer writable. */\nconst DENIED_SCOPE_REASONS: ReadonlySet<string> = new Set([\n  \"pinned_namespace_unavailable\",\n  \"namespace_write_revoked\",\n  \"scope_profile_revoked\",\n  // The resolved profile has no writable layer: the same current-policy\n  // refusal family, surfaced from inside the shared runExtraction gate.\n  \"scope_profile_no_writable_layer\",\n  // captureMode=explicit: ordinary buffered conversation turns never create\n  // memories; only deliberately accepted captures drain.\n  \"capture_mode_explicit\",\n]);\n\nexport interface BufferDrainRunnerOptions {\n  /** Identity of this drainer; owns the lease it takes. */\n  ownerId: string;\n  /** Lease lifetime in ms. The heartbeat keeps it alive while draining. */\n  leaseMs?: number;\n  /** Cancels the run at the next chunk boundary. */\n  signal?: AbortSignal;\n  /** Progress callback (per session, and per claim transition). */\n  onEvent?: (event: DrainRunnerEvent) => void;\n}\n\n/** A failed drain run: the reason a chunk or the session could not finish. */\nexport type DrainExtractionError = Error;\n\nexport type DrainRunnerEvent =\n  | { type: \"session_started\"; key: string; turns: number }\n  | { type: \"session_finished\"; key: string; outcome: DrainSessionOutcome };\n\nconst DEFAULT_LEASE_MS = 120_000;\n\n/**\n * A `BufferStorage` view of one drain claim: the claim file IS the buffer.\n * Writes are the drain's progress (what is left to extract), so every\n * successfully extracted chunk is durably removed before the next one runs.\n *\n * `seen` is the drainer's own view of the claim: the entry it loaded, then the\n * entry it last wrote. Each progress write is diffed against it, so a write\n * records only the turns extracted since the previous one.\n */\nexport class ClaimBufferStorage implements BufferStorage {\n  private seen: BufferEntryState;\n\n  constructor(\n    private readonly claims: BufferDrainClaims,\n    private readonly key: string,\n    private readonly ownerId: string,\n    entry: BufferEntryState\n  ) {\n    this.seen = entry;\n  }\n\n  async loadBuffer(): Promise<BufferState> {\n    const entries: NonNullable<BufferState[\"entries\"]> = Object.create(null);\n    entries[this.key] = {\n      turns: this.seen.turns,\n      retainedTurns: this.seen.retainedTurns,\n      lastExtractionAt: this.seen.lastExtractionAt,\n      extractionCount: this.seen.extractionCount,\n    };\n    return {\n      turns: this.seen.turns,\n      lastExtractionAt: this.seen.lastExtractionAt,\n      extractionCount: this.seen.extractionCount,\n      entries,\n    };\n  }\n\n  async saveBuffer(state: BufferState): Promise<void> {\n    // Whole-state fallback (the claim covers one session): persist the entry.\n    const entry = state.entries?.[this.key];\n    await this.writeProgress(entry ?? { turns: [], lastExtractionAt: null, extractionCount: 0 });\n  }\n\n  async saveBufferSession(key: string, entry: BufferEntryState): Promise<void> {\n    if (key !== this.key) {\n      await this.claims.writeEntry(key, this.ownerId, entry, undefined);\n      return;\n    }\n    await this.writeProgress(entry);\n  }\n\n  private async writeProgress(entry: BufferEntryState): Promise<void> {\n    await this.claims.writeEntry(this.key, this.ownerId, entry, this.seen);\n    // Copy the lists: the buffer keeps mutating its own arrays after a save.\n    this.seen = { ...entry, turns: [...entry.turns], retainedTurns: entry.retainedTurns ? [...entry.retainedTurns] : undefined };\n  }\n\n  async deleteBufferSession(): Promise<void> {\n    // The claim is removed by the ack path, never by a buffer eviction: the\n    // drain decides when the session is finished.\n  }\n}\n\n/** Per-invocation isolated execution context for one claim drain. */\ninterface ClaimDrainExecution {\n  claimBuffer: SmartBuffer;\n  coordinator: TurnIngestionCoordinator;\n  executionDrain: ExtractionDrain;\n}\n\n/** The scopeProfileWritePlan option a scope group forwards to the queue. */\ninterface GroupPlanOption {\n  scopeProfileWritePlan?: ResolvedScopeProfilePlan | null;\n}\n\n/** Durable counters a drain pass contributed. */\ninterface GroupCounts {\n  persistedCount: number;\n  durableOutputCount: number;\n}\n\n/** Pending turns across canonical + retained copies (the honest backlog count). */\nfunction pendingTurnCount(entry: BufferEntryState | undefined): number {\n  if (!entry) return 0;\n  return entry.turns.length + (entry.retainedTurns?.length ?? 0);\n}\n\n/** Load one claimed session. An unclaimed key is nothing to drain. */\nasync function loadClaimedSession(\n  claims: BufferDrainClaims,\n  key: string\n): Promise<\n  | { kind: \"notClaimed\"; notClaimed: DrainSessionOutcome }\n  | { kind: \"claimed\"; claim: { entry: BufferEntryState }; turnsAtStart: number }\n> {\n  const claim = await claims.load(key);\n  if (!claim) {\n    return {\n      kind: \"notClaimed\",\n      notClaimed: {\n        key,\n        status: \"skipped\",\n        turnsAtStart: 0,\n        turnsRemaining: 0,\n        persistedCount: 0,\n        durableOutputCount: 0,\n        reason: \"not_claimed\",\n      },\n    };\n  }\n  return { kind: \"claimed\", claim, turnsAtStart: pendingTurnCount(claim.entry) };\n}\n\nfunction busyLeaseOutcome(key: string, turnsAtStart: number): DrainSessionOutcome {\n  return {\n    key,\n    status: \"skipped\",\n    turnsAtStart,\n    turnsRemaining: turnsAtStart,\n    persistedCount: 0,\n    durableOutputCount: 0,\n    reason: \"claimed_by_another_drain\",\n  };\n}\n\n/** Take the lease unless this drainer already holds it. A busy lease means\n *  another drainer owns the claim — skip without touching content. */\nasync function adoptLease(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  leaseMs: number\n): Promise<DrainSessionOutcome | null> {\n  const held = await claims.adopt(key, {\n    ownerId,\n    pid: process.pid,\n    host: hostname(),\n    acquiredAt: new Date().toISOString(),\n    heartbeatAt: new Date().toISOString(),\n    leaseMs,\n  });\n  return held === \"busy\" ? busyLeaseOutcome(key, pendingTurnCount((await claims.load(key))?.entry)) : null;\n}\n\nfunction assembleOutcome(\n  key: string,\n  turnsAtStart: number,\n  verdict: { status: DrainSessionStatus; reason?: string; turnsRemaining: number },\n  counts: { persistedCount: number; durableOutputCount: number },\n  denied: Map<string, number>\n): DrainSessionOutcome {\n  const outcome: DrainSessionOutcome = {\n    key,\n    status: verdict.status,\n    turnsAtStart,\n    turnsRemaining: verdict.turnsRemaining,\n    persistedCount: counts.persistedCount,\n    durableOutputCount: counts.durableOutputCount,\n  };\n  if (denied.size > 0) outcome.denied = [...denied].map(([deniedReason, turns]) => ({ reason: deniedReason, turns }));\n  if (verdict.reason !== undefined) outcome.reason = verdict.reason;\n  return outcome;\n}\n\n/** Ack an EMPTY claim. The ack verdict is the truth: live ingress can merge\n *  between the empty read and the ack — a not_empty ack means pending work\n *  exists; reload it, release OUR lease, report deferred, never a false\n *  drained. */\nasync function ackEmptyClaim(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  turnsAtStart: number\n): Promise<DrainSessionOutcome> {\n  const ackOutcome = await claims.ack(key, ownerId);\n  if (ackOutcome !== \"acked\") {\n    const reloaded = await claims.load(key);\n    const turnsRemaining = pendingTurnCount(reloaded?.entry);\n    await claims.releaseLease(key, ownerId);\n    return {\n      key,\n      status: \"deferred\",\n      turnsAtStart,\n      turnsRemaining,\n      persistedCount: 0,\n      durableOutputCount: 0,\n      reason: ackOutcome === \"not_empty\" ? \"ack_not_empty\" : \"ack_not_owner\",\n    };\n  }\n  return { key, status: \"drained\", turnsAtStart, turnsRemaining: 0, persistedCount: 0, durableOutputCount: 0 };\n}\n\n/** another drainer took the claim, so this run must stop instead of writing */\nfunction startLeaseHeartbeat(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  leaseMs: number,\n  abort: AbortController\n): NodeJS.Timeout {\n  const heartbeat = setInterval(\n    () => {\n      void claims\n        .heartbeat(key, ownerId, leaseMs)\n        .then((state) => {\n          if (state === \"lost\") abort.abort(new Error(`buffer drain: lease lost for session ${key}`));\n        })\n        .catch((err: Error) => {\n          // A heartbeat that cannot be renewed is a lease that cannot be held:\n          // stop this run cleanly at the next chunk boundary (the next run\n          // resumes it).\n          abort.abort(new Error(`buffer drain: lease heartbeat failed for session ${key}: ${describeError(err)}`));\n        });\n    },\n    Math.max(1_000, Math.floor(leaseMs / 3))\n  );\n  heartbeat.unref?.();\n  return heartbeat;\n}\n\n/** coordinator bound to it, and the no-drop chunked drain. Built per */\nfunction buildClaimExecution(\n  orchestrator: Orchestrator,\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  claim: { entry: BufferEntryState }\n): ClaimDrainExecution {\n  const claimBuffer = new SmartBuffer(orchestrator.config, new ClaimBufferStorage(claims, key, ownerId, claim.entry));\n  const isolatedRun = orchestrator.extractionRunCoordinatorForBuffer(claimBuffer);\n  const coordinator = new TurnIngestionCoordinator(selfDeps<TurnIngestionDeps>(orchestrator));\n  const config = orchestrator.config;\n  const ingestionDeps = selfDeps<TurnIngestionDeps>(orchestrator);\n  // No-drop: a repeatedly failing chunk stays in the claim as durable\n  // retryable backlog — never side-filed, never counted as processed.\n  const executionDrain = new ExtractionDrain(\n    {\n      config: {\n        extractionMinUserTurns: config.extractionMinUserTurns,\n        extractionMinChars: config.extractionMinChars,\n        extractionMaxTurnChars: config.extractionMaxTurnChars,\n        extractionChunkDropAfterFailures: config.extractionChunkDropAfterFailures,\n      },\n      extractionWindowBudgetChars: () => ingestionDeps.extractionWindowBudgetChars?.() ?? Number.POSITIVE_INFINITY,\n      // Render-exact chunk sizing: the model clamp bounds the CONVERSATION\n      // (truncateLocalExtractionConversation), so measure exactly that —\n      // with the SAME source-classification gate extract() applies when it\n      // prepends the connector header (header margin included when the\n      // engine would render it).\n      measureRenderedTurns: (turns) => {\n        const sourceConnector = resolveMemoryLifecycleCapabilities(config).extractionScopeClassification\n          ? resolveSourceConnector(turns)\n          : undefined;\n        return renderExtractionConversation(\n          turns.map((turn) => ({ ...turn, content: turn.content.trim().slice(0, config.extractionMaxTurnChars) })),\n          headerConnector(sourceConnector)\n        ).conversation.length;\n      },\n      runExtraction: (turns, runOptions) => isolatedRun.runExtraction(turns, runOptions),\n      getStorage: () => ingestionDeps.getStorage(),\n      buffer: claimBuffer,\n    },\n    { dropFailedChunks: false }\n  );\n  return { claimBuffer, coordinator, executionDrain };\n}\n\n/** Plan semantics for one scope group: a pinned plan forwards as-is; a\n *  planless ACCEPTED group pins null (existing flush behavior); unpinned\n *  legacy groups pass NO option so runExtraction resolves the CURRENT\n *  profile. */\nfunction planOptionForGroup(group: ExtractionScopeGroup): GroupPlanOption {\n  if (group.scopeProfileWritePlan !== undefined) return { scopeProfileWritePlan: group.scopeProfileWritePlan };\n  if (group.turns.some((turn) => turn.acceptedCapture === true)) return { scopeProfileWritePlan: null };\n  return {};\n}\n\n/** captureMode=explicit: ordinary buffered conversation turns never create\n *  memories — only deliberately accepted captures drain. */\nfunction explicitModeDenied(group: ExtractionScopeGroup, config: PluginConfig): boolean {\n  return shouldSkipImplicitExtraction(config) && !group.turns.some((turn) => turn.acceptedCapture === true);\n}\n\ninterface GroupOutcome {\n  turns: number;\n  result?: ExtractionRunResult;\n}\n\ninterface ScopeDrainContext {\n  config: PluginConfig;\n  key: string;\n  signal: AbortSignal;\n  claimBuffer: SmartBuffer;\n  coordinator: TurnIngestionCoordinator;\n  executionDrain: ExtractionDrain;\n  turns: BufferTurn[];\n}\n\n/** Drain a claimed session's turns ONE captured-scope group at a time: each\n *  group keeps its own namespace/principal/plan pins, and the shared\n *  extraction boundary re-applies CURRENT authorization from the turn's\n *  ORIGINAL coding binding before any write. Groups run sequentially (FIFO\n *  per key — the queue's same-key exclusion would serialize them anyway); a\n *  denied group never blocks or clears the other groups. */\nasync function drainScopeGroups(\n  ctx: ScopeDrainContext\n): Promise<{ groupOutcomes: GroupOutcome[]; groupError?: DrainExtractionError }> {\n  const groupOutcomes: GroupOutcome[] = [];\n  let groupError: DrainExtractionError | undefined;\n  for (const group of groupTurnsByExtractionScope(ctx.turns)) {\n    if (ctx.signal.aborted) break;\n    if (explicitModeDenied(group, ctx.config)) {\n      log.warn(\n        `buffer drain: session ${ctx.key} denied capture_mode_explicit (${group.turns.length} ordinary turn(s) retained)`\n      );\n      groupOutcomes.push({\n        turns: group.turns.length,\n        result: { status: \"skipped\", reason: \"capture_mode_explicit\", persistedCount: 0, durableOutputCount: 0 },\n      });\n      continue;\n    }\n    const settleGate = Promise.withResolvers<{ cause?: unknown; result?: ExtractionRunResult }>();\n    let done = false;\n    const onSettle = (cause: unknown, result?: ExtractionRunResult): void => {\n      if (done) return;\n      done = true;\n      settleGate.resolve({ cause, result });\n    };\n    // Settlement and callback EXIT are tracked separately: the lease is\n    // released only after BOTH the queued closure settled and fully exited\n    // (an abort settles through its listener while the closure may still be\n    // persisting).\n    const exited = Promise.withResolvers<void>();\n    void ctx.coordinator\n      .queueBufferedExtraction(group.turns, \"trigger_mode\", {\n        bufferKey: ctx.key,\n        clearBufferAfterExtraction: true,\n        clearMatchingTurns: true,\n        skipDedupeCheck: true,\n        skipCharThreshold: true,\n        skipUserTurnThreshold: true,\n        // Automatic background work yields to fail-closed foreground flushes\n        // (preemptRunning), same as the live trigger path.\n        preemptable: true,\n        abortSignal: ctx.signal,\n        writeNamespaceOverride: group.writeNamespaceOverride,\n        principalOverride: group.principalOverride,\n        ...planOptionForGroup(group),\n        execution: { buffer: ctx.claimBuffer, drain: ctx.executionDrain },\n        onTaskSettled: (error, result) => settleGate.resolve({ cause: error, result }),\n        onTaskExit: () => exited.resolve(),\n      })\n      .catch((cause: DrainExtractionError) => onSettle(cause));\n    const [verdict] = await Promise.all([settleGate.promise, exited.promise]);\n    const settled = verdict;\n    if (settled.cause !== undefined) {\n      // SAFETY: settle captures whatever the queued closure rejected with;\n      // every drain rejection site throws Error values, and a rejection is\n      // always a DrainExtractionError in this path.\n      groupError = settled.cause as Error;\n      break;\n    }\n    groupOutcomes.push({ turns: group.turns.length, result: settled.result });\n  }\n  return { groupOutcomes, groupError };\n}\n\n/** Denied scope groups: policy refusals leave their turns pending (the group\n *  result's turns were NOT cleared), aggregated per reason so a drain is\n *  never reported complete while denied backlog remains. */\nfunction deniedByReason(groupOutcomes: readonly GroupOutcome[]): Map<string, number> {\n  const denied = new Map<string, number>();\n  for (const entry of groupOutcomes) {\n    if (entry.result?.status !== \"skipped\" || !DENIED_SCOPE_REASONS.has(entry.result.reason ?? \"\")) continue;\n    denied.set(entry.result.reason!, (denied.get(entry.result.reason!) ?? 0) + entry.turns);\n  }\n  return denied;\n}\n\nfunction lastGroupReason(groupOutcomes: readonly GroupOutcome[]): string | undefined {\n  for (let index = groupOutcomes.length - 1; index >= 0; index -= 1) {\n    const reason = groupOutcomes[index]?.result?.reason;\n    if (reason !== undefined) return reason;\n  }\n  return undefined;\n}\n\n/** the session file is gone for good — but the ack verdict is the truth (live */\nasync function settleDrainVerdict(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string,\n  groupOutcomes: readonly GroupOutcome[],\n  groupError: DrainExtractionError | undefined,\n  turnsRemaining: number\n): Promise<{ status: DrainSessionStatus; reason?: string; turnsRemaining: number }> {\n  if (turnsRemaining === 0) return await ackOrReload(claims, key, ownerId);\n  if (groupError) {\n    await claims.releaseLease(key, ownerId);\n    return { status: \"failed\", reason: describeError(groupError), turnsRemaining };\n  }\n  await claims.releaseLease(key, ownerId);\n  const reason =\n    groupOutcomes.find((entry) => entry.result?.reason !== undefined && DENIED_SCOPE_REASONS.has(entry.result.reason!))\n      ?.result?.reason ??\n    lastGroupReason(groupOutcomes) ??\n    \"deferred\";\n  return { status: \"deferred\", reason, turnsRemaining };\n}\n\n/** Ack an emptied claim; a not-acked verdict means live ingress merged (or\n *  the lease moved) — reload the honest pending count and release OUR lease,\n *  keeping the source. */\nasync function ackOrReload(\n  claims: BufferDrainClaims,\n  key: string,\n  ownerId: string\n): Promise<{ status: DrainSessionStatus; reason?: string; turnsRemaining: number }> {\n  const ackOutcome = await claims.ack(key, ownerId);\n  if (ackOutcome === \"acked\") return { status: \"drained\", turnsRemaining: 0 };\n  const reloaded = await claims.load(key);\n  const turnsRemaining = pendingTurnCount(reloaded?.entry);\n  await claims.releaseLease(key, ownerId);\n  return { status: \"deferred\", reason: ackOutcome === \"not_empty\" ? \"ack_not_empty\" : \"ack_not_owner\", turnsRemaining };\n}\n\nfunction groupCounts(groupOutcomes: readonly GroupOutcome[]): GroupCounts {\n  return {\n    persistedCount: groupOutcomes.reduce((sum, entry) => sum + (entry.result?.persistedCount ?? 0), 0),\n    durableOutputCount: groupOutcomes.reduce((sum, entry) => sum + (entry.result?.durableOutputCount ?? 0), 0),\n  };\n}\n\nexport interface DrainScanEntry {\n  key: string;\n  turns: number;\n  claimed: boolean;\n}\n\n/** Session-buffer listings: a claimed session reports its CLAIM's pending\n *  count (the live buffer copy may lag the claim), an unclaimed one its\n *  buffer entry. */\nasync function bufferSessionListings(\n  claims: BufferDrainClaims,\n  entries: Record<string, BufferEntryState>\n): Promise<{ listings: DrainScanEntry[]; seen: Set<string> }> {\n  const listings: DrainScanEntry[] = [];\n  const seen = new Set<string>();\n  for (const [key, entry] of Object.entries(entries)) {\n    seen.add(key);\n    const claim = claims.isClaimed(key) ? await claims.load(key) : null;\n    listings.push({\n      key,\n      turns: claim ? pendingTurnCount(claim.entry) : pendingTurnCount(entry),\n      claimed: claim !== null,\n    });\n  }\n  return { listings, seen };\n}\n\n/** Claims the buffer state no longer lists (drained by an earlier run whose\n *  claim file outlived its session file). */\nasync function orphanClaimListings(claims: BufferDrainClaims, seen: Set<string>): Promise<DrainScanEntry[]> {\n  const out: DrainScanEntry[] = [];\n  for (const listed of await claims.list()) {\n    if (seen.has(listed.key)) continue;\n    out.push({ key: listed.key, turns: listed.turnCount, claimed: true });\n  }\n  return out;\n}\n\n/** The drain runs on the caller's abort signal combined with this run's own\n *  lease-loss controller. */\nfunction drainAbortSignal(callerSignal: AbortSignal | undefined, abort: AbortController): AbortSignal {\n  return callerSignal ? AbortSignal.any([callerSignal, abort.signal]) : abort.signal;\n}\n\n/** One heartbeat-protected claim drain: run every scope group, settle the\n *  verdict against the claim store, and assemble the honest outcome. The\n *  heartbeat is cleared by the caller on every exit path. */\nasync function runClaimDrain(\n  ctx: {\n    orchestrator: Orchestrator;\n    claims: BufferDrainClaims;\n    key: string;\n    ownerId: string;\n    claimBuffer: SmartBuffer;\n    coordinator: TurnIngestionCoordinator;\n    executionDrain: ExtractionDrain;\n    turns: BufferTurn[];\n    turnsAtStart: number;\n    config: PluginConfig;\n    signal: AbortSignal;\n  },\n  options: BufferDrainRunnerOptions,\n  heartbeat: NodeJS.Timeout\n): Promise<DrainSessionOutcome> {\n  // Reconcile only identities recorded as durably extracted under this\n  // owner's claim lease. The claim lock is released before entering the live\n  // buffer mutation queue, preserving the buffer→claim lock order used by\n  // concurrent ingress saves.\n  const reconcileDrainedTurns = async (): Promise<void> => {\n    const drained = await ctx.claims.drainedTurnsForOwner(ctx.key, ctx.ownerId);\n    if (drained !== null) await ctx.orchestrator.buffer.save({ key: ctx.key, drained });\n  };\n\n  // An emptied claim acks here: the ack verdict is the truth (drained), or\n  // live ingress merged between the read and the ack — deferred, source kept.\n  if (ctx.turns.length === 0) {\n    await reconcileDrainedTurns();\n    const outcome = await ackEmptyClaim(ctx.claims, ctx.key, ctx.ownerId, ctx.turnsAtStart);\n    options.onEvent?.({ type: \"session_finished\", key: ctx.key, outcome });\n    return outcome;\n  }\n  const { groupOutcomes, groupError } = await drainScopeGroups(ctx);\n  await reconcileDrainedTurns();\n  // Heartbeat cleared on EVERY exit path: a rejected drain must not keep\n  // renewing the lease forever (cleared in the caller's finally).\n  const remaining = await ctx.claims.load(ctx.key);\n  const { status, reason, turnsRemaining } = await settleDrainVerdict(\n    ctx.claims,\n    ctx.key,\n    ctx.ownerId,\n    groupOutcomes,\n    groupError,\n    pendingTurnCount(remaining?.entry)\n  );\n  const outcome = assembleOutcome(\n    ctx.key,\n    ctx.turnsAtStart,\n    { status, reason, turnsRemaining },\n    groupCounts(groupOutcomes),\n    deniedByReason(groupOutcomes)\n  );\n  log.info(`buffer drain: session ${ctx.key} ${status} (${outcome.turnsRemaining} turn(s) remaining)`);\n  options.onEvent?.({ type: \"session_finished\", key: ctx.key, outcome });\n  return outcome;\n}\n\nexport class BufferDrainRunner {\n  constructor(private readonly orchestrator: Orchestrator) {}\n\n  /** The claim store of this orchestrator's memory root. */\n  get claims(): BufferDrainClaims {\n    return this.orchestrator.storage.bufferDrainClaims();\n  }\n\n  /**\n   * Drain one claimed session. The caller owns the lease (it may have taken\n   * it already); this method verifies ownership before touching content.\n   */\n  async drainSession(key: string, options: BufferDrainRunnerOptions): Promise<DrainSessionOutcome> {\n    const claims = this.claims;\n    const leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;\n    const claimed = await loadClaimedSession(claims, key);\n    if (claimed.kind === \"notClaimed\") return claimed.notClaimed;\n    const { claim, turnsAtStart } = claimed;\n    options.onEvent?.({ type: \"session_started\", key, turns: turnsAtStart });\n\n    // Take the lease unless this drainer already holds it.\n    const busy = await adoptLease(claims, key, options.ownerId, leaseMs);\n    if (busy !== null) {\n      const outcome = busy;\n      options.onEvent?.({ type: \"session_finished\", key, outcome });\n      return outcome;\n    }\n\n    // The claim is the buffer for this run: every successful chunk is removed\n    // from it, so a kill leaves exactly the un-extracted turns.\n    const { claimBuffer, coordinator, executionDrain } = buildClaimExecution(\n      this.orchestrator,\n      claims,\n      key,\n      options.ownerId,\n      claim\n    );\n    await claimBuffer.load();\n\n    // The claim's turns (retained first, like the live buffer's order).\n    const turns = [...(claim.entry.retainedTurns ?? []), ...claim.entry.turns];\n\n    // A lost lease means another drainer took the claim: stop instead of\n    // writing progress into a claim this run no longer owns.\n    const abort = new AbortController();\n    const signal = drainAbortSignal(options.signal, abort);\n    const heartbeat = startLeaseHeartbeat(claims, key, options.ownerId, leaseMs, abort);\n    try {\n      return await runClaimDrain(\n        {\n          orchestrator: this.orchestrator,\n          claims,\n          key,\n          ownerId: options.ownerId,\n          claimBuffer,\n          coordinator,\n          executionDrain,\n          turns,\n          turnsAtStart,\n          config: this.orchestrator.config,\n          signal,\n        },\n        options,\n        heartbeat\n      );\n    } finally {\n      clearInterval(heartbeat);\n    }\n  }\n\n  /** Claim a session file for the drain. Returns false when it is not claimable. */\n  async claim(key: string, ownerId: string, leaseMs = DEFAULT_LEASE_MS): Promise<boolean> {\n    const lease: DrainLease = {\n      ownerId,\n      pid: process.pid,\n      host: hostname(),\n      acquiredAt: new Date().toISOString(),\n      heartbeatAt: new Date().toISOString(),\n      leaseMs,\n    };\n    return (await this.claims.claimFromSessionFile(key, lease)) === \"claimed\";\n  }\n\n  /** Sessions with buffered turns, claimed or not (CLI scan). */\n  async scan(): Promise<DrainScanEntry[]> {\n    const sessions = await this.orchestrator.storage.loadBuffer();\n    const { listings, seen } = await bufferSessionListings(this.claims, sessions.entries ?? {});\n    return [...listings, ...(await orphanClaimListings(this.claims, seen))];\n  }\n}\n"],"mappings":"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","names":["outcome"]}

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-YAUHSNPB.js → chunk-F74G4KIH.js}

@@ -1,6 +1,6 @@
 import {
   rebuildMemoryProjection
-} from "./chunk-B4ZU34JQ.js";
+} from "./chunk-DT7SNJH6.js";
 
 // src/convergence-refresh.ts
 async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, getStorage, searchEnabled) {
@@ -32,4 +32,4 @@ async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, get
 export {
   refreshConvergedNamespaces
 };
-//# sourceMappingURL=chunk-YAUHSNPB.js.map
+//# sourceMappingURL=chunk-F74G4KIH.js.map

package/dist/{chunk-MPGLM2VU.js → chunk-FF3EFLUT.js}

@@ -1,17 +1,19 @@
 import {
   defineOperation
-} from "./chunk-6LCWKS62.js";
+} from "./chunk-UAUV3BWS.js";
 import {
-  EngramAccessInputError
-} from "./chunk-LGEH473S.js";
+  EngramAccessInputError,
+  rejectReservedArgumentKey
+} from "./chunk-CJCTKL6Y.js";
 
 // src/recall-navigation-operations.ts
 import { z } from "zod";
 function stripNulls(data) {
   if (data !== null && typeof data === "object" && !Array.isArray(data)) {
     const obj = data;
-    const cleaned = {};
+    const cleaned = /* @__PURE__ */ Object.create(null);
     for (const [key, value] of Object.entries(obj)) {
+      rejectReservedArgumentKey(key);
       if (value !== null) cleaned[key] = value;
     }
     return cleaned;
@@ -92,4 +94,4 @@ defineOperation({
     };
   }
 });
-//# sourceMappingURL=chunk-MPGLM2VU.js.map
+//# sourceMappingURL=chunk-FF3EFLUT.js.map

package/dist/chunk-FF3EFLUT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recall-navigation-operations.ts"],"sourcesContent":["/**\n * Recall-navigation boundary operations (issue #1956).\n *\n * `memory_expand` / `memory_traverse` route MCP, HTTP, and CLI dispatch\n * through the shared validation + error-mapping layer (access-boundary.ts)\n * to the single `EngramAccessService.recallNavigate` implementation.\n * Sibling module so access-operations-batch.ts stays at its ceiling seam\n * (same layout as deep-recall's extraction).\n */\n\nimport { z } from \"zod\";\n\nimport { defineOperation } from \"./access-boundary.js\";\nimport { EngramAccessInputError, rejectReservedArgumentKey } from \"./access-errors.js\";\n\n/**\n * Null-prototype accumulator for cleaned request arguments, matching the\n * batch preprocessors (issue #3225 B1): a copied own `__proto__` member on a\n * plain `{}` switches the accumulator's prototype and an inherited field then\n * reaches the zod parse.\n */\nfunction stripNulls(data: unknown): unknown {\n  if (data !== null && typeof data === \"object\" && !Array.isArray(data)) {\n    const obj = data as Record<string, unknown>;\n    const cleaned = Object.create(null);\n    for (const [key, value] of Object.entries(obj)) {\n      rejectReservedArgumentKey(key);\n      if (value !== null) cleaned[key] = value;\n    }\n    return cleaned;\n  }\n  return data;\n}\n\nfunction strictSchema<T extends z.ZodRawShape>(shape: T): z.ZodType<Record<string, unknown>> {\n  return z.preprocess(stripNulls, z.object(shape).passthrough()) as unknown as z.ZodType<Record<string, unknown>>;\n}\n\nconst str = z.string().optional();\n\nfunction optStr(value: unknown): string | undefined {\n  return typeof value === \"string\" ? value : undefined;\n}\n\nfunction optInt(value: unknown): number | undefined {\n  if (typeof value === \"number\") return value;\n  if (typeof value === \"string\" && Number.isFinite(Number(value))) return Number(value);\n  return undefined;\n}\n\nfunction reqStr(value: unknown, field: string): string {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new EngramAccessInputError(`${field} is required`);\n  }\n  return value;\n}\n\nconst baseShape = {\n  memoryId: z.string(),\n  sessionKey: z.string(),\n  namespace: str,\n};\n\ndefineOperation({\n  name: \"memory_expand\",\n  description: \"Re-render one already-served recall result at a deeper disclosure level (chunk → section → raw).\",\n  schema: strictSchema({ ...baseShape, disclosure: z.enum([\"chunk\", \"section\", \"raw\"]).optional() }),\n  handler: async (input, ctx) => {\n    const disclosure = optStr(input.disclosure);\n    return {\n      result: await ctx.service.recallNavigate({\n        action: \"expand\",\n        memoryId: reqStr(input.memoryId, \"memoryId\"),\n        sessionKey: reqStr(input.sessionKey, \"sessionKey\"),\n        ...(disclosure === \"chunk\" || disclosure === \"section\" || disclosure === \"raw\" ? { disclosure } : {}),\n        namespace: optStr(input.namespace),\n        authenticatedPrincipal: ctx.authenticatedPrincipal,\n      }),\n    };\n  },\n});\n\ndefineOperation({\n  name: \"memory_traverse\",\n  description:\n    \"Follow typed frontmatter links from an already-served recall result; neighbors return as chunk-level summaries.\",\n  schema: strictSchema({\n    ...baseShape,\n    relation: z\n      .enum([\n        \"supports\",\n        \"contradicts\",\n        \"elaborates\",\n        \"causes\",\n        \"caused_by\",\n        \"supersedes\",\n        \"follows\",\n        \"references\",\n        \"related\",\n      ])\n      .optional(),\n    limit: z.union([z.number(), z.string()]).optional(),\n  }),\n  handler: async (input, ctx) => {\n    const relation = optStr(input.relation);\n    return {\n      result: await ctx.service.recallNavigate({\n        action: \"traverse\",\n        memoryId: reqStr(input.memoryId, \"memoryId\"),\n        sessionKey: reqStr(input.sessionKey, \"sessionKey\"),\n        ...(relation !== undefined ? { relation } : {}),\n        limit: optInt(input.limit),\n        namespace: optStr(input.namespace),\n        authenticatedPrincipal: ctx.authenticatedPrincipal,\n      }),\n    };\n  },\n});\n"],"mappings":"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","names":[]}

package/dist/{chunk-BV2BRHD4.js → chunk-FHGWKODN.js}

@@ -21,7 +21,7 @@ import {
 import {
   CONTENT_HASH_INDEX_RETRY_MAX_DELAY_MS,
   ContentHashIndex
-} from "./chunk-KQUSP6LB.js";
+} from "./chunk-UDKWFDV2.js";
 import {
   withHeldFileLock
 } from "./chunk-EBV6VXKF.js";
@@ -2297,4 +2297,4 @@ export {
   parseTombstoneBlockedOfflineSyncMemory,
   TombstoneBlockedCaptureIndexHost
 };
-//# sourceMappingURL=chunk-BV2BRHD4.js.map
+//# sourceMappingURL=chunk-FHGWKODN.js.map

package/dist/chunk-FKBGK3NC.js

@@ -0,0 +1,62 @@
+import {
+  defaultCapsulesDir
+} from "./chunk-ZY2MNJR6.js";
+import {
+  EngramAccessInputError
+} from "./chunk-CJCTKL6Y.js";
+
+// src/capsule-import-gate.ts
+import { constants as fsConstants } from "fs";
+import { access, realpath, stat } from "fs/promises";
+import path from "path";
+import { ZodError } from "zod";
+function hasFsErrorCode(cause, code) {
+  return cause instanceof Object && "code" in cause && cause.code === code;
+}
+function isInputFsError(cause) {
+  return hasFsErrorCode(cause, "ENOENT") || hasFsErrorCode(cause, "ENOTDIR") || hasFsErrorCode(cause, "EACCES") || hasFsErrorCode(cause, "EPERM") || hasFsErrorCode(cause, "ELOOP") || hasFsErrorCode(cause, "ENAMETOOLONG") || hasFsErrorCode(cause, "ERR_INVALID_ARG_VALUE");
+}
+var ZOD_STYLE_CODE = /^Z_/;
+function hasZodStyleErrorCode(cause) {
+  return cause instanceof Object && "code" in cause && ZOD_STYLE_CODE.test(String(cause.code));
+}
+function isCapsuleImportArchiveInputError(cause, message) {
+  if (cause instanceof ZodError) return true;
+  if (hasZodStyleErrorCode(cause)) return true;
+  return message.startsWith("importCapsule: archive") || message.startsWith("importCapsule: bundle") || message.startsWith("importCapsule: manifest") || message.startsWith("importCapsule: record") || /incorrect header check|invalid stored block lengths|not in gzip format|unexpected end of file/i.test(message);
+}
+var IMPORT_SOURCE_REFUSED = "capsule import failed: archivePath must be an existing file inside the namespace capsule store";
+async function realpathOrNull(target) {
+  try {
+    return await realpath(target);
+  } catch (cause) {
+    if (!isInputFsError(cause)) throw cause;
+    return null;
+  }
+}
+function isInsideDirectory(directory, target) {
+  const rel = path.relative(directory, target);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
+}
+async function validateCapsuleImportArchive(archivePath, storageDir) {
+  const storeReal = await realpathOrNull(defaultCapsulesDir(storageDir));
+  const archiveReal = await realpathOrNull(archivePath);
+  if (storeReal === null || archiveReal === null || !isInsideDirectory(storeReal, archiveReal)) {
+    throw new EngramAccessInputError(IMPORT_SOURCE_REFUSED);
+  }
+  if (!(await stat(archiveReal)).isFile()) {
+    throw new EngramAccessInputError("capsule import failed: archivePath must point to a file");
+  }
+  try {
+    await access(archiveReal, fsConstants.R_OK);
+  } catch (cause) {
+    if (!isInputFsError(cause)) throw cause;
+    throw new EngramAccessInputError("capsule import failed: archive is not readable");
+  }
+}
+
+export {
+  isCapsuleImportArchiveInputError,
+  validateCapsuleImportArchive
+};
+//# sourceMappingURL=chunk-FKBGK3NC.js.map

package/dist/chunk-FKBGK3NC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/capsule-import-gate.ts"],"sourcesContent":["import { constants as fsConstants } from \"node:fs\";\nimport { access, realpath, stat } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { ZodError } from \"zod\";\nimport { EngramAccessInputError } from \"./access-errors.js\";\nimport { defaultCapsulesDir } from \"./capsule-cli.js\";\n\n/**\n * Import-path gate for remote capsule imports (issue #3225 C1).\n *\n * `EngramAccessService.capsuleImport` serves the HTTP route and the\n * `capsule_import` MCP operation, where the caller supplies `archivePath`.\n * The destination namespace is authorized, but the source archive previously\n * was not: any path the server process could read was accepted. This module\n * confines the source to the namespace capsule store, `defaultCapsulesDir`\n * of the destination storage dir, which is the same store `capsule export`\n * writes and `capsule_list` lists.\n *\n * The CLI import path does not go through this gate; it is the explicit\n * operator authority and keeps unrestricted local-path imports.\n */\n\n/** True when the caught error carries the given errno-style code. */\nfunction hasFsErrorCode(cause: unknown, code: string): boolean {\n  return cause instanceof Object && \"code\" in cause && cause.code === code;\n}\n\n/** True when `cause` is a path error the gate reports as an input error instead of a server fault. */\nfunction isInputFsError(cause: unknown): boolean {\n  return (\n    hasFsErrorCode(cause, \"ENOENT\") ||\n    hasFsErrorCode(cause, \"ENOTDIR\") ||\n    hasFsErrorCode(cause, \"EACCES\") ||\n    hasFsErrorCode(cause, \"EPERM\") ||\n    hasFsErrorCode(cause, \"ELOOP\") ||\n    hasFsErrorCode(cause, \"ENAMETOOLONG\") ||\n    hasFsErrorCode(cause, \"ERR_INVALID_ARG_VALUE\")\n  );\n}\n\n/** Matches zod-style `Z_` error codes carried on error objects. */\nconst ZOD_STYLE_CODE = /^Z_/;\n\n/** True when the caught error carries a zod-style `Z_` code. */\nfunction hasZodStyleErrorCode(cause: unknown): boolean {\n  return cause instanceof Object && \"code\" in cause && ZOD_STYLE_CODE.test(String(cause.code));\n}\n\n/** True when the importer failed on archive input (shape, gzip, checksum) rather than backend errors. */\nexport function isCapsuleImportArchiveInputError(cause: unknown, message: string): boolean {\n  if (cause instanceof ZodError) return true;\n  if (hasZodStyleErrorCode(cause)) return true;\n  return (\n    message.startsWith(\"importCapsule: archive\") ||\n    message.startsWith(\"importCapsule: bundle\") ||\n    message.startsWith(\"importCapsule: manifest\") ||\n    message.startsWith(\"importCapsule: record\") ||\n    /incorrect header check|invalid stored block lengths|not in gzip format|unexpected end of file/i.test(message)\n  );\n}\n\n/**\n * One message for every refusal before confinement is proven. A caller that\n * can name any server path must not learn from the error whether that path\n * exists, is a directory, or is unreadable.\n */\nconst IMPORT_SOURCE_REFUSED =\n  \"capsule import failed: archivePath must be an existing file inside the namespace capsule store\";\n\n/** Resolve a path to its real path; a missing, looping, or unreadable path resolves to null. */\nasync function realpathOrNull(target: string): Promise<string | null> {\n  try {\n    return await realpath(target);\n  } catch (cause) {\n    if (!isInputFsError(cause)) throw cause;\n    return null;\n  }\n}\n\n/** True when `target` is a strict descendant of `directory` (both already resolved). */\nfunction isInsideDirectory(directory: string, target: string): boolean {\n  const rel = path.relative(directory, target);\n  return rel !== \"\" && rel !== \"..\" && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);\n}\n\n/**\n * Validate a remote import source and confine it to the namespace capsule\n * store. Both real paths are resolved first, so `..` segments and store\n * symlinks that point outside are refused. Confinement is checked before the\n * file is inspected in any other way, and every failure before it proves\n * confinement raises the same message.\n */\nexport async function validateCapsuleImportArchive(archivePath: string, storageDir: string): Promise<void> {\n  const storeReal = await realpathOrNull(defaultCapsulesDir(storageDir));\n  const archiveReal = await realpathOrNull(archivePath);\n  if (storeReal === null || archiveReal === null || !isInsideDirectory(storeReal, archiveReal)) {\n    throw new EngramAccessInputError(IMPORT_SOURCE_REFUSED);\n  }\n  // The path now names a store entry, so the checks below only describe the store.\n  if (!(await stat(archiveReal)).isFile()) {\n    throw new EngramAccessInputError(\"capsule import failed: archivePath must point to a file\");\n  }\n  try {\n    await access(archiveReal, fsConstants.R_OK);\n  } catch (cause) {\n    if (!isInputFsError(cause)) throw cause;\n    throw new EngramAccessInputError(\"capsule import failed: archive is not readable\");\n  }\n}\n"],"mappings":";;;;;;;;AAAA,SAAS,aAAa,mBAAmB;AACzC,SAAS,QAAQ,UAAU,YAAY;AACvC,OAAO,UAAU;AACjB,SAAS,gBAAgB;AAoBzB,SAAS,eAAe,OAAgB,MAAuB;AAC7D,SAAO,iBAAiB,UAAU,UAAU,SAAS,MAAM,SAAS;AACtE;AAGA,SAAS,eAAe,OAAyB;AAC/C,SACE,eAAe,OAAO,QAAQ,KAC9B,eAAe,OAAO,SAAS,KAC/B,eAAe,OAAO,QAAQ,KAC9B,eAAe,OAAO,OAAO,KAC7B,eAAe,OAAO,OAAO,KAC7B,eAAe,OAAO,cAAc,KACpC,eAAe,OAAO,uBAAuB;AAEjD;AAGA,IAAM,iBAAiB;AAGvB,SAAS,qBAAqB,OAAyB;AACrD,SAAO,iBAAiB,UAAU,UAAU,SAAS,eAAe,KAAK,OAAO,MAAM,IAAI,CAAC;AAC7F;AAGO,SAAS,iCAAiC,OAAgB,SAA0B;AACzF,MAAI,iBAAiB,SAAU,QAAO;AACtC,MAAI,qBAAqB,KAAK,EAAG,QAAO;AACxC,SACE,QAAQ,WAAW,wBAAwB,KAC3C,QAAQ,WAAW,uBAAuB,KAC1C,QAAQ,WAAW,yBAAyB,KAC5C,QAAQ,WAAW,uBAAuB,KAC1C,iGAAiG,KAAK,OAAO;AAEjH;AAOA,IAAM,wBACJ;AAGF,eAAe,eAAe,QAAwC;AACpE,MAAI;AACF,WAAO,MAAM,SAAS,MAAM;AAAA,EAC9B,SAAS,OAAO;AACd,QAAI,CAAC,eAAe,KAAK,EAAG,OAAM;AAClC,WAAO;AAAA,EACT;AACF;AAGA,SAAS,kBAAkB,WAAmB,QAAyB;AACrE,QAAM,MAAM,KAAK,SAAS,WAAW,MAAM;AAC3C,SAAO,QAAQ,MAAM,QAAQ,QAAQ,CAAC,IAAI,WAAW,KAAK,KAAK,GAAG,EAAE,KAAK,CAAC,KAAK,WAAW,GAAG;AAC/F;AASA,eAAsB,6BAA6B,aAAqB,YAAmC;AACzG,QAAM,YAAY,MAAM,eAAe,mBAAmB,UAAU,CAAC;AACrE,QAAM,cAAc,MAAM,eAAe,WAAW;AACpD,MAAI,cAAc,QAAQ,gBAAgB,QAAQ,CAAC,kBAAkB,WAAW,WAAW,GAAG;AAC5F,UAAM,IAAI,uBAAuB,qBAAqB;AAAA,EACxD;AAEA,MAAI,EAAE,MAAM,KAAK,WAAW,GAAG,OAAO,GAAG;AACvC,UAAM,IAAI,uBAAuB,yDAAyD;AAAA,EAC5F;AACA,MAAI;AACF,UAAM,OAAO,aAAa,YAAY,IAAI;AAAA,EAC5C,SAAS,OAAO;AACd,QAAI,CAAC,eAAe,KAAK,EAAG,OAAM;AAClC,UAAM,IAAI,uBAAuB,gDAAgD;AAAA,EACnF;AACF;","names":[]}

package/dist/{chunk-X2KO4FK5.js → chunk-FNFURZBZ.js}

@@ -6,18 +6,18 @@ import {
 // src/briefing-deadline.ts
 var BRIEFING_DEADLINE_MS = 3e4;
 var BriefingTimeoutError = class extends Error {
-  constructor(deadlineMs) {
-    super(`briefing timed out after ${deadlineMs}ms`);
+  constructor(deadlineMs, label = "briefing") {
+    super(`${label} timed out after ${deadlineMs}ms`);
     this.deadlineMs = deadlineMs;
     this.name = "TimeoutError";
   }
   deadlineMs;
 };
-async function withBriefingDeadline(run, abortSignal) {
+async function withBriefingDeadline(run, abortSignal, label = "briefing") {
   const controller = new AbortController();
   const signal = abortSignal ? AbortSignal.any([abortSignal, controller.signal]) : controller.signal;
   const timer = setTimeout(
-    () => controller.abort(new BriefingTimeoutError(BRIEFING_DEADLINE_MS)),
+    () => controller.abort(new BriefingTimeoutError(BRIEFING_DEADLINE_MS, label)),
     BRIEFING_DEADLINE_MS
   );
   try {
@@ -37,4 +37,4 @@ export {
   BriefingTimeoutError,
   withBriefingDeadline
 };
-//# sourceMappingURL=chunk-X2KO4FK5.js.map
+//# sourceMappingURL=chunk-FNFURZBZ.js.map

package/dist/chunk-FNFURZBZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/briefing-deadline.ts"],"sourcesContent":["import { isAbortError, raceAbort } from \"./abort-error.js\";\n\nexport const BRIEFING_DEADLINE_MS = 30_000;\n\nexport class BriefingTimeoutError extends Error {\n  constructor(readonly deadlineMs: number, label = \"briefing\") {\n    super(`${label} timed out after ${deadlineMs}ms`);\n    this.name = \"TimeoutError\";\n  }\n}\n\nexport async function withBriefingDeadline<T>(\n  run: (signal: AbortSignal) => Promise<T>,\n  abortSignal?: AbortSignal,\n  label = \"briefing\",\n): Promise<T> {\n  const controller = new AbortController();\n  const signal = abortSignal ? AbortSignal.any([abortSignal, controller.signal]) : controller.signal;\n  const timer = setTimeout(\n    () => controller.abort(new BriefingTimeoutError(BRIEFING_DEADLINE_MS, label)),\n    BRIEFING_DEADLINE_MS\n  );\n  try {\n    signal.throwIfAborted();\n    return await raceAbort(run(signal), signal, \"briefing aborted\");\n  } catch (err) {\n    // raceAbort normalizes cancellation; retain the distinct deadline reason.\n    const reason: unknown = signal.reason;\n    if (signal.aborted && (reason instanceof BriefingTimeoutError || isAbortError(reason))) throw reason;\n    throw err;\n  } finally {\n    clearTimeout(timer);\n  }\n}\n"],"mappings":";;;;;;AAEO,IAAM,uBAAuB;AAE7B,IAAM,uBAAN,cAAmC,MAAM;AAAA,EAC9C,YAAqB,YAAoB,QAAQ,YAAY;AAC3D,UAAM,GAAG,KAAK,oBAAoB,UAAU,IAAI;AAD7B;AAEnB,SAAK,OAAO;AAAA,EACd;AAAA,EAHqB;AAIvB;AAEA,eAAsB,qBACpB,KACA,aACA,QAAQ,YACI;AACZ,QAAM,aAAa,IAAI,gBAAgB;AACvC,QAAM,SAAS,cAAc,YAAY,IAAI,CAAC,aAAa,WAAW,MAAM,CAAC,IAAI,WAAW;AAC5F,QAAM,QAAQ;AAAA,IACZ,MAAM,WAAW,MAAM,IAAI,qBAAqB,sBAAsB,KAAK,CAAC;AAAA,IAC5E;AAAA,EACF;AACA,MAAI;AACF,WAAO,eAAe;AACtB,WAAO,MAAM,UAAU,IAAI,MAAM,GAAG,QAAQ,kBAAkB;AAAA,EAChE,SAAS,KAAK;AAEZ,UAAM,SAAkB,OAAO;AAC/B,QAAI,OAAO,YAAY,kBAAkB,wBAAwB,aAAa,MAAM,GAAI,OAAM;AAC9F,UAAM;AAAA,EACR,UAAE;AACA,iBAAa,KAAK;AAAA,EACpB;AACF;","names":[]}

package/dist/{chunk-KESJ5XX3.js → chunk-G54BOKZ6.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-WAD32CZG.js";
+} from "./chunk-CC4V7HNP.js";
 import {
   keyring_exports,
   secureStoreDir
@@ -416,4 +416,4 @@ export {
   resolveNamespaceStorageRoot,
   NamespaceStorageRouter
 };
-//# sourceMappingURL=chunk-KESJ5XX3.js.map
+//# sourceMappingURL=chunk-G54BOKZ6.js.map

package/dist/{chunk-YK7GOPIE.js → chunk-G67EUQAB.js}

@@ -1,3 +1,6 @@
+import {
+  gunzipCapsuleArchive
+} from "./chunk-QV2VZKD5.js";
 import {
   createVersion
 } from "./chunk-ER7XANP3.js";
@@ -13,13 +16,13 @@ import {
   requestEntityCanonicalIdReconcile,
   withRawEntityPageMutation
 } from "./chunk-IAYUTGF2.js";
-import {
-  parseExportBundle
-} from "./chunk-WEHSQBFR.js";
 import {
   decryptCapsuleFileInMemory,
   isEncryptedCapsuleFile
-} from "./chunk-DQEMWVMT.js";
+} from "./chunk-X7Y7WX73.js";
+import {
+  parseExportBundle
+} from "./chunk-WEHSQBFR.js";
 import {
   assertIsDirectoryNotSymlink,
   assertRealpathInsideRoot,
@@ -32,7 +35,6 @@ import {
 import { lstat, mkdir, readFile, realpath, stat, unlink, writeFile } from "fs/promises";
 import path from "path";
 import { createHash, randomUUID } from "crypto";
-import { gunzipSync } from "zlib";
 async function importCapsule(opts) {
   const archiveAbs = path.resolve(opts.archivePath);
   const rootAbs = path.resolve(opts.root);
@@ -57,7 +59,7 @@ async function importCapsule(opts) {
   } else {
     raw = await readFile(archiveAbs);
   }
-  const json = gunzipSync(raw).toString("utf-8");
+  const json = gunzipCapsuleArchive(raw, "importCapsule", archiveAbs);
   let parsedJson;
   try {
     parsedJson = JSON.parse(json);
@@ -294,4 +296,4 @@ function mintForkId(capsuleId, originalId, now) {
 export {
   importCapsule
 };
-//# sourceMappingURL=chunk-YK7GOPIE.js.map
+//# sourceMappingURL=chunk-G67EUQAB.js.map