@tearleads/client-sdk 0.1.63 → 0.1.65

package/data/persistence/principalHistoryIncompleteRetention.js

@@ -1,26 +0,0 @@
-import { and, asc, desc, eq, inArray, ne } from "drizzle-orm";
-import { principalHistoryStages } from "../sqlite/principalHistoryStageSchema.js";
-import { releasePrincipalHistoryRoot } from "./principalHistoryRootOwnership.js";
-const INCOMPLETE_STAGE_LIMIT = 8;
-const RECLAIM_BATCH_LIMIT = 16;
-/** Disposable work only: completed artifacts and trust pins are unaffected. */
-export async function reclaimIncompletePrincipalHistoryStages(tx, current) {
-    const obsolete = await tx
-        .select({ id: principalHistoryStages.id })
-        .from(principalHistoryStages)
-        .where(and(eq(principalHistoryStages.scopeId, current.scopeId), eq(principalHistoryStages.organizationId, current.organizationId), eq(principalHistoryStages.complete, false), ne(principalHistoryStages.id, current.id)))
-        .orderBy(desc(principalHistoryStages.touchedAt), asc(principalHistoryStages.id))
-        // The writer always keeps its own stage, even when recency hints tie.
-        .offset(INCOMPLETE_STAGE_LIMIT - (current.complete ? 0 : 1))
-        .limit(RECLAIM_BATCH_LIMIT);
-    const ids = obsolete.map(({ id }) => id);
-    for (const id of ids)
-        await releasePrincipalHistoryRoot(tx, `stage:${id}`);
-    if (ids.length === 0)
-        return;
-    await tx
-        .delete(principalHistoryStages)
-        .where(inArray(principalHistoryStages.id, ids))
-        .run();
-}
-//# sourceMappingURL=principalHistoryIncompleteRetention.js.map

package/data/persistence/principalHistoryIncompleteRetention.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"principalHistoryIncompleteRetention.js","sourceRoot":"","sources":["principalHistoryIncompleteRetention.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAE/E,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAE9E,MAAM,sBAAsB,GAAG,CAAC,CAAC;AACjC,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAE/B,+EAA+E;AAC/E,MAAM,CAAC,KAAK,UAAU,uCAAuC,CAC3D,EAAgC,EAChC,OAKC;IAED,MAAM,QAAQ,GAAG,MAAM,EAAE;SACtB,MAAM,CAAC,EAAE,EAAE,EAAE,sBAAsB,CAAC,EAAE,EAAE,CAAC;SACzC,IAAI,CAAC,sBAAsB,CAAC;SAC5B,KAAK,CACJ,GAAG,CACD,EAAE,CAAC,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EACnD,EAAE,CAAC,sBAAsB,CAAC,cAAc,EAAE,OAAO,CAAC,cAAc,CAAC,EACjE,EAAE,CAAC,sBAAsB,CAAC,QAAQ,EAAE,KAAK,CAAC,EAC1C,EAAE,CAAC,sBAAsB,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,CAAC,CAC1C,CACF;SACA,OAAO,CACN,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,EACtC,GAAG,CAAC,sBAAsB,CAAC,EAAE,CAAC,CAC/B;QACD,sEAAsE;SACrE,MAAM,CAAC,sBAAsB,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC3D,KAAK,CAAC,mBAAmB,CAAC,CAAC;IAC9B,MAAM,GAAG,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;IACzC,KAAK,MAAM,EAAE,IAAI,GAAG;QAAE,MAAM,2BAA2B,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;IAC3E,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAC7B,MAAM,EAAE;SACL,MAAM,CAAC,sBAAsB,CAAC;SAC9B,KAAK,CAAC,OAAO,CAAC,sBAAsB,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;SAC9C,GAAG,EAAE,CAAC;AACX,CAAC","sourcesContent":["import { and, asc, desc, eq, inArray, ne } from \"drizzle-orm\";\nimport { principalHistoryStages } from \"../sqlite/principalHistoryStageSchema\";\nimport type { ClientSQLiteTransactionScope } from \"../sqlite/sqlitePersistenceRuntime\";\nimport { releasePrincipalHistoryRoot } from \"./principalHistoryRootOwnership\";\n\nconst INCOMPLETE_STAGE_LIMIT = 8;\nconst RECLAIM_BATCH_LIMIT = 16;\n\n/** Disposable work only: completed artifacts and trust pins are unaffected. */\nexport async function reclaimIncompletePrincipalHistoryStages(\n  tx: ClientSQLiteTransactionScope,\n  current: {\n    readonly id: string;\n    readonly scopeId: string;\n    readonly organizationId: string;\n    readonly complete: boolean;\n  },\n) {\n  const obsolete = await tx\n    .select({ id: principalHistoryStages.id })\n    .from(principalHistoryStages)\n    .where(\n      and(\n        eq(principalHistoryStages.scopeId, current.scopeId),\n        eq(principalHistoryStages.organizationId, current.organizationId),\n        eq(principalHistoryStages.complete, false),\n        ne(principalHistoryStages.id, current.id),\n      ),\n    )\n    .orderBy(\n      desc(principalHistoryStages.touchedAt),\n      asc(principalHistoryStages.id),\n    )\n    // The writer always keeps its own stage, even when recency hints tie.\n    .offset(INCOMPLETE_STAGE_LIMIT - (current.complete ? 0 : 1))\n    .limit(RECLAIM_BATCH_LIMIT);\n  const ids = obsolete.map(({ id }) => id);\n  for (const id of ids) await releasePrincipalHistoryRoot(tx, `stage:${id}`);\n  if (ids.length === 0) return;\n  await tx\n    .delete(principalHistoryStages)\n    .where(inArray(principalHistoryStages.id, ids))\n    .run();\n}\n"]}

package/data/persistence/principalHistoryNodeRetention.js

@@ -1,201 +0,0 @@
-import { and, asc, eq, inArray } from "drizzle-orm";
-import { principalHistoryNodes } from "../sqlite/principalHistoryEvidenceSchema.js";
-import { principalHistoryNodeReferences } from "../sqlite/principalHistoryNodeRetentionSchema.js";
-import { sqliteInsertBatchSize, sqliteRowsPerStatement, } from "../sqlite/sqliteBindBudget.js";
-import { excludedValue } from "../sqlite/sqliteUpsert.js";
-import { decrementPrincipalHistoryNodeReference, } from "./principalHistoryRootOwnership.js";
-const REFERENCE_WRITE_BATCH_SIZE = sqliteInsertBatchSize(principalHistoryNodeReferences);
-const NODE_WRITE_BATCH_SIZE = sqliteInsertBatchSize(principalHistoryNodes);
-// The scope id binds once per lookup.
-const HASH_LOOKUP_BATCH_SIZE = sqliteRowsPerStatement(1, 1);
-function batches(items, size) {
-    const result = [];
-    for (let index = 0; index < items.length; index += size)
-        result.push(items.slice(index, index + size));
-    return result;
-}
-async function loadNodeReferences(tx, scope, hashes, into) {
-    const missing = [...new Set(hashes)].filter((hash) => !into.has(hash));
-    for (const batch of batches(missing, HASH_LOOKUP_BATCH_SIZE)) {
-        for (const hash of batch)
-            into.set(hash, null);
-        const rows = await tx
-            .select()
-            .from(principalHistoryNodeReferences)
-            .where(and(eq(principalHistoryNodeReferences.scopeId, scope.scopeId), inArray(principalHistoryNodeReferences.hash, batch)));
-        for (const row of rows)
-            into.set(row.hash, row);
-    }
-}
-async function loadStoredNodeHashes(tx, scope, hashes) {
-    const stored = new Set();
-    for (const batch of batches([...new Set(hashes)], HASH_LOOKUP_BATCH_SIZE)) {
-        const rows = await tx
-            .select({ hash: principalHistoryNodes.hash })
-            .from(principalHistoryNodes)
-            .where(and(eq(principalHistoryNodes.scopeId, scope.scopeId), inArray(principalHistoryNodes.hash, batch)));
-        for (const row of rows)
-            stored.add(row.hash);
-    }
-    return stored;
-}
-/**
- * Replays the per-node edge bookkeeping in memory: increment inserts or adds
- * one, decrement floors at zero within the scope's organization, and an edge
- * change keeps the count while marking nodes first stored here as managed.
- */
-function replayNodeEdges(scope, nodes, loaded, storedNodeHashes) {
-    const references = new Map(loaded);
-    const read = (hash) => {
-        const reference = references.get(hash);
-        if (reference === undefined)
-            throw new Error("Principal history node reference was not loaded");
-        return reference;
-    };
-    const increment = (hash) => {
-        const reference = read(hash);
-        references.set(hash, reference
-            ? { ...reference, referenceCount: reference.referenceCount + 1 }
-            : {
-                ...scope,
-                hash,
-                referenceCount: 1,
-                managed: false,
-                leftHash: null,
-                rightHash: null,
-            });
-    };
-    const decrement = (hash) => {
-        const reference = read(hash);
-        if (reference?.organizationId === scope.organizationId)
-            references.set(hash, {
-                ...reference,
-                referenceCount: Math.max(reference.referenceCount - 1, 0),
-            });
-    };
-    for (const node of nodes) {
-        const previous = read(node.hash);
-        if (previous?.leftHash !== node.leftHash ||
-            previous.rightHash !== node.rightHash) {
-            const managed = previous?.managed || !storedNodeHashes.has(node.hash);
-            increment(node.leftHash);
-            increment(node.rightHash);
-            const current = read(node.hash);
-            references.set(node.hash, {
-                ...(current ?? {
-                    ...scope,
-                    hash: node.hash,
-                    referenceCount: previous?.referenceCount ?? 0,
-                }),
-                leftHash: node.leftHash,
-                rightHash: node.rightHash,
-                managed,
-            });
-            for (const hash of [previous?.leftHash, previous?.rightHash])
-                if (hash)
-                    decrement(hash);
-        }
-        storedNodeHashes.add(node.hash);
-    }
-    return references;
-}
-function isSameNodeReference(left, right) {
-    return (left.organizationId === right.organizationId &&
-        left.referenceCount === right.referenceCount &&
-        left.managed === right.managed &&
-        left.leftHash === right.leftHash &&
-        left.rightHash === right.rightHash);
-}
-/**
- * Register edges and store proof nodes in the given order, with the same
- * result as recording each node's edges and then upserting it. Reads the
- * touched liveness rows once, replays the bookkeeping, and writes the changed
- * rows and the nodes as multi-row upserts.
- */
-export async function writePrincipalHistoryNodes(tx, scope, nodes) {
-    if (nodes.length === 0)
-        return;
-    const loaded = new Map();
-    await loadNodeReferences(tx, scope, nodes.flatMap((node) => [node.hash, node.leftHash, node.rightHash]), loaded);
-    // An edge change releases the stored row's previous children.
-    await loadNodeReferences(tx, scope, nodes.flatMap((node) => {
-        const stored = loaded.get(node.hash);
-        return [stored?.leftHash, stored?.rightHash].filter((hash) => Boolean(hash));
-    }), loaded);
-    const replayed = replayNodeEdges(scope, nodes, loaded, await loadStoredNodeHashes(tx, scope, nodes.map((node) => node.hash)));
-    const changed = [...replayed].flatMap(([hash, reference]) => {
-        const before = loaded.get(hash);
-        return reference && !(before && isSameNodeReference(before, reference))
-            ? [reference]
-            : [];
-    });
-    for (const batch of batches(changed, REFERENCE_WRITE_BATCH_SIZE))
-        await tx
-            .insert(principalHistoryNodeReferences)
-            .values(batch)
-            .onConflictDoUpdate({
-            target: [
-                principalHistoryNodeReferences.scopeId,
-                principalHistoryNodeReferences.hash,
-            ],
-            set: {
-                referenceCount: excludedValue(principalHistoryNodeReferences.referenceCount),
-                managed: excludedValue(principalHistoryNodeReferences.managed),
-                leftHash: excludedValue(principalHistoryNodeReferences.leftHash),
-                rightHash: excludedValue(principalHistoryNodeReferences.rightHash),
-            },
-        })
-            .run();
-    const nodeRows = new Map(nodes.map((node) => [
-        node.hash,
-        {
-            ...scope,
-            hash: node.hash,
-            leftHash: node.leftHash,
-            rightHash: node.rightHash,
-        },
-    ]));
-    for (const batch of batches([...nodeRows.values()], NODE_WRITE_BATCH_SIZE))
-        await tx
-            .insert(principalHistoryNodes)
-            .values(batch)
-            .onConflictDoUpdate({
-            target: [principalHistoryNodes.scopeId, principalHistoryNodes.hash],
-            set: {
-                organizationId: excludedValue(principalHistoryNodes.organizationId),
-                leftHash: excludedValue(principalHistoryNodes.leftHash),
-                rightHash: excludedValue(principalHistoryNodes.rightHash),
-            },
-        })
-            .run();
-}
-/** A bounded cascade releases only managed proof nodes with no live incoming edge. */
-export async function reclaimPrincipalHistoryNodes(tx, scope) {
-    let reclaimed = 0;
-    while (reclaimed < 64) {
-        const obsolete = await tx
-            .select()
-            .from(principalHistoryNodeReferences)
-            .where(and(eq(principalHistoryNodeReferences.scopeId, scope.scopeId), eq(principalHistoryNodeReferences.organizationId, scope.organizationId), eq(principalHistoryNodeReferences.managed, true), eq(principalHistoryNodeReferences.referenceCount, 0)))
-            .orderBy(asc(principalHistoryNodeReferences.hash))
-            .limit(64 - reclaimed);
-        if (obsolete.length === 0)
-            break;
-        for (const node of obsolete) {
-            await tx
-                .delete(principalHistoryNodes)
-                .where(and(eq(principalHistoryNodes.scopeId, scope.scopeId), eq(principalHistoryNodes.organizationId, scope.organizationId), eq(principalHistoryNodes.hash, node.hash)))
-                .run();
-            await tx
-                .delete(principalHistoryNodeReferences)
-                .where(and(eq(principalHistoryNodeReferences.scopeId, scope.scopeId), eq(principalHistoryNodeReferences.hash, node.hash)))
-                .run();
-            for (const hash of [node.leftHash, node.rightHash])
-                if (hash)
-                    await decrementPrincipalHistoryNodeReference(tx, scope, hash);
-            reclaimed += 1;
-        }
-    }
-    return reclaimed;
-}
-//# sourceMappingURL=principalHistoryNodeRetention.js.map

package/data/persistence/principalHistoryNodeRetention.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"principalHistoryNodeRetention.js","sourceRoot":"","sources":["principalHistoryNodeRetention.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EAAE,8BAA8B,EAAE,MAAM,+CAA+C,CAAC;AAC/F,OAAO,EACL,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EACL,sCAAsC,GAEvC,MAAM,iCAAiC,CAAC;AAKzC,MAAM,0BAA0B,GAAG,qBAAqB,CACtD,8BAA8B,CAC/B,CAAC;AACF,MAAM,qBAAqB,GAAG,qBAAqB,CAAC,qBAAqB,CAAC,CAAC;AAC3E,sCAAsC;AACtC,MAAM,sBAAsB,GAAG,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAE5D,SAAS,OAAO,CAAI,KAAmB,EAAE,IAAY;IACnD,MAAM,MAAM,GAAU,EAAE,CAAC;IACzB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI,IAAI;QACrD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC;IAChD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,KAAK,UAAU,kBAAkB,CAC/B,EAAgC,EAChC,KAAgC,EAChC,MAAyB,EACzB,IAAuD;IAEvD,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACvE,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,OAAO,EAAE,sBAAsB,CAAC,EAAE,CAAC;QAC7D,KAAK,MAAM,IAAI,IAAI,KAAK;YAAE,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC/C,MAAM,IAAI,GAAG,MAAM,EAAE;aAClB,MAAM,EAAE;aACR,IAAI,CAAC,8BAA8B,CAAC;aACpC,KAAK,CACJ,GAAG,CACD,EAAE,CAAC,8BAA8B,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,EACzD,OAAO,CAAC,8BAA8B,CAAC,IAAI,EAAE,KAAK,CAAC,CACpD,CACF,CAAC;QACJ,KAAK,MAAM,GAAG,IAAI,IAAI;YAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAClD,CAAC;AACH,CAAC;AAED,KAAK,UAAU,oBAAoB,CACjC,EAAgC,EAChC,KAAgC,EAChC,MAAyB;IAEzB,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU,CAAC;IACjC,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,sBAAsB,CAAC,EAAE,CAAC;QAC1E,MAAM,IAAI,GAAG,MAAM,EAAE;aAClB,MAAM,CAAC,EAAE,IAAI,EAAE,qBAAqB,CAAC,IAAI,EAAE,CAAC;aAC5C,IAAI,CAAC,qBAAqB,CAAC;aAC3B,KAAK,CACJ,GAAG,CACD,EAAE,CAAC,qBAAqB,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,EAChD,OAAO,CAAC,qBAAqB,CAAC,IAAI,EAAE,KAAK,CAAC,CAC3C,CACF,CAAC;QACJ,KAAK,MAAM,GAAG,IAAI,IAAI;YAAE,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CACtB,KAAgC,EAChC,KAA2C,EAC3C,MAAiE,EACjE,gBAA6B;IAE7B,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC;IACnC,MAAM,IAAI,GAAG,CAAC,IAAY,EAAE,EAAE;QAC5B,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,SAAS,KAAK,SAAS;YACzB,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACrE,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;IACF,MAAM,SAAS,GAAG,CAAC,IAAY,EAAE,EAAE;QACjC,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QAC7B,UAAU,CAAC,GAAG,CACZ,IAAI,EACJ,SAAS;YACP,CAAC,CAAC,EAAE,GAAG,SAAS,EAAE,cAAc,EAAE,SAAS,CAAC,cAAc,GAAG,CAAC,EAAE;YAChE,CAAC,CAAC;gBACE,GAAG,KAAK;gBACR,IAAI;gBACJ,cAAc,EAAE,CAAC;gBACjB,OAAO,EAAE,KAAK;gBACd,QAAQ,EAAE,IAAI;gBACd,SAAS,EAAE,IAAI;aAChB,CACN,CAAC;IACJ,CAAC,CAAC;IACF,MAAM,SAAS,GAAG,CAAC,IAAY,EAAE,EAAE;QACjC,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QAC7B,IAAI,SAAS,EAAE,cAAc,KAAK,KAAK,CAAC,cAAc;YACpD,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE;gBACnB,GAAG,SAAS;gBACZ,cAAc,EAAE,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,cAAc,GAAG,CAAC,EAAE,CAAC,CAAC;aAC1D,CAAC,CAAC;IACP,CAAC,CAAC;IACF,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACjC,IACE,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC,QAAQ;YACpC,QAAQ,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS,EACrC,CAAC;YACD,MAAM,OAAO,GAAG,QAAQ,EAAE,OAAO,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACtE,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACzB,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAChC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE;gBACxB,GAAG,CAAC,OAAO,IAAI;oBACb,GAAG,KAAK;oBACR,IAAI,EAAE,IAAI,CAAC,IAAI;oBACf,cAAc,EAAE,QAAQ,EAAE,cAAc,IAAI,CAAC;iBAC9C,CAAC;gBACF,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,OAAO;aACR,CAAC,CAAC;YACH,KAAK,MAAM,IAAI,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC;gBAC1D,IAAI,IAAI;oBAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;QACD,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,SAAS,mBAAmB,CAC1B,IAAmC,EACnC,KAAoC;IAEpC,OAAO,CACL,IAAI,CAAC,cAAc,KAAK,KAAK,CAAC,cAAc;QAC5C,IAAI,CAAC,cAAc,KAAK,KAAK,CAAC,cAAc;QAC5C,IAAI,CAAC,OAAO,KAAK,KAAK,CAAC,OAAO;QAC9B,IAAI,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ;QAChC,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS,CACnC,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAC9C,EAAgC,EAChC,KAAgC,EAChC,KAA2C;IAE3C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAC/B,MAAM,MAAM,GAAG,IAAI,GAAG,EAAgD,CAAC;IACvE,MAAM,kBAAkB,CACtB,EAAE,EACF,KAAK,EACL,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,EACnE,MAAM,CACP,CAAC;IACF,8DAA8D;IAC9D,MAAM,kBAAkB,CACtB,EAAE,EACF,KAAK,EACL,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;QACrB,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrC,OAAO,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,MAAM,CACjD,CAAC,IAAI,EAAkB,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CACxC,CAAC;IACJ,CAAC,CAAC,EACF,MAAM,CACP,CAAC;IACF,MAAM,QAAQ,GAAG,eAAe,CAC9B,KAAK,EACL,KAAK,EACL,MAAM,EACN,MAAM,oBAAoB,CACxB,EAAE,EACF,KAAK,EACL,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAC/B,CACF,CAAC;IACF,MAAM,OAAO,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE;QAC1D,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAChC,OAAO,SAAS,IAAI,CAAC,CAAC,MAAM,IAAI,mBAAmB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;YACrE,CAAC,CAAC,CAAC,SAAS,CAAC;YACb,CAAC,CAAC,EAAE,CAAC;IACT,CAAC,CAAC,CAAC;IACH,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,OAAO,EAAE,0BAA0B,CAAC;QAC9D,MAAM,EAAE;aACL,MAAM,CAAC,8BAA8B,CAAC;aACtC,MAAM,CAAC,KAAK,CAAC;aACb,kBAAkB,CAAC;YAClB,MAAM,EAAE;gBACN,8BAA8B,CAAC,OAAO;gBACtC,8BAA8B,CAAC,IAAI;aACpC;YACD,GAAG,EAAE;gBACH,cAAc,EAAE,aAAa,CAC3B,8BAA8B,CAAC,cAAc,CAC9C;gBACD,OAAO,EAAE,aAAa,CAAC,8BAA8B,CAAC,OAAO,CAAC;gBAC9D,QAAQ,EAAE,aAAa,CAAC,8BAA8B,CAAC,QAAQ,CAAC;gBAChE,SAAS,EAAE,aAAa,CAAC,8BAA8B,CAAC,SAAS,CAAC;aACnE;SACF,CAAC;aACD,GAAG,EAAE,CAAC;IACX,MAAM,QAAQ,GAAG,IAAI,GAAG,CACtB,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QAClB,IAAI,CAAC,IAAI;QACT;YACE,GAAG,KAAK;YACR,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B;KACF,CAAC,CACH,CAAC;IACF,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,qBAAqB,CAAC;QACxE,MAAM,EAAE;aACL,MAAM,CAAC,qBAAqB,CAAC;aAC7B,MAAM,CAAC,KAAK,CAAC;aACb,kBAAkB,CAAC;YAClB,MAAM,EAAE,CAAC,qBAAqB,CAAC,OAAO,EAAE,qBAAqB,CAAC,IAAI,CAAC;YACnE,GAAG,EAAE;gBACH,cAAc,EAAE,aAAa,CAAC,qBAAqB,CAAC,cAAc,CAAC;gBACnE,QAAQ,EAAE,aAAa,CAAC,qBAAqB,CAAC,QAAQ,CAAC;gBACvD,SAAS,EAAE,aAAa,CAAC,qBAAqB,CAAC,SAAS,CAAC;aAC1D;SACF,CAAC;aACD,GAAG,EAAE,CAAC;AACb,CAAC;AAED,sFAAsF;AACtF,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAChD,EAAgC,EAChC,KAAgC;IAEhC,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,OAAO,SAAS,GAAG,EAAE,EAAE,CAAC;QACtB,MAAM,QAAQ,GAAG,MAAM,EAAE;aACtB,MAAM,EAAE;aACR,IAAI,CAAC,8BAA8B,CAAC;aACpC,KAAK,CACJ,GAAG,CACD,EAAE,CAAC,8BAA8B,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,EACzD,EAAE,CACA,8BAA8B,CAAC,cAAc,EAC7C,KAAK,CAAC,cAAc,CACrB,EACD,EAAE,CAAC,8BAA8B,CAAC,OAAO,EAAE,IAAI,CAAC,EAChD,EAAE,CAAC,8BAA8B,CAAC,cAAc,EAAE,CAAC,CAAC,CACrD,CACF;aACA,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,IAAI,CAAC,CAAC;aACjD,KAAK,CAAC,EAAE,GAAG,SAAS,CAAC,CAAC;QACzB,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;YAAE,MAAM;QACjC,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;YAC5B,MAAM,EAAE;iBACL,MAAM,CAAC,qBAAqB,CAAC;iBAC7B,KAAK,CACJ,GAAG,CACD,EAAE,CAAC,qBAAqB,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,EAChD,EAAE,CAAC,qBAAqB,CAAC,cAAc,EAAE,KAAK,CAAC,cAAc,CAAC,EAC9D,EAAE,CAAC,qBAAqB,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAC1C,CACF;iBACA,GAAG,EAAE,CAAC;YACT,MAAM,EAAE;iBACL,MAAM,CAAC,8BAA8B,CAAC;iBACtC,KAAK,CACJ,GAAG,CACD,EAAE,CAAC,8BAA8B,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,EACzD,EAAE,CAAC,8BAA8B,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CACnD,CACF;iBACA,GAAG,EAAE,CAAC;YACT,KAAK,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC;gBAChD,IAAI,IAAI;oBAAE,MAAM,sCAAsC,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;YAC1E,SAAS,IAAI,CAAC,CAAC;QACjB,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["import type { PrincipalHistoryIndexNode } from \"@tearleads/crypto\";\nimport { and, asc, eq, inArray } from \"drizzle-orm\";\nimport { principalHistoryNodes } from \"../sqlite/principalHistoryEvidenceSchema\";\nimport { principalHistoryNodeReferences } from \"../sqlite/principalHistoryNodeRetentionSchema\";\nimport {\n  sqliteInsertBatchSize,\n  sqliteRowsPerStatement,\n} from \"../sqlite/sqliteBindBudget\";\nimport type { ClientSQLiteTransactionScope } from \"../sqlite/sqlitePersistenceRuntime\";\nimport { excludedValue } from \"../sqlite/sqliteUpsert\";\nimport {\n  decrementPrincipalHistoryNodeReference,\n  type PrincipalHistoryNodeScope,\n} from \"./principalHistoryRootOwnership\";\n\ntype PrincipalHistoryNodeReference =\n  typeof principalHistoryNodeReferences.$inferSelect;\n\nconst REFERENCE_WRITE_BATCH_SIZE = sqliteInsertBatchSize(\n  principalHistoryNodeReferences,\n);\nconst NODE_WRITE_BATCH_SIZE = sqliteInsertBatchSize(principalHistoryNodes);\n// The scope id binds once per lookup.\nconst HASH_LOOKUP_BATCH_SIZE = sqliteRowsPerStatement(1, 1);\n\nfunction batches<T>(items: readonly T[], size: number): T[][] {\n  const result: T[][] = [];\n  for (let index = 0; index < items.length; index += size)\n    result.push(items.slice(index, index + size));\n  return result;\n}\n\nasync function loadNodeReferences(\n  tx: ClientSQLiteTransactionScope,\n  scope: PrincipalHistoryNodeScope,\n  hashes: readonly string[],\n  into: Map<string, PrincipalHistoryNodeReference | null>,\n): Promise<void> {\n  const missing = [...new Set(hashes)].filter((hash) => !into.has(hash));\n  for (const batch of batches(missing, HASH_LOOKUP_BATCH_SIZE)) {\n    for (const hash of batch) into.set(hash, null);\n    const rows = await tx\n      .select()\n      .from(principalHistoryNodeReferences)\n      .where(\n        and(\n          eq(principalHistoryNodeReferences.scopeId, scope.scopeId),\n          inArray(principalHistoryNodeReferences.hash, batch),\n        ),\n      );\n    for (const row of rows) into.set(row.hash, row);\n  }\n}\n\nasync function loadStoredNodeHashes(\n  tx: ClientSQLiteTransactionScope,\n  scope: PrincipalHistoryNodeScope,\n  hashes: readonly string[],\n): Promise<Set<string>> {\n  const stored = new Set<string>();\n  for (const batch of batches([...new Set(hashes)], HASH_LOOKUP_BATCH_SIZE)) {\n    const rows = await tx\n      .select({ hash: principalHistoryNodes.hash })\n      .from(principalHistoryNodes)\n      .where(\n        and(\n          eq(principalHistoryNodes.scopeId, scope.scopeId),\n          inArray(principalHistoryNodes.hash, batch),\n        ),\n      );\n    for (const row of rows) stored.add(row.hash);\n  }\n  return stored;\n}\n\n/**\n * Replays the per-node edge bookkeeping in memory: increment inserts or adds\n * one, decrement floors at zero within the scope's organization, and an edge\n * change keeps the count while marking nodes first stored here as managed.\n */\nfunction replayNodeEdges(\n  scope: PrincipalHistoryNodeScope,\n  nodes: readonly PrincipalHistoryIndexNode[],\n  loaded: ReadonlyMap<string, PrincipalHistoryNodeReference | null>,\n  storedNodeHashes: Set<string>,\n): Map<string, PrincipalHistoryNodeReference | null> {\n  const references = new Map(loaded);\n  const read = (hash: string) => {\n    const reference = references.get(hash);\n    if (reference === undefined)\n      throw new Error(\"Principal history node reference was not loaded\");\n    return reference;\n  };\n  const increment = (hash: string) => {\n    const reference = read(hash);\n    references.set(\n      hash,\n      reference\n        ? { ...reference, referenceCount: reference.referenceCount + 1 }\n        : {\n            ...scope,\n            hash,\n            referenceCount: 1,\n            managed: false,\n            leftHash: null,\n            rightHash: null,\n          },\n    );\n  };\n  const decrement = (hash: string) => {\n    const reference = read(hash);\n    if (reference?.organizationId === scope.organizationId)\n      references.set(hash, {\n        ...reference,\n        referenceCount: Math.max(reference.referenceCount - 1, 0),\n      });\n  };\n  for (const node of nodes) {\n    const previous = read(node.hash);\n    if (\n      previous?.leftHash !== node.leftHash ||\n      previous.rightHash !== node.rightHash\n    ) {\n      const managed = previous?.managed || !storedNodeHashes.has(node.hash);\n      increment(node.leftHash);\n      increment(node.rightHash);\n      const current = read(node.hash);\n      references.set(node.hash, {\n        ...(current ?? {\n          ...scope,\n          hash: node.hash,\n          referenceCount: previous?.referenceCount ?? 0,\n        }),\n        leftHash: node.leftHash,\n        rightHash: node.rightHash,\n        managed,\n      });\n      for (const hash of [previous?.leftHash, previous?.rightHash])\n        if (hash) decrement(hash);\n    }\n    storedNodeHashes.add(node.hash);\n  }\n  return references;\n}\n\nfunction isSameNodeReference(\n  left: PrincipalHistoryNodeReference,\n  right: PrincipalHistoryNodeReference,\n): boolean {\n  return (\n    left.organizationId === right.organizationId &&\n    left.referenceCount === right.referenceCount &&\n    left.managed === right.managed &&\n    left.leftHash === right.leftHash &&\n    left.rightHash === right.rightHash\n  );\n}\n\n/**\n * Register edges and store proof nodes in the given order, with the same\n * result as recording each node's edges and then upserting it. Reads the\n * touched liveness rows once, replays the bookkeeping, and writes the changed\n * rows and the nodes as multi-row upserts.\n */\nexport async function writePrincipalHistoryNodes(\n  tx: ClientSQLiteTransactionScope,\n  scope: PrincipalHistoryNodeScope,\n  nodes: readonly PrincipalHistoryIndexNode[],\n): Promise<void> {\n  if (nodes.length === 0) return;\n  const loaded = new Map<string, PrincipalHistoryNodeReference | null>();\n  await loadNodeReferences(\n    tx,\n    scope,\n    nodes.flatMap((node) => [node.hash, node.leftHash, node.rightHash]),\n    loaded,\n  );\n  // An edge change releases the stored row's previous children.\n  await loadNodeReferences(\n    tx,\n    scope,\n    nodes.flatMap((node) => {\n      const stored = loaded.get(node.hash);\n      return [stored?.leftHash, stored?.rightHash].filter(\n        (hash): hash is string => Boolean(hash),\n      );\n    }),\n    loaded,\n  );\n  const replayed = replayNodeEdges(\n    scope,\n    nodes,\n    loaded,\n    await loadStoredNodeHashes(\n      tx,\n      scope,\n      nodes.map((node) => node.hash),\n    ),\n  );\n  const changed = [...replayed].flatMap(([hash, reference]) => {\n    const before = loaded.get(hash);\n    return reference && !(before && isSameNodeReference(before, reference))\n      ? [reference]\n      : [];\n  });\n  for (const batch of batches(changed, REFERENCE_WRITE_BATCH_SIZE))\n    await tx\n      .insert(principalHistoryNodeReferences)\n      .values(batch)\n      .onConflictDoUpdate({\n        target: [\n          principalHistoryNodeReferences.scopeId,\n          principalHistoryNodeReferences.hash,\n        ],\n        set: {\n          referenceCount: excludedValue(\n            principalHistoryNodeReferences.referenceCount,\n          ),\n          managed: excludedValue(principalHistoryNodeReferences.managed),\n          leftHash: excludedValue(principalHistoryNodeReferences.leftHash),\n          rightHash: excludedValue(principalHistoryNodeReferences.rightHash),\n        },\n      })\n      .run();\n  const nodeRows = new Map(\n    nodes.map((node) => [\n      node.hash,\n      {\n        ...scope,\n        hash: node.hash,\n        leftHash: node.leftHash,\n        rightHash: node.rightHash,\n      },\n    ]),\n  );\n  for (const batch of batches([...nodeRows.values()], NODE_WRITE_BATCH_SIZE))\n    await tx\n      .insert(principalHistoryNodes)\n      .values(batch)\n      .onConflictDoUpdate({\n        target: [principalHistoryNodes.scopeId, principalHistoryNodes.hash],\n        set: {\n          organizationId: excludedValue(principalHistoryNodes.organizationId),\n          leftHash: excludedValue(principalHistoryNodes.leftHash),\n          rightHash: excludedValue(principalHistoryNodes.rightHash),\n        },\n      })\n      .run();\n}\n\n/** A bounded cascade releases only managed proof nodes with no live incoming edge. */\nexport async function reclaimPrincipalHistoryNodes(\n  tx: ClientSQLiteTransactionScope,\n  scope: PrincipalHistoryNodeScope,\n): Promise<number> {\n  let reclaimed = 0;\n  while (reclaimed < 64) {\n    const obsolete = await tx\n      .select()\n      .from(principalHistoryNodeReferences)\n      .where(\n        and(\n          eq(principalHistoryNodeReferences.scopeId, scope.scopeId),\n          eq(\n            principalHistoryNodeReferences.organizationId,\n            scope.organizationId,\n          ),\n          eq(principalHistoryNodeReferences.managed, true),\n          eq(principalHistoryNodeReferences.referenceCount, 0),\n        ),\n      )\n      .orderBy(asc(principalHistoryNodeReferences.hash))\n      .limit(64 - reclaimed);\n    if (obsolete.length === 0) break;\n    for (const node of obsolete) {\n      await tx\n        .delete(principalHistoryNodes)\n        .where(\n          and(\n            eq(principalHistoryNodes.scopeId, scope.scopeId),\n            eq(principalHistoryNodes.organizationId, scope.organizationId),\n            eq(principalHistoryNodes.hash, node.hash),\n          ),\n        )\n        .run();\n      await tx\n        .delete(principalHistoryNodeReferences)\n        .where(\n          and(\n            eq(principalHistoryNodeReferences.scopeId, scope.scopeId),\n            eq(principalHistoryNodeReferences.hash, node.hash),\n          ),\n        )\n        .run();\n      for (const hash of [node.leftHash, node.rightHash])\n        if (hash) await decrementPrincipalHistoryNodeReference(tx, scope, hash);\n      reclaimed += 1;\n    }\n  }\n  return reclaimed;\n}\n"]}

package/data/persistence/principalHistoryPrefixPersistence.d.ts

@@ -1,29 +0,0 @@
-import { principalHistoryPrefixes } from "../sqlite/principalHistoryEvidenceSchema.js";
-import { type ExecSql } from "../sqlite/sqlSchema.js";
-export type PrincipalHistoryPrefix = typeof principalHistoryPrefixes.$inferSelect;
-export declare function loadPrincipalHistoryPrefix(execSql: ExecSql, scopeId: string): Promise<{
-    scopeId: string;
-    organizationId: string;
-    version: number;
-    headJson: string;
-    currentJson: string;
-    progress: string;
-} | null>;
-/**
- * Preserve identical completed progress; this sink does not authenticate hints.
- * Callers must discard an unreadable prefix or identify it with rejectedPrefix
- * before publishing a repair of the same head and current artifacts.
- */
-export declare function savePrincipalHistoryPrefix(input: {
-    readonly execSql: ExecSql;
-    readonly prefix: PrincipalHistoryPrefix;
-    readonly indexRootHash: string;
-    readonly stillCurrent: () => boolean;
-    readonly rejectedPrefix?: PrincipalHistoryPrefix | null;
-}): Promise<void>;
-/** Invalid hints are disposable, but a losing reader must preserve a newer hint. */
-export declare function discardPrincipalHistoryPrefix(input: {
-    readonly execSql: ExecSql;
-    readonly prefix: PrincipalHistoryPrefix;
-    readonly stillCurrent: () => boolean;
-}): Promise<void>;

package/data/persistence/principalHistoryPrefixPersistence.js

@@ -1,102 +0,0 @@
-import { and, eq } from "drizzle-orm";
-import { assertProjectionVerificationCurrent } from "../keyingProjectionVerification/types.js";
-import { principalHistoryEvidenceTables, principalHistoryPrefixes, } from "../sqlite/principalHistoryEvidenceSchema.js";
-import { principalHistoryStageTables } from "../sqlite/principalHistoryStageSchema.js";
-import { getClientSQLitePersistenceRuntime } from "../sqlite/sqlitePersistenceRuntime.js";
-import { ensureSqlTables } from "../sqlite/sqlSchema.js";
-import { reclaimPrincipalHistoryNodes } from "./principalHistoryNodeRetention.js";
-import { releasePrincipalHistoryRoot, retainPrincipalHistoryRoot, } from "./principalHistoryRootOwnership.js";
-import { reclaimCompletedPrincipalHistoryStages } from "./principalHistoryStageRetention.js";
-import { archivePrincipalHistoryKeyEnvelopes } from "./principalKeyEnvelopeArchivePersistence.js";
-export async function loadPrincipalHistoryPrefix(execSql, scopeId) {
-    await ensureSqlTables(execSql, principalHistoryEvidenceTables);
-    const { db } = getClientSQLitePersistenceRuntime(execSql);
-    const [prefix] = await db
-        .select()
-        .from(principalHistoryPrefixes)
-        .where(eq(principalHistoryPrefixes.scopeId, scopeId))
-        .limit(1);
-    return prefix ?? null;
-}
-/**
- * Preserve identical completed progress; this sink does not authenticate hints.
- * Callers must discard an unreadable prefix or identify it with rejectedPrefix
- * before publishing a repair of the same head and current artifacts.
- */
-export async function savePrincipalHistoryPrefix(input) {
-    const prefix = { ...input.prefix };
-    const indexRootHash = input.indexRootHash;
-    const rejected = input.rejectedPrefix ? { ...input.rejectedPrefix } : null;
-    await ensureSqlTables(input.execSql, [
-        ...principalHistoryEvidenceTables,
-        ...principalHistoryStageTables,
-    ]);
-    const runtime = getClientSQLitePersistenceRuntime(input.execSql);
-    const result = await runtime.guardedTransaction(async (tx) => {
-        const [previous] = await tx
-            .select()
-            .from(principalHistoryPrefixes)
-            .where(eq(principalHistoryPrefixes.scopeId, prefix.scopeId))
-            .limit(1);
-        const replacesRejected = previous &&
-            rejected?.scopeId === previous.scopeId &&
-            rejected.progress === previous.progress;
-        if (previous && previous.version > prefix.version && !replacesRejected)
-            return;
-        if (previous &&
-            previous.version === prefix.version &&
-            previous.organizationId === prefix.organizationId &&
-            previous.headJson === prefix.headJson &&
-            previous.currentJson === prefix.currentJson &&
-            !replacesRejected) {
-            // Resealing an unchanged prefix would invalidate an acknowledgement's
-            // progress CAS even though its authenticated predecessor is unchanged.
-            // Still refresh authenticated root ownership and retention below.
-            // Reuse authenticates this opaque progress; rejected hints are removed
-            // or explicitly replaced before repair can rely on the new prefix.
-            prefix.progress = previous.progress;
-        }
-        if (previous)
-            await archivePrincipalHistoryKeyEnvelopes(tx, previous);
-        await archivePrincipalHistoryKeyEnvelopes(tx, prefix);
-        await tx
-            .insert(principalHistoryPrefixes)
-            .values(prefix)
-            .onConflictDoUpdate({
-            target: principalHistoryPrefixes.scopeId,
-            set: prefix,
-        })
-            .run();
-        await reclaimCompletedPrincipalHistoryStages(tx, prefix);
-        await retainPrincipalHistoryRoot(tx, {
-            id: `prefix:${prefix.scopeId}`,
-            scopeId: prefix.scopeId,
-            organizationId: prefix.organizationId,
-            rootHash: indexRootHash,
-        });
-        await reclaimPrincipalHistoryNodes(tx, prefix);
-    }, input.stillCurrent, { behavior: "immediate" });
-    assertProjectionVerificationCurrent(() => result.committed);
-}
-/** Invalid hints are disposable, but a losing reader must preserve a newer hint. */
-export async function discardPrincipalHistoryPrefix(input) {
-    const prefix = { ...input.prefix };
-    await ensureSqlTables(input.execSql, principalHistoryEvidenceTables);
-    const runtime = getClientSQLitePersistenceRuntime(input.execSql);
-    const result = await runtime.guardedTransaction(async (tx) => {
-        const [current] = await tx
-            .select({ progress: principalHistoryPrefixes.progress })
-            .from(principalHistoryPrefixes)
-            .where(eq(principalHistoryPrefixes.scopeId, prefix.scopeId))
-            .limit(1);
-        if (current?.progress !== prefix.progress)
-            return;
-        await releasePrincipalHistoryRoot(tx, `prefix:${prefix.scopeId}`);
-        await tx
-            .delete(principalHistoryPrefixes)
-            .where(and(eq(principalHistoryPrefixes.scopeId, prefix.scopeId), eq(principalHistoryPrefixes.progress, prefix.progress)))
-            .run();
-    }, input.stillCurrent, { behavior: "immediate" });
-    assertProjectionVerificationCurrent(() => result.committed);
-}
-//# sourceMappingURL=principalHistoryPrefixPersistence.js.map

package/data/persistence/principalHistoryPrefixPersistence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"principalHistoryPrefixPersistence.js","sourceRoot":"","sources":["principalHistoryPrefixPersistence.ts"],"names":[],"mappings":"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","sourcesContent":["import { and, eq } from \"drizzle-orm\";\nimport { assertProjectionVerificationCurrent } from \"../keyingProjectionVerification/types\";\nimport {\n  principalHistoryEvidenceTables,\n  principalHistoryPrefixes,\n} from \"../sqlite/principalHistoryEvidenceSchema\";\nimport { principalHistoryStageTables } from \"../sqlite/principalHistoryStageSchema\";\nimport { getClientSQLitePersistenceRuntime } from \"../sqlite/sqlitePersistenceRuntime\";\nimport { type ExecSql, ensureSqlTables } from \"../sqlite/sqlSchema\";\nimport { reclaimPrincipalHistoryNodes } from \"./principalHistoryNodeRetention\";\nimport {\n  releasePrincipalHistoryRoot,\n  retainPrincipalHistoryRoot,\n} from \"./principalHistoryRootOwnership\";\nimport { reclaimCompletedPrincipalHistoryStages } from \"./principalHistoryStageRetention\";\nimport { archivePrincipalHistoryKeyEnvelopes } from \"./principalKeyEnvelopeArchivePersistence\";\n\nexport type PrincipalHistoryPrefix =\n  typeof principalHistoryPrefixes.$inferSelect;\n\nexport async function loadPrincipalHistoryPrefix(\n  execSql: ExecSql,\n  scopeId: string,\n) {\n  await ensureSqlTables(execSql, principalHistoryEvidenceTables);\n  const { db } = getClientSQLitePersistenceRuntime(execSql);\n  const [prefix] = await db\n    .select()\n    .from(principalHistoryPrefixes)\n    .where(eq(principalHistoryPrefixes.scopeId, scopeId))\n    .limit(1);\n  return prefix ?? null;\n}\n\n/**\n * Preserve identical completed progress; this sink does not authenticate hints.\n * Callers must discard an unreadable prefix or identify it with rejectedPrefix\n * before publishing a repair of the same head and current artifacts.\n */\nexport async function savePrincipalHistoryPrefix(input: {\n  readonly execSql: ExecSql;\n  readonly prefix: PrincipalHistoryPrefix;\n  readonly indexRootHash: string;\n  readonly stillCurrent: () => boolean;\n  readonly rejectedPrefix?: PrincipalHistoryPrefix | null;\n}): Promise<void> {\n  const prefix = { ...input.prefix };\n  const indexRootHash = input.indexRootHash;\n  const rejected = input.rejectedPrefix ? { ...input.rejectedPrefix } : null;\n  await ensureSqlTables(input.execSql, [\n    ...principalHistoryEvidenceTables,\n    ...principalHistoryStageTables,\n  ]);\n  const runtime = getClientSQLitePersistenceRuntime(input.execSql);\n  const result = await runtime.guardedTransaction(\n    async (tx) => {\n      const [previous] = await tx\n        .select()\n        .from(principalHistoryPrefixes)\n        .where(eq(principalHistoryPrefixes.scopeId, prefix.scopeId))\n        .limit(1);\n      const replacesRejected =\n        previous &&\n        rejected?.scopeId === previous.scopeId &&\n        rejected.progress === previous.progress;\n      if (previous && previous.version > prefix.version && !replacesRejected)\n        return;\n      if (\n        previous &&\n        previous.version === prefix.version &&\n        previous.organizationId === prefix.organizationId &&\n        previous.headJson === prefix.headJson &&\n        previous.currentJson === prefix.currentJson &&\n        !replacesRejected\n      ) {\n        // Resealing an unchanged prefix would invalidate an acknowledgement's\n        // progress CAS even though its authenticated predecessor is unchanged.\n        // Still refresh authenticated root ownership and retention below.\n        // Reuse authenticates this opaque progress; rejected hints are removed\n        // or explicitly replaced before repair can rely on the new prefix.\n        prefix.progress = previous.progress;\n      }\n      if (previous) await archivePrincipalHistoryKeyEnvelopes(tx, previous);\n      await archivePrincipalHistoryKeyEnvelopes(tx, prefix);\n      await tx\n        .insert(principalHistoryPrefixes)\n        .values(prefix)\n        .onConflictDoUpdate({\n          target: principalHistoryPrefixes.scopeId,\n          set: prefix,\n        })\n        .run();\n      await reclaimCompletedPrincipalHistoryStages(tx, prefix);\n      await retainPrincipalHistoryRoot(tx, {\n        id: `prefix:${prefix.scopeId}`,\n        scopeId: prefix.scopeId,\n        organizationId: prefix.organizationId,\n        rootHash: indexRootHash,\n      });\n      await reclaimPrincipalHistoryNodes(tx, prefix);\n    },\n    input.stillCurrent,\n    { behavior: \"immediate\" },\n  );\n  assertProjectionVerificationCurrent(() => result.committed);\n}\n\n/** Invalid hints are disposable, but a losing reader must preserve a newer hint. */\nexport async function discardPrincipalHistoryPrefix(input: {\n  readonly execSql: ExecSql;\n  readonly prefix: PrincipalHistoryPrefix;\n  readonly stillCurrent: () => boolean;\n}): Promise<void> {\n  const prefix = { ...input.prefix };\n  await ensureSqlTables(input.execSql, principalHistoryEvidenceTables);\n  const runtime = getClientSQLitePersistenceRuntime(input.execSql);\n  const result = await runtime.guardedTransaction(\n    async (tx) => {\n      const [current] = await tx\n        .select({ progress: principalHistoryPrefixes.progress })\n        .from(principalHistoryPrefixes)\n        .where(eq(principalHistoryPrefixes.scopeId, prefix.scopeId))\n        .limit(1);\n      if (current?.progress !== prefix.progress) return;\n      await releasePrincipalHistoryRoot(tx, `prefix:${prefix.scopeId}`);\n      await tx\n        .delete(principalHistoryPrefixes)\n        .where(\n          and(\n            eq(principalHistoryPrefixes.scopeId, prefix.scopeId),\n            eq(principalHistoryPrefixes.progress, prefix.progress),\n          ),\n        )\n        .run();\n    },\n    input.stillCurrent,\n    { behavior: \"immediate\" },\n  );\n  assertProjectionVerificationCurrent(() => result.committed);\n}\n"]}

package/data/persistence/principalHistoryRootOwnership.js

@@ -1,71 +0,0 @@
-import { and, eq, sql } from "drizzle-orm";
-import { principalHistoryNodeReferences, principalHistoryRootOwners, } from "../sqlite/principalHistoryNodeRetentionSchema.js";
-export async function incrementPrincipalHistoryNodeReference(tx, scope, hash) {
-    await tx
-        .insert(principalHistoryNodeReferences)
-        .values({
-        ...scope,
-        hash,
-        referenceCount: 1,
-        managed: false,
-        leftHash: null,
-        rightHash: null,
-    })
-        .onConflictDoUpdate({
-        target: [
-            principalHistoryNodeReferences.scopeId,
-            principalHistoryNodeReferences.hash,
-        ],
-        set: {
-            referenceCount: sql `${principalHistoryNodeReferences.referenceCount} + 1`,
-        },
-    })
-        .run();
-}
-export async function decrementPrincipalHistoryNodeReference(tx, scope, hash) {
-    await tx
-        .update(principalHistoryNodeReferences)
-        .set({
-        referenceCount: sql `max(${principalHistoryNodeReferences.referenceCount} - 1, 0)`,
-    })
-        .where(and(eq(principalHistoryNodeReferences.scopeId, scope.scopeId), eq(principalHistoryNodeReferences.organizationId, scope.organizationId), eq(principalHistoryNodeReferences.hash, hash)))
-        .run();
-}
-/** Caller commits ownership together with the exact saved progress it describes. */
-export async function retainPrincipalHistoryRoot(tx, input) {
-    const [previous] = await tx
-        .select()
-        .from(principalHistoryRootOwners)
-        .where(eq(principalHistoryRootOwners.id, input.id))
-        .limit(1);
-    if (previous?.scopeId === input.scopeId &&
-        previous.organizationId === input.organizationId &&
-        previous.rootHash === input.rootHash)
-        return;
-    await incrementPrincipalHistoryNodeReference(tx, input, input.rootHash);
-    await tx
-        .insert(principalHistoryRootOwners)
-        .values(input)
-        .onConflictDoUpdate({
-        target: principalHistoryRootOwners.id,
-        set: input,
-    })
-        .run();
-    if (previous)
-        await decrementPrincipalHistoryNodeReference(tx, previous, previous.rootHash);
-}
-export async function releasePrincipalHistoryRoot(tx, id) {
-    const [previous] = await tx
-        .select()
-        .from(principalHistoryRootOwners)
-        .where(eq(principalHistoryRootOwners.id, id))
-        .limit(1);
-    if (!previous)
-        return;
-    await tx
-        .delete(principalHistoryRootOwners)
-        .where(eq(principalHistoryRootOwners.id, id))
-        .run();
-    await decrementPrincipalHistoryNodeReference(tx, previous, previous.rootHash);
-}
-//# sourceMappingURL=principalHistoryRootOwnership.js.map

package/data/persistence/principalHistoryRootOwnership.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"principalHistoryRootOwnership.js","sourceRoot":"","sources":["principalHistoryRootOwnership.ts"],"names":[],"mappings":"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","sourcesContent":["import { and, eq, sql } from \"drizzle-orm\";\nimport {\n  principalHistoryNodeReferences,\n  principalHistoryRootOwners,\n} from \"../sqlite/principalHistoryNodeRetentionSchema\";\nimport type { ClientSQLiteTransactionScope } from \"../sqlite/sqlitePersistenceRuntime\";\n\nexport interface PrincipalHistoryNodeScope {\n  /** Evidence scope hashes include organizationId; one scope belongs to one organization. */\n  readonly scopeId: string;\n  readonly organizationId: string;\n}\n\nexport async function incrementPrincipalHistoryNodeReference(\n  tx: ClientSQLiteTransactionScope,\n  scope: PrincipalHistoryNodeScope,\n  hash: string,\n) {\n  await tx\n    .insert(principalHistoryNodeReferences)\n    .values({\n      ...scope,\n      hash,\n      referenceCount: 1,\n      managed: false,\n      leftHash: null,\n      rightHash: null,\n    })\n    .onConflictDoUpdate({\n      target: [\n        principalHistoryNodeReferences.scopeId,\n        principalHistoryNodeReferences.hash,\n      ],\n      set: {\n        referenceCount: sql`${principalHistoryNodeReferences.referenceCount} + 1`,\n      },\n    })\n    .run();\n}\n\nexport async function decrementPrincipalHistoryNodeReference(\n  tx: ClientSQLiteTransactionScope,\n  scope: PrincipalHistoryNodeScope,\n  hash: string,\n) {\n  await tx\n    .update(principalHistoryNodeReferences)\n    .set({\n      referenceCount: sql`max(${principalHistoryNodeReferences.referenceCount} - 1, 0)`,\n    })\n    .where(\n      and(\n        eq(principalHistoryNodeReferences.scopeId, scope.scopeId),\n        eq(principalHistoryNodeReferences.organizationId, scope.organizationId),\n        eq(principalHistoryNodeReferences.hash, hash),\n      ),\n    )\n    .run();\n}\n\n/** Caller commits ownership together with the exact saved progress it describes. */\nexport async function retainPrincipalHistoryRoot(\n  tx: ClientSQLiteTransactionScope,\n  input: PrincipalHistoryNodeScope & {\n    readonly id: string;\n    readonly rootHash: string;\n  },\n) {\n  const [previous] = await tx\n    .select()\n    .from(principalHistoryRootOwners)\n    .where(eq(principalHistoryRootOwners.id, input.id))\n    .limit(1);\n  if (\n    previous?.scopeId === input.scopeId &&\n    previous.organizationId === input.organizationId &&\n    previous.rootHash === input.rootHash\n  )\n    return;\n  await incrementPrincipalHistoryNodeReference(tx, input, input.rootHash);\n  await tx\n    .insert(principalHistoryRootOwners)\n    .values(input)\n    .onConflictDoUpdate({\n      target: principalHistoryRootOwners.id,\n      set: input,\n    })\n    .run();\n  if (previous)\n    await decrementPrincipalHistoryNodeReference(\n      tx,\n      previous,\n      previous.rootHash,\n    );\n}\n\nexport async function releasePrincipalHistoryRoot(\n  tx: ClientSQLiteTransactionScope,\n  id: string,\n) {\n  const [previous] = await tx\n    .select()\n    .from(principalHistoryRootOwners)\n    .where(eq(principalHistoryRootOwners.id, id))\n    .limit(1);\n  if (!previous) return;\n  await tx\n    .delete(principalHistoryRootOwners)\n    .where(eq(principalHistoryRootOwners.id, id))\n    .run();\n  await decrementPrincipalHistoryNodeReference(tx, previous, previous.rootHash);\n}\n"]}

package/data/persistence/principalHistoryStagePersistence.d.ts

@@ -1,15 +0,0 @@
-import { principalHistoryStages } from "../sqlite/principalHistoryStageSchema.js";
-import { type ExecSql } from "../sqlite/sqlSchema.js";
-import { type PrincipalHistoryEvidencePage } from "./principalHistoryEvidencePersistence.js";
-/** A stage's verification work; its retention hints are written by persistence. */
-export type PrincipalHistoryStage = Omit<typeof principalHistoryStages.$inferSelect, "scopeId" | "touchedAt">;
-export declare function loadPrincipalHistoryStage(execSql: ExecSql, id: string): Promise<PrincipalHistoryStage | null>;
-/** Publish accepted entries and index nodes atomically with authenticated progress. */
-export declare function savePrincipalHistoryStage(input: {
-    readonly execSql: ExecSql;
-    readonly stage: PrincipalHistoryStage;
-    readonly evidence: PrincipalHistoryEvidencePage;
-    readonly previousProgress: string | null;
-    readonly stillCurrent: () => boolean;
-}): Promise<void>;
-export declare function discardPrincipalHistoryStage(execSql: ExecSql, stage: PrincipalHistoryStage, stillCurrent: () => boolean): Promise<void>;

package/data/persistence/principalHistoryStagePersistence.js

@@ -1,96 +0,0 @@
-import { and, eq } from "drizzle-orm";
-import { assertProjectionVerificationCurrent } from "../keyingProjectionVerification/types.js";
-import { principalHistoryEvidenceTables } from "../sqlite/principalHistoryEvidenceSchema.js";
-import { principalHistoryNodeRetentionTables } from "../sqlite/principalHistoryNodeRetentionSchema.js";
-import { principalHistoryStages, principalHistoryStageTables, } from "../sqlite/principalHistoryStageSchema.js";
-import { getClientSQLitePersistenceRuntime } from "../sqlite/sqlitePersistenceRuntime.js";
-import { ensureSqlTables } from "../sqlite/sqlSchema.js";
-import { writePrincipalHistoryEvidencePage, } from "./principalHistoryEvidencePersistence.js";
-import { reclaimIncompletePrincipalHistoryStages } from "./principalHistoryIncompleteRetention.js";
-import { reclaimPrincipalHistoryNodes } from "./principalHistoryNodeRetention.js";
-import { releasePrincipalHistoryRoot, retainPrincipalHistoryRoot, } from "./principalHistoryRootOwnership.js";
-import { reclaimUnpublishedPrincipalHistoryStages } from "./principalHistoryUnpublishedRetention.js";
-const principalHistoryStageColumns = {
-    id: principalHistoryStages.id,
-    organizationId: principalHistoryStages.organizationId,
-    currentJson: principalHistoryStages.currentJson,
-    afterVersion: principalHistoryStages.afterVersion,
-    complete: principalHistoryStages.complete,
-    progress: principalHistoryStages.progress,
-};
-class PrincipalHistoryStageChangedError extends Error {
-    code = "principal_history_stage_changed";
-    constructor() {
-        super("Another operation changed the saved principal history; resume from its current state");
-        this.name = "PrincipalHistoryStageChangedError";
-    }
-}
-export async function loadPrincipalHistoryStage(execSql, id) {
-    await ensureSqlTables(execSql, principalHistoryStageTables);
-    const { db } = getClientSQLitePersistenceRuntime(execSql);
-    const [row] = await db
-        .select(principalHistoryStageColumns)
-        .from(principalHistoryStages)
-        .where(eq(principalHistoryStages.id, id))
-        .limit(1);
-    return row ?? null;
-}
-/** Publish accepted entries and index nodes atomically with authenticated progress. */
-export async function savePrincipalHistoryStage(input) {
-    const evidence = structuredClone(input.evidence);
-    const stage = { ...input.stage, scopeId: evidence.scopeId };
-    await ensureSqlTables(input.execSql, [
-        ...principalHistoryStageTables,
-        ...principalHistoryEvidenceTables,
-    ]);
-    const runtime = getClientSQLitePersistenceRuntime(input.execSql);
-    const saved = await runtime.guardedTransaction(async (tx) => {
-        const [previous] = await tx
-            .select({ progress: principalHistoryStages.progress })
-            .from(principalHistoryStages)
-            .where(eq(principalHistoryStages.id, stage.id))
-            .limit(1);
-        if ((previous?.progress ?? null) !== input.previousProgress)
-            throw new PrincipalHistoryStageChangedError();
-        await writePrincipalHistoryEvidencePage(tx, evidence);
-        const row = { ...stage, touchedAt: Date.now() };
-        await tx
-            .insert(principalHistoryStages)
-            .values(row)
-            .onConflictDoUpdate({ target: principalHistoryStages.id, set: row })
-            .run();
-        await retainPrincipalHistoryRoot(tx, {
-            id: `stage:${stage.id}`,
-            scopeId: evidence.scopeId,
-            organizationId: stage.organizationId,
-            rootHash: evidence.indexRootHash,
-        });
-        await reclaimIncompletePrincipalHistoryStages(tx, stage);
-        await reclaimUnpublishedPrincipalHistoryStages(tx, stage);
-        await reclaimPrincipalHistoryNodes(tx, evidence);
-    }, input.stillCurrent, { behavior: "immediate" });
-    assertProjectionVerificationCurrent(() => saved.committed);
-}
-export async function discardPrincipalHistoryStage(execSql, stage, stillCurrent) {
-    await ensureSqlTables(execSql, [
-        ...principalHistoryStageTables,
-        ...principalHistoryNodeRetentionTables,
-    ]);
-    const runtime = getClientSQLitePersistenceRuntime(execSql);
-    const discarded = await runtime.guardedTransaction(async (db) => {
-        const [current] = await db
-            .select({ progress: principalHistoryStages.progress })
-            .from(principalHistoryStages)
-            .where(eq(principalHistoryStages.id, stage.id))
-            .limit(1);
-        if (current?.progress !== stage.progress)
-            return;
-        await releasePrincipalHistoryRoot(db, `stage:${stage.id}`);
-        await db
-            .delete(principalHistoryStages)
-            .where(and(eq(principalHistoryStages.id, stage.id), eq(principalHistoryStages.progress, stage.progress)))
-            .run();
-    }, stillCurrent, { behavior: "immediate" });
-    assertProjectionVerificationCurrent(() => discarded.committed);
-}
-//# sourceMappingURL=principalHistoryStagePersistence.js.map