@astrosheep/keiyaku 2.9.9 → 2.9.10

package/build/core/settlement/queue-read-model.js

@@ -1,126 +1,103 @@
-import { listContractIds, readLedger } from "../ledger.js";
-import { deriveContractState } from "../status/lifecycle.js";
-import { commissionTarget } from "../status/drift.js";
-export function isCurrentPetitionData(data) {
-    return "target" in data && "seat" in data;
-}
-function latestPetition(entries) {
-    for (let index = entries.length - 1; index >= 0; index -= 1) {
-        const entry = entries[index];
-        if (entry.kind === "petition")
-            return entry;
-    }
-    return undefined;
-}
-export function deriveQueueReadModel(ledgers) {
+import { lookupCurrentContract, readRepositoryLifecycle, } from "../repository-ledger/read-model.js";
+export function deriveQueueReadModel(read) {
     const seatsByContract = new Map();
     const diagnosticsByContract = new Map();
-    const orderedByTarget = new Map();
-    for (const ledger of ledgers) {
-        if (deriveContractState(ledger.entries).state !== "petitioned")
-            continue;
-        const petition = latestPetition(ledger.entries);
-        if (!petition)
-            continue;
-        const derived = commissionTarget(ledger.entries);
-        if (!derived)
-            continue;
-        const diagnostics = [];
-        let seat;
-        if (isCurrentPetitionData(petition.data)) {
-            seat = {
-                contract: ledger.contractId,
-                target: petition.data.target,
-                seat: petition.data.seat,
-                legacy: false,
+    const candidatesByTarget = new Map();
+    const occupancyByTarget = new Map();
+    for (const contract of read.isolatedContracts) {
+        diagnosticsByContract.set(contract, [{
+                kind: "lifecycle-disease",
+                status: "isolated",
+                diagnostics: read.diagnostics.filter((diagnostic) => diagnostic.contract === contract),
+            }]);
+    }
+    for (const model of read.contracts) {
+        // Every accepted petition occupies its seat, even if a later transition
+        // diseased the contract and removed it from settlement ordering.
+        for (const { objectId, entry } of model.history) {
+            if (entry.kind !== "petition")
+                continue;
+            const occupancy = {
+                contract: model.contract,
+                target: entry.data.target,
+                seat: entry.data.seat,
+                objectId,
             };
-            if (petition.data.target !== derived.ref) {
-                diagnostics.push({
-                    kind: "target-mismatch",
-                    petitioned: petition.data.target,
-                    derived: derived.ref,
-                });
-            }
-            const bucket = orderedByTarget.get(petition.data.target) ?? [];
-            bucket.push(seat);
-            orderedByTarget.set(petition.data.target, bucket);
+            const occupancies = occupancyByTarget.get(occupancy.target) ?? [];
+            occupancies.push(occupancy);
+            occupancyByTarget.set(occupancy.target, occupancies);
         }
-        else {
-            seat = {
-                contract: ledger.contractId,
-                target: derived.ref,
-                seat: null,
-                legacy: true,
-            };
-            diagnostics.push({ kind: "legacy-petition" });
+        // A diseased contract remains visible to status and occupies its persisted
+        // seat, but cannot participate in settlement ordering.
+        const outcome = lookupCurrentContract(read, model.contract);
+        if (outcome.status === "diseased") {
+            diagnosticsByContract.set(model.contract, [{
+                    kind: "lifecycle-disease",
+                    status: "diseased",
+                    diagnostics: outcome.diagnostics,
+                }]);
+            continue;
         }
-        seatsByContract.set(ledger.contractId, seat);
-        diagnosticsByContract.set(ledger.contractId, diagnostics);
+        if (outcome.status !== "healthy")
+            continue;
+        if (model.phase !== "awaiting-verdict" && model.phase !== "approved")
+            continue;
+        if (model.petition.state === "none")
+            continue;
+        const seat = {
+            contract: model.contract,
+            target: model.petition.target,
+            seat: model.petition.seat,
+        };
+        const candidates = candidatesByTarget.get(seat.target) ?? [];
+        candidates.push({ seat, petitionObjectId: model.petition.objectId });
+        candidatesByTarget.set(seat.target, candidates);
+        seatsByContract.set(model.contract, seat);
+        diagnosticsByContract.set(model.contract, []);
     }
-    for (const [target, seats] of orderedByTarget) {
-        const bySeat = new Map();
-        for (const seat of seats) {
-            if (seat.seat === null)
-                continue;
-            const group = bySeat.get(seat.seat) ?? [];
-            group.push(seat);
-            bySeat.set(seat.seat, group);
-        }
-        for (const [seatNumber, group] of bySeat) {
-            if (group.length < 2)
+    const orderedByTarget = new Map();
+    for (const [target, candidates] of candidatesByTarget) {
+        for (const candidate of candidates) {
+            const collisions = (occupancyByTarget.get(target) ?? [])
+                .filter((occupancy) => occupancy.seat === candidate.seat.seat && occupancy.objectId !== candidate.petitionObjectId)
+                .sort((left, right) => left.contract.localeCompare(right.contract) || left.objectId.localeCompare(right.objectId));
+            if (collisions.length === 0)
                 continue;
-            const sorted = [...group].sort((a, b) => a.contract.localeCompare(b.contract));
-            for (const member of sorted) {
-                const others = sorted.filter((other) => other.contract !== member.contract);
-                const existing = diagnosticsByContract.get(member.contract) ?? [];
-                for (const other of others) {
-                    existing.push({ kind: "duplicate-seat", seat: seatNumber, with: other.contract });
-                }
-                diagnosticsByContract.set(member.contract, existing);
+            const diagnostics = diagnosticsByContract.get(candidate.seat.contract);
+            for (const collision of collisions) {
+                diagnostics.push({ kind: "duplicate-seat", seat: candidate.seat.seat, with: collision.contract });
             }
         }
-        seats.sort((a, b) => {
-            const seatA = a.seat ?? Number.POSITIVE_INFINITY;
-            const seatB = b.seat ?? Number.POSITIVE_INFINITY;
-            if (seatA !== seatB)
-                return seatA - seatB;
+        // A duplicated persisted seat is a resource collision, not a deterministic
+        // tie-break. Keep the affected petitions visible with diagnostics, but do
+        // not let either one participate in settlement ordering.
+        const ordered = candidates.map((candidate) => candidate.seat).filter((candidate) => !diagnosticsByContract.get(candidate.contract)?.some((diagnostic) => diagnostic.kind === "duplicate-seat"));
+        ordered.sort((a, b) => {
+            if (a.seat !== b.seat)
+                return a.seat - b.seat;
             return a.contract.localeCompare(b.contract);
         });
-        orderedByTarget.set(target, seats);
+        orderedByTarget.set(target, ordered);
     }
     const targetQueues = [...orderedByTarget.entries()]
         .sort(([a], [b]) => a.localeCompare(b))
         .map(([target, ordered]) => ({ target, ordered }));
     return {
+        observedLedgerHead: read.observedLedgerHead,
         targetQueues,
         seatsByContract,
         diagnosticsByContract,
+        unattributedDiagnostics: read.diagnostics.filter((diagnostic) => diagnostic.contract === undefined),
     };
 }
 export async function readQueueReadModel(cwd) {
-    const contractIds = await listContractIds(cwd);
-    const ledgers = [];
-    for (const id of contractIds) {
-        const ledger = await readLedger(cwd, id);
-        if (ledger)
-            ledgers.push(ledger);
-    }
-    return deriveQueueReadModel(ledgers);
+    return deriveQueueReadModel(await readRepositoryLifecycle(cwd));
 }
 export function queueMembership(model, contractId) {
     const seat = model.seatsByContract.get(contractId);
     if (!seat)
         return undefined;
     const diagnostics = model.diagnosticsByContract.get(contractId) ?? [];
-    if (seat.legacy) {
-        return {
-            seat,
-            position: null,
-            queueLength: 0,
-            queueHead: null,
-            diagnostics,
-        };
-    }
     const targetQueue = model.targetQueues.find((queue) => queue.target === seat.target);
     if (!targetQueue) {
         return {

package/build/core/settlement/queue-seat-allocation.js

@@ -1,103 +1,51 @@
-import { createHash } from "node:crypto";
 import { FlowError } from "../../flow-error.js";
-import { listContractIds, readLedger } from "../ledger.js";
-import { casUpdateRefLog, createRefLogCommit, listRefLogCommits, readRefLogCommitMessage, resolveRefLogHead, } from "../ref-log.js";
-import { isCurrentPetitionData, queueMembership, } from "./queue-read-model.js";
-const ISO_UTC_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+import { readRepositoryLifecycle } from "../repository-ledger/read-model.js";
+import { queueMembership, } from "./queue-read-model.js";
 function isPositiveSafeInteger(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
 }
 export function assertClaimQueueHead(model, contractId) {
+    const lifecycleDisease = model.diagnosticsByContract.get(contractId)?.find((diagnostic) => diagnostic.kind === "lifecycle-disease");
+    if (lifecycleDisease?.kind === "lifecycle-disease") {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is unavailable because its repository ledger history is ${lifecycleDisease.status}`, {
+            facts: {
+                kind: "repository_lifecycle_disease",
+                contractId,
+                status: lifecycleDisease.status,
+                diagnostics: lifecycleDisease.diagnostics.map((diagnostic) => ({ ...diagnostic })),
+            },
+        });
+    }
     const membership = queueMembership(model, contractId);
     if (!membership) {
+        if (model.unattributedDiagnostics.length > 0) {
+            throw new FlowError("INTERNAL_STATE", `contract ${contractId} queue membership is indeterminate because the repository ledger is diseased`, {
+                facts: {
+                    kind: "repository_lifecycle_disease",
+                    contractId,
+                    status: "indeterminate",
+                    diagnostics: model.unattributedDiagnostics.map((diagnostic) => ({ ...diagnostic })),
+                },
+            });
+        }
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} is not queue head; position=not queued`);
     }
-    if (membership.seat.legacy) {
-        throw new FlowError("QUEUE_LEGACY_PETITION", `contract ${contractId} petitioned before seat law took effect; reject its petition and petition again`);
-    }
-    const mismatch = membership.diagnostics.find((diagnostic) => diagnostic.kind === "target-mismatch");
-    if (mismatch && mismatch.kind === "target-mismatch") {
-        throw new FlowError("QUEUE_TARGET_MISMATCH", `contract ${contractId} petition target ${mismatch.petitioned} disagrees with derived target ${mismatch.derived}; reject its petition and petition again`);
+    const collision = membership.diagnostics.find((diagnostic) => diagnostic.kind === "duplicate-seat");
+    if (collision && collision.kind === "duplicate-seat") {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} has duplicate settlement seat ${collision.seat} with ${collision.with}; reject its petition and petition again`);
     }
     if (membership.position !== 1) {
         throw new FlowError("INTERNAL_STATE", `contract ${contractId} is not queue head; position=${membership.position ?? "not queued"}`);
     }
     return membership;
 }
-export function seatAllocatorRef(target) {
-    const digest = createHash("sha256").update(target, "utf8").digest("hex");
-    return `refs/keiyaku/seat/${digest}`;
-}
-function parseSeatAllocatorMessage(message, expectedTarget) {
-    const normalized = message.replace(/\r\n/g, "\n");
-    const separatorIndex = normalized.indexOf("\n\n");
-    if (separatorIndex < 0)
-        throw new Error("missing blank line");
-    const subject = normalized.slice(0, separatorIndex).trim();
-    const body = normalized.slice(separatorIndex + 2).trim();
-    const parsed = JSON.parse(body);
-    const keys = Object.keys(parsed).sort();
-    if (keys.join(",") !== "actor,at,seat,target,v")
-        throw new Error("unexpected fields");
-    if (parsed.v !== 1)
-        throw new Error("bad version");
-    if (typeof parsed.target !== "string" || parsed.target !== expectedTarget)
-        throw new Error("target mismatch");
-    if (!isPositiveSafeInteger(parsed.seat))
-        throw new Error("bad seat");
-    if (typeof parsed.at !== "string" || !ISO_UTC_RE.test(parsed.at))
-        throw new Error("bad at");
-    if (typeof parsed.actor !== "string" || parsed.actor.trim().length === 0)
-        throw new Error("bad actor");
-    if (subject !== `keiyaku seat: ${parsed.seat}`)
-        throw new Error("bad subject");
-    return {
-        v: 1,
-        target: parsed.target,
-        seat: parsed.seat,
-        at: parsed.at,
-        actor: parsed.actor,
-    };
-}
-async function parseAllocatorChain(cwd, head, expectedTarget) {
-    // Intentional degrade: any rev-list or parse failure treats the chain as corrupt.
-    let commits;
-    try {
-        commits = await listRefLogCommits(cwd, head);
-    }
-    catch {
-        return null;
-    }
-    if (commits.length === 0)
-        return null;
-    const entries = [];
-    let previousSeat = 0;
-    for (const commit of commits) {
-        try {
-            const entry = parseSeatAllocatorMessage(await readRefLogCommitMessage(cwd, commit), expectedTarget);
-            if (entry.seat <= previousSeat)
-                return null;
-            previousSeat = entry.seat;
-            entries.push(entry);
-        }
-        catch {
-            return null;
-        }
-    }
-    return { entries, lastSeat: previousSeat };
-}
 async function ledgerSeatFloor(cwd, target) {
-    const contractIds = await listContractIds(cwd);
+    const lifecycle = await readRepositoryLifecycle(cwd);
     let maxSeat = 0;
-    for (const id of contractIds) {
-        const ledger = await readLedger(cwd, id);
-        if (!ledger)
-            continue;
-        for (const entry of ledger.entries) {
+    for (const model of lifecycle.contracts) {
+        for (const { entry } of model.history) {
             if (entry.kind !== "petition")
                 continue;
-            if (!isCurrentPetitionData(entry.data))
-                continue;
             if (entry.data.target !== target)
                 continue;
             if (entry.data.seat > maxSeat)
@@ -107,50 +55,11 @@ async function ledgerSeatFloor(cwd, target) {
     return maxSeat;
 }
 export async function allocateSettlementSeat(cwd, input) {
-    const ref = seatAllocatorRef(input.target);
-    const maxRetries = 3;
-    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
-        // Raw observed-head read: any object id, not commit-only.
-        // Non-commit heads are returned so parseAllocatorChain can classify them as corrupt.
-        const observedHead = await resolveRefLogHead(cwd, ref, { peel: "object" });
-        const floor = await ledgerSeatFloor(cwd, input.target);
-        const parsed = observedHead ? await parseAllocatorChain(cwd, observedHead, input.target) : null;
-        const healthy = parsed !== null && parsed.lastSeat >= floor;
-        let seat;
-        let parent;
-        let expectedOld;
-        if (healthy && parsed) {
-            seat = parsed.lastSeat + 1;
-            parent = observedHead;
-            expectedOld = observedHead;
-        }
-        else {
-            // Missing, parse failure, target mismatch, non-monotonic, or stale-behind-ledger:
-            // mint a detached no-parent root at floor+1. Leave the bad chain for Git GC.
-            seat = floor + 1;
-            parent = null;
-            expectedOld = observedHead;
-        }
-        if (!isPositiveSafeInteger(seat)) {
-            throw new FlowError("INTERNAL_STATE", `settlement seats exhausted for ${input.target}`);
-        }
-        const entry = {
-            v: 1,
-            target: input.target,
-            seat,
-            at: input.at,
-            actor: input.actor,
-        };
-        const newHead = await createRefLogCommit(cwd, {
-            subject: `keiyaku seat: ${entry.seat}`,
-            body: JSON.stringify(entry, null, 2),
-            parentHead: parent,
-            errorLabel: `seat ${entry.seat}`,
-        });
-        // Intentional degrade: CAS failure returns false; bounded retry re-reads head.
-        const casOk = await casUpdateRefLog(cwd, ref, newHead, expectedOld);
-        if (casOk)
-            return { head: newHead, seat };
+    // The candidate is derived from one typed ledger observation. The later
+    // repository-ledger transaction owns the only authoritative CAS and commit.
+    const seat = (await ledgerSeatFloor(cwd, input.target)) + 1;
+    if (!isPositiveSafeInteger(seat)) {
+        throw new FlowError("INTERNAL_STATE", `settlement seats exhausted for ${input.target}`);
     }
-    throw new FlowError("INTERNAL_STATE", `failed to allocate settlement seat for ${input.target}`);
+    return { seat };
 }

package/build/core/settlement/queue.js

@@ -3,4 +3,4 @@
  * Implementation lives in sibling files; this module preserves the historical import path.
  */
 export { deriveQueueReadModel, queueMembership, readQueueReadModel, } from "./queue-read-model.js";
-export { allocateSettlementSeat, assertClaimQueueHead, seatAllocatorRef, } from "./queue-seat-allocation.js";
+export { allocateSettlementSeat, assertClaimQueueHead, } from "./queue-seat-allocation.js";