@earendil-works/pi-agent-core 0.85.1 → 0.86.1

package/dist/harness/session/jsonl/legacy-v3.js

@@ -1,8 +1,9 @@
 import { uuidv7 } from "@earendil-works/pi-ai/utils/uuid";
 import { createBranchSummaryMessage, createCompactionSummaryMessage } from "../../messages.js";
 import { addUsage, emptyUsage } from "../../utils/usage.js";
-import { branchTip, entryLabel, laneConfig, laneState, sessionName } from "../values.js";
+import { branchTip, entryLabel, laneConfig, laneState, sessionName, setValue } from "../values.js";
 import { parseJsonlSessionHeader } from "./codec.js";
+import { fileValue, readJsonlHeader } from "./io.js";
 import { JSONL_FORMAT_VERSION, JSONL_STORAGE_VERSION, } from "./types.js";
 async function resolveLegacyV3ParentSessionId(fileSystem, parentSessionPath, context) {
     const lines = await fileSystem.readTextLines(parentSessionPath, { maxLines: 1 }, context);
@@ -34,15 +35,15 @@ export async function normalizeLegacyV3Header(fileSystem, header, context) {
         ...(await metadataFromLegacyV3Header(fileSystem, header, context)),
     };
 }
-function parseLegacyV3Entry(line, lineNumber) {
+function parseLegacyV3Entry(line) {
     let entry;
     try {
         entry = JSON.parse(line);
     }
     catch (error) {
-        throw new Error(`Invalid legacy v3 JSONL record at line ${lineNumber}: not valid JSON`, { cause: error });
+        throw new Error("Invalid legacy v3 JSONL record: not valid JSON", { cause: error });
     }
-    const recordType = entry.type;
+    const recordType = entry?.type;
     if (recordType !== "message" &&
         recordType !== "custom" &&
         recordType !== "custom_message" &&
@@ -53,7 +54,7 @@ function parseLegacyV3Entry(line, lineNumber) {
         recordType !== "active_tools_change" &&
         recordType !== "session_info" &&
         recordType !== "label") {
-        throw new Error(`Unsupported legacy v3 record type at line ${lineNumber}: ${String(recordType)}`);
+        throw new Error(`Unsupported legacy v3 record type: ${String(recordType)}`);
     }
     return entry;
 }
@@ -76,110 +77,61 @@ function isRetainedEntry(entry) {
         entry.type !== "session_info" &&
         entry.type !== "label");
 }
-class RetainedIdResolver {
-    /** Caches the reminted ID of each discarded legacy node's nearest retained ancestor, or null. */
-    resolvedIds = new Map();
-    entriesById;
-    remintedIds;
-    /**
-     * @param entriesById Complete inventory of legacy physical nodes, including discarded nodes.
-     * @param remintedIds Legacy-to-current ID map containing retained nodes only.
-     */
-    constructor(entriesById, remintedIds) {
-        this.entriesById = entriesById;
-        this.remintedIds = remintedIds;
-    }
-    /**
-     * Resolve a legacy node to its reminted ID, or to its nearest retained ancestor when discarded.
-     * Returns null when the reference is null or no retained ancestor exists.
-     */
-    resolve(legacyId) {
-        const traversedIds = [];
-        const visitedIds = new Set();
-        let currentId = legacyId;
-        let resolvedId = null;
-        while (currentId !== null) {
-            const remintedId = this.remintedIds.get(currentId);
-            if (remintedId !== undefined) {
-                resolvedId = remintedId;
-                break;
-            }
-            if (this.resolvedIds.has(currentId)) {
-                resolvedId = this.resolvedIds.get(currentId) ?? null;
-                break;
-            }
-            if (visitedIds.has(currentId))
-                throw new Error(`Cycle in legacy v3 parent chain at entry: ${currentId}`);
-            visitedIds.add(currentId);
-            const entry = this.entriesById.get(currentId);
-            if (entry === undefined)
-                throw new Error(`Missing legacy v3 entry reference: ${currentId}`);
-            traversedIds.push(currentId);
-            currentId = entry.parentId;
-        }
-        for (const traversedId of traversedIds)
-            this.resolvedIds.set(traversedId, resolvedId);
-        return resolvedId;
-    }
-}
-function requireRetainedId(resolver, legacyId) {
-    const importedId = resolver.resolve(legacyId);
-    if (importedId === null)
-        throw new Error(`Legacy v3 entry reference has no retained ancestor: ${legacyId}`);
-    return importedId;
+/** Parent mappings are already folded during the scan; later references need only a lookup. */
+function createLegacyIdResolver(entries) {
+    return (legacyId) => {
+        if (legacyId === null)
+            return null;
+        const mappedId = entries.get(legacyId)?.mappedId;
+        if (mappedId === undefined)
+            throw new Error(`Missing legacy v3 entry reference: ${legacyId}`);
+        return mappedId;
+    };
 }
-function resolveBranchSummaryFromId(resolver, legacyFromId) {
+function resolveBranchSummaryFromId(resolveLegacyId, legacyFromId) {
     // Legacy branchWithSummary() encoded a root source as the "root" sentinel instead of null.
-    return legacyFromId === "root" ? null : resolver.resolve(legacyFromId);
+    return legacyFromId === "root" ? null : resolveLegacyId(legacyFromId);
 }
-function projectContextMessages(entry, resolver) {
+function projectContextMessage(entry, resolveLegacyId) {
     switch (entry.type) {
         case "message":
-            return [entry.message];
+            return entry.message;
         case "custom_message":
-            return [importedCustomMessage(entry)];
+            return importedCustomMessage(entry);
         case "branch_summary":
             return entry.summary
-                ? [
-                    createBranchSummaryMessage(entry.summary, resolveBranchSummaryFromId(resolver, entry.fromId), entry.timestamp),
-                ]
-                : [];
+                ? createBranchSummaryMessage(entry.summary, resolveBranchSummaryFromId(resolveLegacyId, entry.fromId), entry.timestamp)
+                : undefined;
         case "compaction":
-            return [createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp)];
+            return createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp);
         case "custom":
         case "model_change":
         case "thinking_level_change":
         case "active_tools_change":
         case "session_info":
         case "label":
-            return [];
+            return undefined;
     }
 }
-function materializeRetainedTail(compaction, entriesById, resolver) {
-    const reversedTail = [];
-    const visited = new Set();
+/** Walk physical ancestry, including discarded nodes and the exact kept boundary. */
+function* retainedTailStructure(compaction, entriesById) {
     let currentId = compaction.parentId;
     while (currentId !== null) {
-        if (visited.has(currentId))
-            throw new Error(`Cycle in legacy v3 parent chain at entry: ${currentId}`);
-        visited.add(currentId);
+        // The scan guarantees that every parent exists earlier in the file, so cycles are impossible.
         const entry = entriesById.get(currentId);
-        if (entry === undefined)
-            throw new Error(`Missing legacy v3 parent entry: ${currentId}`);
-        reversedTail.push(entry);
-        if (currentId === compaction.firstKeptEntryId) {
-            return reversedTail.reverse().flatMap((tailEntry) => projectContextMessages(tailEntry, resolver));
-        }
+        yield entry;
+        if (currentId === compaction.firstKeptEntryId)
+            return;
         currentId = entry.parentId;
     }
     throw new Error(`Legacy v3 compaction ${compaction.id} firstKeptEntryId is not on its parent branch: ${compaction.firstKeptEntryId}`);
 }
-function normalizeRetainedEntry(entry, seq, entriesById, resolver) {
+function normalizeRetainedEntry(entry, indexed, retainedTail, resolveLegacyId) {
     const committedBase = {
         kind: "entry",
-        id: requireRetainedId(resolver, entry.id),
-        parentId: resolver.resolve(entry.parentId),
-        seq,
+        id: indexed.mappedId,
+        parentId: resolveLegacyId(indexed.parentId),
+        seq: indexed.seq,
         timestamp: Date.parse(entry.timestamp),
     };
     if (entry.type === "message") {
@@ -196,7 +148,7 @@ function normalizeRetainedEntry(entry, seq, entriesById, resolver) {
         return {
             ...committedBase,
             type: "branch_summary",
-            fromId: resolveBranchSummaryFromId(resolver, entry.fromId),
+            fromId: resolveBranchSummaryFromId(resolveLegacyId, entry.fromId),
             summary: entry.summary,
             details: entry.details,
             usage: entry.usage,
@@ -208,7 +160,7 @@ function normalizeRetainedEntry(entry, seq, entriesById, resolver) {
             ...committedBase,
             type: "compaction",
             summary: entry.summary,
-            retainedTail: materializeRetainedTail(entry, entriesById, resolver),
+            retainedTail,
             tokensBefore: entry.tokensBefore,
             details: entry.details,
             usage: entry.usage,
@@ -222,42 +174,30 @@ function normalizeRetainedEntry(entry, seq, entriesById, resolver) {
         data: entry.data,
     };
 }
-const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
 function selectedConfiguration(entriesById, selectedId) {
+    const remaining = new Set([
+        "model_change",
+        "thinking_level_change",
+        "active_tools_change",
+    ]);
     let model;
     let thinkingLevel;
     let activeToolNames;
-    let sawModel = false;
-    let sawThinkingLevel = false;
-    let sawActiveToolNames = false;
-    const visited = new Set();
     let currentId = selectedId;
-    while (currentId !== null && (!sawModel || !sawThinkingLevel || !sawActiveToolNames)) {
-        if (visited.has(currentId))
-            throw new Error(`Cycle in legacy v3 parent chain at entry: ${currentId}`);
-        visited.add(currentId);
+    while (currentId !== null && remaining.size !== 0) {
         const entry = entriesById.get(currentId);
-        if (entry === undefined)
-            throw new Error(`Missing legacy v3 entry reference: ${currentId}`);
-        if (entry.type === "model_change" && !sawModel) {
-            sawModel = true;
-            if (typeof entry.provider === "string" &&
-                entry.provider.length !== 0 &&
-                typeof entry.modelId === "string" &&
-                entry.modelId.length !== 0) {
-                model = { provider: entry.provider, modelId: entry.modelId };
-            }
-        }
-        else if (entry.type === "thinking_level_change" && !sawThinkingLevel) {
-            sawThinkingLevel = true;
-            if (typeof entry.thinkingLevel === "string" && THINKING_LEVELS.has(entry.thinkingLevel)) {
-                thinkingLevel = entry.thinkingLevel;
-            }
-        }
-        else if (entry.type === "active_tools_change" && !sawActiveToolNames) {
-            sawActiveToolNames = true;
-            if (Array.isArray(entry.activeToolNames) && entry.activeToolNames.every((name) => typeof name === "string")) {
-                activeToolNames = [...entry.activeToolNames];
+        // Consume the nearest change even when invalid: older values must not become fallbacks.
+        if (remaining.delete(entry.type)) {
+            switch (entry.type) {
+                case "model_change":
+                    model = { provider: entry.provider, modelId: entry.modelId };
+                    break;
+                case "thinking_level_change":
+                    thinkingLevel = entry.thinkingLevel;
+                    break;
+                case "active_tools_change":
+                    activeToolNames = [...entry.activeToolNames];
+                    break;
             }
         }
         currentId = entry.parentId;
@@ -266,118 +206,257 @@ function selectedConfiguration(entriesById, selectedId) {
         return undefined;
     return { model, thinkingLevel, activeToolNames: activeToolNames ?? [] };
 }
-function normalizeLegacyV3Values(entries, entriesById, resolver, firstSeq) {
-    const writes = [];
-    let latestSessionInfo;
-    for (const entry of entries) {
-        if (entry.type === "session_info")
-            latestSessionInfo = entry;
+function indexLegacyV3Entry(entry, lineNumber, seq, entries) {
+    // SessionManager appends after an existing leaf and writes extracted branches in parent order.
+    const mappedParentId = entry.parentId === null ? null : entries.get(entry.parentId)?.mappedId;
+    if (mappedParentId === undefined) {
+        throw new Error(`Legacy v3 entry ${entry.id} has a missing or forward parent at line ${lineNumber}: ${entry.parentId}`);
     }
-    if (latestSessionInfo?.name) {
-        writes.push({
-            kind: "value",
-            op: "set",
-            seq: firstSeq + writes.length,
-            namespace: sessionName.namespace,
-            key: sessionName.key,
-            value: latestSessionInfo.name,
-        });
+    const structure = {
+        id: entry.id,
+        parentId: entry.parentId,
+        mappedId: mappedParentId,
+    };
+    if (!isRetainedEntry(entry)) {
+        switch (entry.type) {
+            case "label":
+                return { ...structure, type: entry.type, targetId: entry.targetId, label: entry.label };
+            case "model_change":
+                return { ...structure, type: entry.type, provider: entry.provider, modelId: entry.modelId };
+            case "thinking_level_change":
+                return { ...structure, type: entry.type, thinkingLevel: entry.thinkingLevel };
+            case "active_tools_change":
+                return { ...structure, type: entry.type, activeToolNames: entry.activeToolNames };
+            case "session_info":
+                return { ...structure, type: entry.type };
+        }
+    }
+    // Null denotes the root, not a retained node identity that can be reminted.
+    if (entry.id === null)
+        throw new Error("Legacy v3 entry reference has no retained ancestor: null");
+    const retained = {
+        ...structure,
+        mappedId: uuidv7(Date.parse(entry.timestamp)),
+        seq,
+    };
+    switch (entry.type) {
+        case "branch_summary":
+            return { ...retained, type: entry.type, fromId: entry.fromId };
+        case "compaction":
+            return { ...retained, type: entry.type, firstKeptEntryId: entry.firstKeptEntryId };
+        default:
+            return { ...retained, type: entry.type };
+    }
+}
+function legacyEntryUsage(entry) {
+    switch (entry.type) {
+        case "message":
+            return entry.message.role === "assistant" || entry.message.role === "toolResult"
+                ? entry.message.usage
+                : undefined;
+        case "compaction":
+        case "branch_summary":
+            return entry.usage;
+        default:
+            return undefined;
     }
+}
+async function readLegacyV3Inventory(reader, context) {
+    const entries = new Map();
+    let nextSeq = 1;
+    let importedUsage = emptyUsage();
+    let name;
+    let finalId = null;
+    while (true) {
+        const line = fileValue(await reader.readLine(context), "Failed to read legacy v3 source");
+        if (line === undefined || !line.terminated)
+            break;
+        const lineNumber = entries.size + 2;
+        const entry = parseLegacyV3Entry(line.text);
+        if (entries.has(entry.id))
+            throw new Error(`Duplicate legacy v3 entry id: ${entry.id}`);
+        const indexed = indexLegacyV3Entry(entry, lineNumber, nextSeq, entries);
+        entries.set(entry.id, indexed);
+        if (isRetainedEntry(indexed))
+            nextSeq++;
+        finalId = entry.id;
+        if (entry.type === "session_info")
+            name = entry.name;
+        const usage = legacyEntryUsage(entry);
+        if (usage !== undefined)
+            importedUsage = addUsage(importedUsage, usage);
+    }
+    return { entries, nextSeq, importedUsage, name, finalId };
+}
+function normalizeLegacyV3Values(inventory) {
+    const { entries, name, finalId } = inventory;
+    const resolveLegacyId = createLegacyIdResolver(entries);
+    let nextSeq = inventory.nextSeq;
+    const values = [];
+    // session name
+    if (name)
+        values.push({ ...setValue(sessionName, name), seq: nextSeq++ });
+    // labels
     const labels = new Map();
-    for (const entry of entries) {
+    for (const entry of entries.values()) {
         if (entry.type !== "label")
             continue;
-        const targetId = resolver.resolve(entry.targetId);
-        // Labels have no current address when their target has no retained ancestor.
+        const targetId = resolveLegacyId(entry.targetId);
         if (targetId === null)
             continue;
-        // Legacy v3 treated both undefined and the empty string as clearing a label.
         if (entry.label)
             labels.set(targetId, entry.label);
         else
             labels.delete(targetId);
     }
     for (const [targetId, label] of labels) {
-        const address = entryLabel(targetId);
-        writes.push({
-            kind: "value",
-            op: "set",
-            seq: firstSeq + writes.length,
-            namespace: address.namespace,
-            key: address.key,
-            value: label,
-        });
+        values.push({ ...setValue(entryLabel(targetId), label), seq: nextSeq++ });
     }
-    const finalEntry = entries.at(-1);
-    const tipAddress = branchTip("main");
-    writes.push({
-        kind: "value",
-        op: "set",
-        seq: firstSeq + writes.length,
-        namespace: tipAddress.namespace,
-        key: tipAddress.key,
-        value: finalEntry === undefined ? null : resolver.resolve(finalEntry.id),
-    });
-    const configuration = selectedConfiguration(entriesById, finalEntry?.id ?? null);
+    // branch tip
+    values.push({ ...setValue(branchTip("main"), resolveLegacyId(finalId)), seq: nextSeq++ });
+    // configuration
+    const configuration = selectedConfiguration(entries, finalId);
     if (configuration !== undefined) {
-        const configAddress = laneConfig("main");
-        writes.push({
-            kind: "value",
-            op: "set",
-            seq: firstSeq + writes.length,
-            namespace: configAddress.namespace,
-            key: configAddress.key,
-            value: configuration,
-        });
-        const stateAddress = laneState("main");
-        writes.push({
-            kind: "value",
-            op: "set",
-            seq: firstSeq + writes.length,
-            namespace: stateAddress.namespace,
-            key: stateAddress.key,
-            value: { currentOperationId: null, lastOperationId: null, inbox: [] },
+        values.push({ ...setValue(laneConfig("main"), configuration), seq: nextSeq++ });
+        values.push({
+            ...setValue(laneState("main"), { currentOperationId: null, lastOperationId: null, inbox: [] }),
+            seq: nextSeq++,
         });
     }
-    return writes;
+    return values;
 }
-function aggregateImportedUsage(entries) {
-    let aggregate = emptyUsage();
-    for (const entry of entries) {
-        let usage;
-        if (entry.type === "message") {
-            if (entry.message.role === "assistant")
-                usage = entry.message.usage;
-            else if (entry.message.role === "toolResult")
-                usage = entry.message.usage;
+/**
+ * A captured legacy file exposed as repeatable logical v4 writes.
+ * Each pass reopens the path; callers must not replace or edit the source between passes.
+ * Structural indexes, label/configuration metadata, and derived current values survive between scans.
+ */
+export class LegacyV3Source {
+    header;
+    importedUsage;
+    nextSeq;
+    values;
+    fileSystem;
+    path;
+    entries;
+    resolveLegacyId;
+    constructor(fileSystem, path, header, entries, importedUsage, values, nextSeq) {
+        this.fileSystem = fileSystem;
+        this.path = path;
+        this.header = header;
+        this.entries = entries;
+        this.resolveLegacyId = createLegacyIdResolver(entries);
+        this.importedUsage = importedUsage;
+        this.values = values;
+        this.nextSeq = nextSeq;
+    }
+    /**
+     * Scan complete v3 records without modifying the file, ignoring an unterminated final line.
+     * Build parent mappings, assign IDs stable for this source instance, and derive current values
+     * and imported usage. Retain metadata, not conversation payloads or an open reader. writes()
+     * reopens the path to materialize captured records and resolve their payload-specific references.
+     */
+    static async read(fileSystem, path, context) {
+        const reader = fileValue(await fileSystem.openTextLineReader(path, context), `Failed to open legacy v3 source ${path}`);
+        try {
+            const parsed = await readJsonlHeader(reader, path, context);
+            if (parsed.format !== "v3-legacy") {
+                throw new Error(`Invalid legacy v3 JSONL storage ${path}: expected format 3 header`);
+            }
+            const inventory = await readLegacyV3Inventory(reader, context);
+            const values = normalizeLegacyV3Values(inventory);
+            return new LegacyV3Source(fileSystem, path, await normalizeLegacyV3Header(fileSystem, parsed.header, context), inventory.entries, inventory.importedUsage, values, inventory.nextSeq + values.length);
         }
-        else if (entry.type === "compaction" || entry.type === "branch_summary") {
-            usage = entry.usage;
+        finally {
+            await reader.close(context);
         }
-        if (usage !== undefined)
-            aggregate = addUsage(aggregate, usage);
     }
-    return aggregate;
-}
-/** Normalize the currently supported v3 records without touching their source file. */
-export function normalizeLegacyV3Records(recordLines) {
-    const entries = recordLines.map((line, index) => parseLegacyV3Entry(line, index + 2));
-    const entriesById = new Map();
-    for (const entry of entries) {
-        if (entriesById.has(entry.id))
-            throw new Error(`Duplicate legacy v3 entry id: ${entry.id}`);
-        entriesById.set(entry.id, entry);
+    *entryStructures() {
+        for (const entry of this.entries.values()) {
+            if (!isRetainedEntry(entry))
+                continue;
+            yield { id: entry.mappedId, parentId: this.resolveLegacyId(entry.parentId), seq: entry.seq };
+        }
+    }
+    translateForkEntryId(legacyId) {
+        const entry = this.entries.get(legacyId);
+        if (entry === undefined)
+            throw new Error(`Legacy v3 fork entry does not exist: ${legacyId}`);
+        if (!isRetainedEntry(entry))
+            throw new Error(`Legacy v3 fork entry is not a retained entry: ${legacyId}`);
+        return entry.mappedId;
+    }
+    collectRequiredTailMessageIds(isEntrySelected) {
+        const requiredIds = new Set();
+        for (const entry of this.entries.values()) {
+            if (entry.type !== "compaction")
+                continue;
+            const compactionIsSelected = isEntrySelected === undefined || isEntrySelected(entry.mappedId);
+            if (!compactionIsSelected)
+                continue;
+            // Walk from the compaction's parent through firstKeptEntryId, inclusive.
+            for (const tailEntry of retainedTailStructure(entry, this.entries)) {
+                const canProduceContextMessage = isRetainedEntry(tailEntry) && tailEntry.type !== "custom";
+                if (canProduceContextMessage)
+                    requiredIds.add(tailEntry.id);
+            }
+        }
+        return requiredIds;
+    }
+    /**
+     * Stream normalized v4 entries, optionally filtered by reminted ID, followed by derived current values.
+     * Each pass owns its reader and message cache, sharing only the captured IDs and metadata.
+     */
+    async *writes(context, isEntrySelected) {
+        const requiredTailMessageIds = this.collectRequiredTailMessageIds(isEntrySelected);
+        // Keep needed context messages for this entire pass; tails may revisit old or shared branches.
+        const tailMessagesByLegacyId = new Map();
+        for await (const { entry, indexed } of this.readCapturedEntries(context)) {
+            if (requiredTailMessageIds.has(entry.id)) {
+                const message = projectContextMessage(entry, this.resolveLegacyId);
+                if (message !== undefined)
+                    tailMessagesByLegacyId.set(entry.id, message);
+            }
+            if (!isRetainedEntry(indexed) || !isRetainedEntry(entry))
+                continue;
+            if (isEntrySelected !== undefined && !isEntrySelected(indexed.mappedId))
+                continue;
+            const retainedTail = [];
+            if (indexed.type === "compaction") {
+                for (const ancestor of retainedTailStructure(indexed, this.entries)) {
+                    const message = tailMessagesByLegacyId.get(ancestor.id);
+                    if (message !== undefined)
+                        retainedTail.push(message);
+                }
+                retainedTail.reverse();
+            }
+            yield normalizeRetainedEntry(entry, indexed, retainedTail, this.resolveLegacyId);
+        }
+        yield* this.values;
+    }
+    /** Replay only the captured prefix and verify its physical identities before materialization. */
+    async *readCapturedEntries(context) {
+        const reader = fileValue(await this.fileSystem.openTextLineReader(this.path, context), `Failed to reopen legacy v3 source ${this.path}`);
+        try {
+            const parsed = await readJsonlHeader(reader, this.path, context);
+            if (parsed.format !== "v3-legacy" ||
+                parsed.header.id !== this.header.id ||
+                parsed.header.cwd !== this.header.cwd) {
+                throw new Error("Legacy v3 source header changed");
+            }
+            for (const indexed of this.entries.values()) {
+                const line = fileValue(await reader.readLine(context), "Failed to reread legacy v3 source");
+                if (line === undefined || !line.terminated)
+                    throw new Error("Legacy v3 source ended before captured entries");
+                const entry = parseLegacyV3Entry(line.text);
+                if (entry.id !== indexed.id || entry.type !== indexed.type) {
+                    throw new Error("Legacy v3 source changed");
+                }
+                yield { entry, indexed };
+            }
+        }
+        finally {
+            await reader.close(context);
+        }
     }
-    const retainedEntries = entries.filter(isRetainedEntry);
-    const remintedIds = new Map(retainedEntries.map((entry) => [entry.id, uuidv7(Date.parse(entry.timestamp))]));
-    const resolver = new RetainedIdResolver(entriesById, remintedIds);
-    const entryWrites = retainedEntries.map((entry, index) => normalizeRetainedEntry(entry, index + 1, entriesById, resolver));
-    const valueWrites = normalizeLegacyV3Values(entries, entriesById, resolver, entryWrites.length + 1);
-    const writes = [...entryWrites, ...valueWrites];
-    return {
-        writes,
-        importedUsage: aggregateImportedUsage(entries),
-        nextSeq: writes.length + 1,
-    };
 }
 //# sourceMappingURL=legacy-v3.js.map