@cortexkit/opencode-magic-context 0.34.2 → 0.35.0

package/dist/{index-b563sga5.js → index-h8mk7vpa.js}

@@ -132986,6 +132986,543 @@ function readRawSessionMessageByIdFromDb(db, sessionId, messageId) {
   };
 }
 
+// src/shared/record-type-guard.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/shared/stable-json.ts
+function stableStringify(value, seen = new WeakSet) {
+  if (value === undefined)
+    return "undefined";
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value) ?? String(value);
+  if (seen.has(value))
+    return '"[Circular]"';
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item, seen)).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(([a], [b]) => {
+    if (a < b)
+      return -1;
+    if (a > b)
+      return 1;
+    return 0;
+  });
+  return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child, seen)}`).join(",")}}`;
+}
+
+// src/hooks/magic-context/read-session-true-raw-tokens.ts
+function completedToolArcCrossesBoundary(invOrdinal, resOrdinal, boundary) {
+  return invOrdinal < boundary && boundary <= resOrdinal;
+}
+var MAX_MESSAGE_CACHE_ENTRIES = 1e5;
+var MAX_MESSAGE_CACHE_KEY_BYTES = 64 * 1024 * 1024;
+var FNV1A_32_OFFSET = 2166136261;
+var FNV1A_32_PRIME = 16777619;
+var messageEstimateCache = new Map;
+var messageEstimateCacheBytes = 0;
+var EMPTY_BREAKDOWN = {
+  text: 0,
+  reasoning: 0,
+  toolInput: 0,
+  toolOutput: 0,
+  image: 0,
+  other: 0,
+  total: 0
+};
+function addBreakdown(target, kind, value) {
+  if (kind === "total")
+    return;
+  const safeValue = Number.isFinite(value) && value > 0 ? Math.round(value) : 0;
+  target[kind] += safeValue;
+  target.total += safeValue;
+}
+function estimateStructured(value) {
+  if (typeof value === "string")
+    return estimateTokens(value);
+  if (value === undefined || value === null)
+    return 0;
+  return estimateTokens(stableStringify(value));
+}
+function firstStringField(record, fields) {
+  for (const field of fields) {
+    const value = record[field];
+    if (typeof value === "string" && value.length > 0)
+      return value;
+  }
+  return null;
+}
+function stringValue(value) {
+  if (typeof value === "string")
+    return value;
+  if (value === undefined || value === null)
+    return "";
+  return stableStringify(value);
+}
+function textFromToolResultContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    const pieces = [];
+    for (const entry of content) {
+      if (typeof entry === "string") {
+        pieces.push(entry);
+      } else if (isRecord(entry)) {
+        const text = firstStringField(entry, ["text", "content", "value"]);
+        pieces.push(text ?? stableStringify(entry));
+      } else if (entry !== null && entry !== undefined) {
+        pieces.push(String(entry));
+      }
+    }
+    return pieces.join(`
+`);
+  }
+  return stringValue(content);
+}
+function looksImageLike(part) {
+  const type = typeof part.type === "string" ? part.type.toLowerCase() : "";
+  const mime = typeof part.mime === "string" ? part.mime.toLowerCase() : "";
+  const mediaType = typeof part.mediaType === "string" ? part.mediaType.toLowerCase() : "";
+  return type.includes("image") || mime.startsWith("image/") || mediaType.startsWith("image/") || part.image_url !== undefined || part.imageUrl !== undefined || part.image !== undefined;
+}
+function defaultImageTokenHeuristic(part) {
+  if (isRecord(part)) {
+    const width = part.width;
+    const height = part.height;
+    if (typeof width === "number" && typeof height === "number" && width > 0 && height > 0) {
+      return Math.max(256, Math.min(4096, Math.ceil(width * height / 750)));
+    }
+  }
+  return 1024;
+}
+function partType(part) {
+  return typeof part.type === "string" ? part.type : "";
+}
+function hasOwn(record, key) {
+  return Object.hasOwn(record, key);
+}
+function recursiveByteLength(value) {
+  if (value === null || value === undefined)
+    return 0;
+  if (typeof value === "string")
+    return value.length;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value).length;
+  }
+  if (Array.isArray(value)) {
+    return value.reduce((sum, item) => sum + recursiveByteLength(item), value.length);
+  }
+  if (isRecord(value)) {
+    let total = Object.keys(value).length;
+    for (const [key, child] of Object.entries(value)) {
+      total += key.length + recursiveByteLength(child);
+    }
+    return total;
+  }
+  return String(value).length;
+}
+function updateFnv1a32(hash, text) {
+  let next = hash;
+  for (let index = 0;index < text.length; index += 1) {
+    next ^= text.charCodeAt(index);
+    next = Math.imul(next, FNV1A_32_PRIME) >>> 0;
+  }
+  return next;
+}
+function contentStringsHash(fields) {
+  let hash = FNV1A_32_OFFSET;
+  for (const field of fields) {
+    hash = updateFnv1a32(hash, `${field.length}:`);
+    hash = updateFnv1a32(hash, field);
+    hash = updateFnv1a32(hash, "\x00");
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function rawPartVersion(part) {
+  return part.__magicContextPartUpdatedAt ?? part.updated_at ?? part.updatedAt ?? part.version ?? part.revision ?? "";
+}
+function callIdFromPart(part) {
+  const direct = firstStringField(part, ["callID", "callId", "toolCallId", "tool_call_id", "id"]);
+  if (direct)
+    return direct;
+  const state = isRecord(part.state) ? part.state : null;
+  return state ? firstStringField(state, ["callID", "callId", "toolCallId", "tool_call_id", "id"]) ?? "" : "";
+}
+function toolSignalFromPart(part) {
+  if (!isRecord(part))
+    return null;
+  const type = partType(part);
+  const state = isRecord(part.state) ? part.state : null;
+  const callId = callIdFromPart(part);
+  if (!callId && type !== "tool")
+    return null;
+  if (type === "tool") {
+    const hasInput = state !== null && hasOwn(state, "input");
+    const outputKey = state ? hasOwn(state, "output") ? "output" : hasOwn(state, "error") ? "error" : hasOwn(state, "result") ? "result" : null : null;
+    const hasOutput = outputKey !== null;
+    const outputValue = outputKey && state ? state[outputKey] : undefined;
+    const providerExecuted = part.providerExecuted === true;
+    const openInvocation = !providerExecuted && !hasOutput;
+    return {
+      callId,
+      hasInput: hasInput || openInvocation,
+      hasOutput,
+      inputText: hasInput && state ? stringValue(state.input) : "",
+      outputText: hasOutput ? stringValue(outputValue) : ""
+    };
+  }
+  if (type === "tool-invocation") {
+    const args = part.args ?? part.input;
+    return {
+      callId,
+      hasInput: args !== undefined,
+      hasOutput: false,
+      inputText: args !== undefined ? stringValue(args) : "",
+      outputText: ""
+    };
+  }
+  if (type === "tool_use") {
+    const input = part.input;
+    return {
+      callId,
+      hasInput: input !== undefined,
+      hasOutput: false,
+      inputText: input !== undefined ? stringValue(input) : "",
+      outputText: ""
+    };
+  }
+  if (type === "tool_result") {
+    const content = part.content ?? part.output ?? part.result;
+    return {
+      callId,
+      hasInput: false,
+      hasOutput: content !== undefined,
+      inputText: "",
+      outputText: content !== undefined ? textFromToolResultContent(content) : ""
+    };
+  }
+  return null;
+}
+function partCheapFingerprint(part) {
+  if (!isRecord(part))
+    return `${typeof part}:${recursiveByteLength(part)}`;
+  const version = rawPartVersion(part);
+  const type = typeof part.type === "string" ? part.type : "";
+  return `${type}:${String(version)}:${recursiveByteLength(part)}`;
+}
+function messageCacheKey(message, options) {
+  const namespace = "cacheNamespace" in options ? options.cacheNamespace : "estimate";
+  const cheapFingerprint = message.parts.map(partCheapFingerprint).join("|");
+  return [
+    namespace,
+    options.providerShapeVersion,
+    message.id || `ordinal:${message.ordinal}`,
+    message.role,
+    message.parts.length,
+    cheapFingerprint
+  ].join("\x00");
+}
+function setCachedEstimate(key, breakdown) {
+  const keyEstimateBytes = key.length * 2 + 64;
+  const existing = messageEstimateCache.get(key);
+  if (existing)
+    messageEstimateCacheBytes -= existing.keyEstimateBytes;
+  messageEstimateCache.set(key, { breakdown, keyEstimateBytes });
+  messageEstimateCacheBytes += keyEstimateBytes;
+  while (messageEstimateCache.size > MAX_MESSAGE_CACHE_ENTRIES || messageEstimateCacheBytes > MAX_MESSAGE_CACHE_KEY_BYTES) {
+    const first = messageEstimateCache.keys().next().value;
+    if (typeof first !== "string")
+      break;
+    const removed = messageEstimateCache.get(first);
+    if (removed)
+      messageEstimateCacheBytes -= removed.keyEstimateBytes;
+    messageEstimateCache.delete(first);
+  }
+}
+function cloneBreakdown(value) {
+  return { ...value };
+}
+function estimateNonToolPart(part, options, breakdown) {
+  if (!isRecord(part)) {
+    if (part !== null && part !== undefined)
+      addBreakdown(breakdown, "other", estimateStructured(part));
+    return true;
+  }
+  const type = partType(part);
+  if (type === "step-start" || type === "step-finish" || type === "meta" && Object.keys(part).length <= 1) {
+    return true;
+  }
+  if (type === "text") {
+    const text = firstStringField(part, ["text", "content"]);
+    if (text)
+      addBreakdown(breakdown, "text", estimateTokens(text));
+    return true;
+  }
+  if (type === "reasoning" || type === "thinking" || type === "redacted_thinking") {
+    const text = firstStringField(part, ["thinking", "text", "content", "reasoning"]);
+    if (text) {
+      addBreakdown(breakdown, "reasoning", estimateTokens(text));
+    } else {
+      addBreakdown(breakdown, "other", estimateStructured(part));
+    }
+    return true;
+  }
+  const reasoningText = firstStringField(part, ["thinking", "reasoning"]);
+  if (reasoningText && type.length === 0) {
+    addBreakdown(breakdown, "reasoning", estimateTokens(reasoningText));
+    return true;
+  }
+  if (looksImageLike(part)) {
+    addBreakdown(breakdown, "image", options.imageTokenHeuristic?.(part) ?? defaultImageTokenHeuristic(part));
+    const altText = firstStringField(part, ["alt", "text", "description"]);
+    if (altText)
+      addBreakdown(breakdown, "text", estimateTokens(altText));
+    return true;
+  }
+  if (type.includes("file") || type === "source") {
+    const content = firstStringField(part, ["content", "text", "source"]);
+    if (content)
+      addBreakdown(breakdown, "text", estimateTokens(content));
+    else
+      addBreakdown(breakdown, "other", estimateStructured(part));
+    return true;
+  }
+  return false;
+}
+function estimateTrueRawMessageTokens(message, options) {
+  const breakdown = cloneBreakdown(EMPTY_BREAKDOWN);
+  const countedInput = new Set;
+  const countedOutput = new Set;
+  let ordinalToolIndex = 0;
+  for (const part of message.parts) {
+    const signal = toolSignalFromPart(part);
+    if (signal) {
+      const localKey = `${signal.callId || "tool"}:${message.ordinal}:${ordinalToolIndex}`;
+      ordinalToolIndex += 1;
+      if (signal.hasInput) {
+        const key = `${signal.callId}:input:${message.ordinal}`;
+        if (!countedInput.has(key)) {
+          countedInput.add(key);
+          addBreakdown(breakdown, "toolInput", estimateTokens(signal.inputText));
+        }
+      }
+      if (signal.hasOutput) {
+        const key = `${signal.callId}:output:${message.ordinal}:${localKey}`;
+        if (!countedOutput.has(key)) {
+          countedOutput.add(key);
+          addBreakdown(breakdown, "toolOutput", estimateTokens(signal.outputText));
+        }
+      }
+      continue;
+    }
+    if (!estimateNonToolPart(part, options, breakdown)) {
+      addBreakdown(breakdown, "other", estimateStructured(part));
+    }
+  }
+  return breakdown;
+}
+function buildToolArcs(messages) {
+  const openQueues = new Map;
+  const arcs = [];
+  for (const message of messages) {
+    for (const part of message.parts) {
+      const signal = toolSignalFromPart(part);
+      if (!signal || signal.callId.length === 0)
+        continue;
+      if (signal.hasInput && signal.hasOutput) {
+        arcs.push({
+          callId: signal.callId,
+          invOrdinal: message.ordinal,
+          resOrdinal: message.ordinal
+        });
+        continue;
+      }
+      if (signal.hasInput) {
+        const queue = openQueues.get(signal.callId) ?? [];
+        queue.push(message.ordinal);
+        openQueues.set(signal.callId, queue);
+        continue;
+      }
+      if (signal.hasOutput) {
+        const queue = openQueues.get(signal.callId) ?? [];
+        const invOrdinal = queue.shift();
+        if (queue.length === 0)
+          openQueues.delete(signal.callId);
+        else
+          openQueues.set(signal.callId, queue);
+        if (invOrdinal !== undefined) {
+          arcs.push({ callId: signal.callId, invOrdinal, resOrdinal: message.ordinal });
+        }
+      }
+    }
+  }
+  for (const [callId, queue] of openQueues) {
+    for (const invOrdinal of queue) {
+      arcs.push({ callId, invOrdinal, resOrdinal: null });
+    }
+  }
+  return arcs.sort((a, b) => a.invOrdinal - b.invOrdinal || (a.resOrdinal ?? Number.MAX_SAFE_INTEGER) - (b.resOrdinal ?? Number.MAX_SAFE_INTEGER));
+}
+function fenceBoundaryForToolArcs(candidate, arcs, lastCompartmentEndOrdinal, recentOpenArcCutoff) {
+  let boundary = candidate;
+  for (const arc of arcs) {
+    if (arc.resOrdinal !== null) {
+      if (completedToolArcCrossesBoundary(arc.invOrdinal, arc.resOrdinal, boundary)) {
+        boundary = arc.resOrdinal + 1;
+      }
+      continue;
+    }
+    if (arc.invOrdinal < recentOpenArcCutoff)
+      continue;
+    if (arc.invOrdinal >= lastCompartmentEndOrdinal + 1 && arc.invOrdinal < boundary) {
+      return arc.invOrdinal;
+    }
+    if (arc.invOrdinal >= boundary) {
+      return arc.invOrdinal;
+    }
+  }
+  return boundary;
+}
+function tokenForMessage(message, options) {
+  const key = messageCacheKey(message, options);
+  const cached = messageEstimateCache.get(key);
+  if (cached)
+    return cloneBreakdown(cached.breakdown);
+  const breakdown = estimateTrueRawMessageTokens(message, options);
+  setCachedEstimate(key, breakdown);
+  return cloneBreakdown(breakdown);
+}
+function buildTrueRawTokenIndex(sessionId, messages, options) {
+  const ordered = [...messages].sort((a, b) => a.ordinal - b.ordinal);
+  const sliceCount = ordered.length;
+  const firstOrdinal = ordered.length > 0 ? ordered[0].ordinal : 1;
+  const terminalOrdinal = ordered.length > 0 ? ordered[ordered.length - 1].ordinal : 0;
+  const rawMessageCount = Math.max(sliceCount, terminalOrdinal, options.absoluteMessageCount ?? sliceCount);
+  const ordinalSpan = terminalOrdinal >= firstOrdinal ? terminalOrdinal - firstOrdinal + 1 : 0;
+  const tokensByOrdinal = new Map;
+  const idsByOrdinal = new Map;
+  const prefix = new Array(ordinalSpan + 1).fill(0);
+  for (const message of ordered) {
+    const stored = options.storedTotalForMessage?.(message);
+    const total = stored !== undefined && stored !== null ? stored : tokenForMessage(message, options).total;
+    tokensByOrdinal.set(message.ordinal, total);
+    idsByOrdinal.set(message.ordinal, message.id);
+    const relative = message.ordinal - firstOrdinal + 1;
+    if (relative >= 1 && relative <= ordinalSpan) {
+      prefix[relative] = total;
+    }
+  }
+  for (let k = 1;k <= ordinalSpan; k += 1) {
+    prefix[k] += prefix[k - 1];
+  }
+  const ordinalToIndex = (ordinal) => Math.max(0, Math.min(ordinalSpan, ordinal - firstOrdinal));
+  return {
+    sessionId,
+    providerShapeVersion: options.providerShapeVersion,
+    rawMessageCount,
+    tokenForOrdinal(ordinal) {
+      return tokensByOrdinal.get(ordinal) ?? 0;
+    },
+    messageIdAtOrdinal(ordinal) {
+      return idsByOrdinal.get(ordinal) ?? null;
+    },
+    suffixTokensFromOrdinal(ordinal) {
+      if (ordinal <= firstOrdinal)
+        return prefix[ordinalSpan];
+      if (ordinal > terminalOrdinal)
+        return 0;
+      return prefix[ordinalSpan] - prefix[ordinalToIndex(ordinal)];
+    },
+    rangeTokens(startInclusive, endExclusive) {
+      const start = Math.max(firstOrdinal, startInclusive);
+      const end = Math.max(start, Math.min(terminalOrdinal + 1, endExclusive));
+      return prefix[end - firstOrdinal] - prefix[start - firstOrdinal];
+    },
+    findSuffixStartForTokens(tokens) {
+      if (!Number.isFinite(tokens) || tokens <= 0)
+        return terminalOrdinal + 1;
+      const target = Math.max(0, Math.floor(tokens));
+      const total = prefix[ordinalSpan];
+      if (total < target)
+        return firstOrdinal;
+      const cut = total - target;
+      let lo = 0;
+      let hi = ordinalSpan;
+      let best = 0;
+      while (lo <= hi) {
+        const mid = lo + hi >> 1;
+        if (prefix[mid] <= cut) {
+          best = mid;
+          lo = mid + 1;
+        } else {
+          hi = mid - 1;
+        }
+      }
+      return firstOrdinal + best;
+    },
+    findHeadEndForCap(startInclusive, endExclusive, capTokens) {
+      const start = Math.max(firstOrdinal, Math.min(terminalOrdinal + 1, startInclusive));
+      const end = Math.max(start, Math.min(terminalOrdinal + 1, endExclusive));
+      if (!Number.isFinite(capTokens) || capTokens <= 0)
+        return start;
+      const startIndex = start - firstOrdinal;
+      const endIndex = end - firstOrdinal;
+      const cut = prefix[startIndex] + Math.floor(capTokens);
+      let lo = startIndex + 1;
+      let hi = endIndex;
+      let bestEndIndex = startIndex;
+      while (lo <= hi) {
+        const mid = lo + hi >> 1;
+        if (prefix[mid] <= cut) {
+          bestEndIndex = mid;
+          lo = mid + 1;
+        } else {
+          hi = mid - 1;
+        }
+      }
+      let bestEnd = firstOrdinal + bestEndIndex;
+      if (bestEnd === start && start < end)
+        bestEnd = start + 1;
+      return Math.min(bestEnd, end);
+    }
+  };
+}
+function partContentFingerprint(part) {
+  if (!isRecord(part))
+    return `${typeof part}:${recursiveByteLength(part)}`;
+  const tool = toolSignalFromPart(part);
+  if (tool) {
+    return contentStringsHash([tool.inputText, tool.outputText]);
+  }
+  const text = firstStringField(part, ["text", "thinking", "reasoning", "content", "url"]) ?? "";
+  return contentStringsHash([text]);
+}
+function computeRawRangeFingerprint(messages, startInclusive, endExclusive) {
+  const pieces = [];
+  for (const message of messages) {
+    if (message.ordinal < startInclusive || message.ordinal >= endExclusive)
+      continue;
+    const partFingerprint = message.parts.map(partContentFingerprint).join(",");
+    pieces.push(`${message.ordinal}:${message.id}:${message.parts.length}:${partFingerprint}`);
+  }
+  return pieces.join("|");
+}
+function invalidateTrueRawTokenCache(args) {
+  const sessionNeedle = args.sessionId ? `${args.sessionId}` : null;
+  const messageNeedle = args.messageId ? `\x00${args.messageId}\x00` : null;
+  for (const [key, value] of messageEstimateCache) {
+    const sessionMatches = sessionNeedle === null || key.includes(sessionNeedle);
+    const messageMatches = messageNeedle === null || key.includes(messageNeedle);
+    if (sessionMatches && messageMatches) {
+      messageEstimateCache.delete(key);
+      messageEstimateCacheBytes -= value.keyEstimateBytes;
+    }
+  }
+  args.reason;
+}
+
 // src/hooks/magic-context/tag-content-primitives.ts
 var encoder = new TextEncoder;
 var TAG_PREFIX_REGEX = /^(?:§\d+§\s*)+/;
@@ -133079,11 +133616,6 @@ function buildFileSourceContent(parts) {
   return content.length > 0 ? content : null;
 }
 
-// src/shared/record-type-guard.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 // src/hooks/magic-context/edit-marker.ts
 var TRUNCATION_SENTINEL = "...[truncated]";
 var EDIT_REGION_HINT_LEN = 40;
@@ -133848,6 +134380,7 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
       toolOnlyRanges.push({ start: range.start, end: range.end });
     }
   }
+  const completedToolArcs = buildToolArcs(messages).flatMap((arc) => arc.resOrdinal === null ? [] : [{ start: arc.invOrdinal, end: arc.resOrdinal }]);
   return {
     startIndex: startOrdinal,
     endIndex: lastOrdinal,
@@ -133860,7 +134393,8 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
 `),
     lines: lineMeta,
     commitClusterCount: commitClusters,
-    toolOnlyRanges
+    toolOnlyRanges,
+    completedToolArcs
   };
 }
 
@@ -134781,4 +135315,4 @@ function clearSession(db, sessionId) {
   })();
 }
 
-export { textMentionsRecentCommit, hasMeaningfulUserText, extractTexts, extractToolCallSummaries, estimateTokens, normalizeText, clearCompressionDepth, clearCompressionDepthRange, ensureSessionMetaRow, persistCachedM0, clearCachedM0M1, isRawCompactionSummaryInfo, extractInMemoryMessageViews, buildInMemoryTailRawMessages, stripPersistedAssistantText, byteSize, stripTagPrefix, peelLeadingMcTagNotation, prependTag, isThinkingPart, isTextPart, isToolPartWithOutput, isFilePart, buildFileSourceContent, isRecord, isEditTool, partHasCompletedResult, extractToolCallObservation, ToolMutationBatch, createToolDropTarget, setRawMessageProvider, cleanUserText, withRawSessionMessageCache, readRawSessionMessages, primeTailRawMessageCache, getCachedAbsoluteMessageCount, primeInMemoryTailRawMessageCache, readRawSessionMessageOrdinalPage, getRawSessionStoredMessageCount, readRawSessionMessagePartsById, readRawSessionMessageOrdinalById, readRawSessionMessageById, getRawSessionMessageCount, getRawSessionTagKeysThrough, getLegacyProtectedTailStartOrdinal, readSessionChunk, getMessageIndexSourceIdentity, isMessageIndexSourceCurrent, getLastIndexedOrdinal, getIndexedMessageCorpusSize, getMessageIndexReconciliationStartOrdinal, isMessageIndexReconciledThrough, deleteIndexedMessage, clearIndexedMessages, indexSingleMessage, indexMessagesAfterOrdinal, sweepOrphanedOpenCodeMessageIndexes, getOrCreateSessionMeta, updateSessionMeta, advanceToolReclaimWatermark, markSessionCleanupPending, retryPendingSessionCleanups, clearSession };
+export { textMentionsRecentCommit, hasMeaningfulUserText, extractTexts, extractToolCallSummaries, estimateTokens, normalizeText, stableStringify, clearCompressionDepth, clearCompressionDepthRange, ensureSessionMetaRow, persistCachedM0, clearCachedM0M1, isRawCompactionSummaryInfo, extractInMemoryMessageViews, buildInMemoryTailRawMessages, isRecord, completedToolArcCrossesBoundary, estimateTrueRawMessageTokens, buildToolArcs, fenceBoundaryForToolArcs, buildTrueRawTokenIndex, computeRawRangeFingerprint, invalidateTrueRawTokenCache, stripPersistedAssistantText, byteSize, stripTagPrefix, peelLeadingMcTagNotation, prependTag, isThinkingPart, isTextPart, isToolPartWithOutput, isFilePart, buildFileSourceContent, isEditTool, partHasCompletedResult, extractToolCallObservation, ToolMutationBatch, createToolDropTarget, setRawMessageProvider, cleanUserText, withRawSessionMessageCache, readRawSessionMessages, primeTailRawMessageCache, getCachedAbsoluteMessageCount, primeInMemoryTailRawMessageCache, readRawSessionMessageOrdinalPage, getRawSessionStoredMessageCount, readRawSessionMessagePartsById, readRawSessionMessageOrdinalById, readRawSessionMessageById, getRawSessionMessageCount, getRawSessionTagKeysThrough, getLegacyProtectedTailStartOrdinal, readSessionChunk, getMessageIndexSourceIdentity, isMessageIndexSourceCurrent, getLastIndexedOrdinal, getIndexedMessageCorpusSize, getMessageIndexReconciliationStartOrdinal, isMessageIndexReconciledThrough, deleteIndexedMessage, clearIndexedMessages, indexSingleMessage, indexMessagesAfterOrdinal, sweepOrphanedOpenCodeMessageIndexes, getOrCreateSessionMeta, updateSessionMeta, advanceToolReclaimWatermark, markSessionCleanupPending, retryPendingSessionCleanups, clearSession };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,YAAY,EAAE,MAAM,qBAAqB,CAAC;AA8wBvE,QAAA,MAAM,MAAM,EAAE,YAGb,CAAC;AAEF,eAAe,MAAM,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAyxBvE,QAAA,MAAM,MAAM,EAAE,YAGb,CAAC;AAEF,eAAe,MAAM,CAAC"}