@ponythewhite/base-context 1.0.13 → 1.0.15

package/dist/core/session-manager.js

@@ -2012,6 +2012,10 @@ export class SessionManager {
             isCurrent: () => isCurrent(currentRevision),
             readHistory: (read) => sink.readHistory((history) => read(history.branchContext)),
             [readCopiedEpochSource]: (read) => sink.readHistory(read),
+            readCompactionEntries: (entryIds) => {
+                const ids = [...new Set(entryIds)];
+                return sink.readHistory((history) => this._readCompactionEntriesAt(history, ids, capturedLimits));
+            },
             readBranch: async () => {
                 if (indexed)
                     return sink.readHistory(async (history) => (await this._readBranchesAt(history, [history.source.leafId], capturedLimits)).branches[0]);
@@ -2893,6 +2897,59 @@ export class SessionManager {
             return entries;
         });
     }
+    async _readCompactionEntriesAt(history, entryIds, limits) {
+        const { maxEntries, maxSourceBytes } = limits;
+        if (!Number.isSafeInteger(maxEntries) ||
+            maxEntries <= 0 ||
+            !Number.isSafeInteger(maxSourceBytes) ||
+            maxSourceBytes <= 0)
+            throw new Error("Invalid compaction source limits");
+        if (entryIds.length > maxEntries)
+            throw new Error("Compaction entry budget exceeded");
+        const selected = new Set(entryIds);
+        const references = [];
+        for (const id of entryIds) {
+            const reference = await history.branchContext.get(id);
+            if (!reference)
+                throw new Error("Compaction entry is outside its captured branch");
+            references.push(reference);
+        }
+        references.sort((a, b) => a.sequence - b.sequence);
+        // Pinned older views cannot cross an omitted message to become a chronological cut.
+        // Walk metadata only: excluded lifetime payloads must not consume the hydration budget.
+        const suffixAnchors = new Set();
+        const visited = new Set();
+        let current = history.source.leafId;
+        let leafKind;
+        while (current !== null) {
+            if (visited.has(current))
+                throw new Error("Compaction parent path is unresolved");
+            visited.add(current);
+            const reference = await history.branchContext.get(current);
+            if (!reference)
+                throw new Error("Compaction parent path is unresolved");
+            leafKind ??= reference.kind;
+            if (["message", "custom_message", "branch_summary"].includes(reference.kind)) {
+                if (!selected.has(reference.id))
+                    break;
+                suffixAnchors.add(reference.id);
+            }
+            current = reference.parentId;
+        }
+        const entries = [];
+        let sourceBytes = 0;
+        for (const reference of references) {
+            const remaining = maxSourceBytes - sourceBytes;
+            sourceBytes += reference.locator.length;
+            if (sourceBytes > maxSourceBytes)
+                throw new Error("Compaction source byte budget exceeded");
+            const value = await history.hydrateEntry(reference.id, remaining);
+            if (!value)
+                throw new Error("Compaction entry source is unavailable");
+            entries.push(withEntryRetention(value.entry, value.source.retention, value.source.qualification));
+        }
+        return { entries, suffixAnchors, leafKind };
+    }
     async _readBranchesAt(history, leafIds, limits) {
         const { maxEntries, maxSourceBytes } = limits;
         if (!Number.isSafeInteger(maxEntries) ||