@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/core/queue.js

@@ -1,343 +0,0 @@
-import { createHash } from "node:crypto";
-import { FlowError } from "../flow-error.js";
-import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../git/core.js";
-import { listContractIds, readLedger } from "./ledger.js";
-import { deriveContractState } from "./status/lifecycle.js";
-import { commissionTarget } from "./status/drift.js";
-const EMPTY_TREE_HASH = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
-const MISSING_REF_SENTINEL = "0".repeat(40);
-const ISO_UTC_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
-function isPositiveSafeInteger(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
-}
-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) {
-    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,
-            };
-            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);
-        }
-        else {
-            seat = {
-                contract: ledger.contractId,
-                target: derived.ref,
-                seat: null,
-                legacy: true,
-            };
-            diagnostics.push({ kind: "legacy-petition" });
-        }
-        seatsByContract.set(ledger.contractId, seat);
-        diagnosticsByContract.set(ledger.contractId, diagnostics);
-    }
-    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)
-                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);
-            }
-        }
-        seats.sort((a, b) => {
-            const seatA = a.seat ?? Number.POSITIVE_INFINITY;
-            const seatB = b.seat ?? Number.POSITIVE_INFINITY;
-            if (seatA !== seatB)
-                return seatA - seatB;
-            return a.contract.localeCompare(b.contract);
-        });
-        orderedByTarget.set(target, seats);
-    }
-    const targetQueues = [...orderedByTarget.entries()]
-        .sort(([a], [b]) => a.localeCompare(b))
-        .map(([target, ordered]) => ({ target, ordered }));
-    return {
-        targetQueues,
-        seatsByContract,
-        diagnosticsByContract,
-    };
-}
-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);
-}
-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 {
-            seat,
-            position: null,
-            queueLength: 0,
-            queueHead: null,
-            diagnostics,
-        };
-    }
-    const index = targetQueue.ordered.findIndex((entry) => entry.contract === contractId);
-    const position = index < 0 ? null : index + 1;
-    return {
-        seat,
-        position,
-        queueLength: targetQueue.ordered.length,
-        queueHead: targetQueue.ordered[0]?.contract ?? null,
-        diagnostics,
-    };
-}
-export function assertClaimQueueHead(model, contractId) {
-    const membership = queueMembership(model, contractId);
-    if (!membership) {
-        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`);
-    }
-    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}`;
-}
-async function resolveRefHeadRaw(cwd, ref) {
-    const git = createGit(cwd);
-    try {
-        // Raw observed-head read: any existing Git object id, not commit-only.
-        // Non-commit heads are returned so parseAllocatorChain can classify them as corrupt.
-        return (await git.raw(["rev-parse", "--verify", ref])).trim();
-    }
-    catch (error) {
-        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
-            return null;
-        throw wrapGitError(`rev-parse ${ref}`, error, cwd);
-    }
-}
-async function readCommitMessage(cwd, commit) {
-    const git = createGit(cwd);
-    try {
-        return await git.raw(["show", "-s", "--format=%B", commit]);
-    }
-    catch (error) {
-        throw wrapGitError(`show commit message ${commit}`, error, cwd);
-    }
-}
-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) {
-    const git = createGit(cwd);
-    let output;
-    try {
-        output = await git.raw(["rev-list", "--reverse", head]);
-    }
-    catch {
-        return null;
-    }
-    const commits = output
-        .trim()
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean);
-    if (commits.length === 0)
-        return null;
-    const entries = [];
-    let previousSeat = 0;
-    for (const commit of commits) {
-        try {
-            const entry = parseSeatAllocatorMessage(await readCommitMessage(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);
-    let maxSeat = 0;
-    for (const id of contractIds) {
-        const ledger = await readLedger(cwd, id);
-        if (!ledger)
-            continue;
-        for (const entry of ledger.entries) {
-            if (entry.kind !== "petition")
-                continue;
-            if (!isCurrentPetitionData(entry.data))
-                continue;
-            if (entry.data.target !== target)
-                continue;
-            if (entry.data.seat > maxSeat)
-                maxSeat = entry.data.seat;
-        }
-    }
-    return maxSeat;
-}
-async function createSeatCommit(cwd, entry, parentHead) {
-    const git = createGit(cwd);
-    const subject = `keiyaku seat: ${entry.seat}`;
-    const args = ["commit-tree", EMPTY_TREE_HASH];
-    if (parentHead)
-        args.push("-p", parentHead);
-    args.push("-m", subject, "-m", JSON.stringify(entry, null, 2));
-    try {
-        return (await git.raw(args)).trim();
-    }
-    catch (error) {
-        throw wrapGitError(`commit-tree seat ${entry.seat}`, error, cwd);
-    }
-}
-async function casUpdateRef(cwd, ref, newHead, expectedOld) {
-    const git = createGit(cwd);
-    const oldValue = expectedOld ?? MISSING_REF_SENTINEL;
-    try {
-        await git.raw(["update-ref", ref, newHead, oldValue]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function allocateSettlementSeat(cwd, input) {
-    const ref = seatAllocatorRef(input.target);
-    const maxRetries = 3;
-    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
-        const observedHead = await resolveRefHeadRaw(cwd, ref);
-        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 createSeatCommit(cwd, entry, parent);
-        const casOk = await casUpdateRef(cwd, ref, newHead, expectedOld);
-        if (casOk)
-            return { head: newHead, seat };
-    }
-    throw new FlowError("INTERNAL_STATE", `failed to allocate settlement seat for ${input.target}`);
-}

package/build/core/task-contract.js

@@ -1,237 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { assertGitObservation, requireGitRepository } from "../git/branches.js";
-import { withLockHeldTaskBoard } from "./task-git-store.js";
-import { prepareTaskDocumentReplacements, taskRepositoryFromLockedBoard } from "./task-store-repository.js";
-import { containsCommit, createLandingCommit, createTaskBoardCommit, inspectCurrentBranch, publishForwardTaskBoardCommit, readableRefHead, reconcileTaskIndex, refHead, sameTaskSourceBytes, taskContractAtCommit, taskWritesFromSources, updateBranch, updateTargetRef, } from "./task/settlement-git.js";
-import { contractPointerDocument, doneTaskReplacement, reopenedTaskDocument, requireHealthySettlementBoard, requireSettledTask, selectReadyTaskForBind, taskForContract, } from "./task/settlement-policy.js";
-import { stableRepoRoot } from "./worktree-path.js";
-async function clearAttemptedPointer(input) {
-    const current = requireSettledTask(await input.repository.read(), input.task.id);
-    if (current.contractId === input.contractId) {
-        await replaceTaskDocument(input.repository, contractPointerDocument(current, undefined));
-    }
-}
-async function replaceTaskDocument(repository, replacement) {
-    return repository.mutate(() => ({
-        replacements: [replacement],
-        select: (resulting) => requireSettledTask(resulting, replacement.id),
-    }));
-}
-export async function settleTaskBoardForBind(input, deps = {}) {
-    await requireGitRepository(input.cwd, "task bind");
-    return withLockHeldTaskBoard(input.cwd, async (transaction) => {
-        if (transaction.location.mode !== "git") {
-            if (transaction.location.capability === "unavailable") {
-                assertGitObservation({ capability: "unavailable" }, "task bind");
-            }
-            throw new FlowError("NOT_GIT_REPO", "task bind requires Git task storage");
-        }
-        const hubCwd = transaction.location.root;
-        const repository = taskRepositoryFromLockedBoard(transaction);
-        const branch = inspectCurrentBranch(hubCwd);
-        const board = requireHealthySettlementBoard(await repository.read());
-        const selected = input.taskId === undefined
-            ? undefined
-            : selectReadyTaskForBind(board, input.taskId);
-        if (selected) {
-            await replaceTaskDocument(repository, contractPointerDocument(selected, input.contractId));
-        }
-        const firstCommit = createTaskBoardCommit({
-            cwd: hubCwd,
-            gitDir: transaction.location.gitDir,
-            root: transaction.location.root,
-            parent: branch.head,
-            sources: transaction.sources,
-            subject: selected
-                ? `Bind task ${selected.id} to contract ${input.contractId}`
-                : `Flush task board for contract ${input.contractId}`,
-        });
-        try {
-            await updateBranch({ cwd: hubCwd, ref: branch.ref, next: firstCommit, expected: branch.head }, deps);
-        }
-        catch (error) {
-            if (selected) {
-                await clearAttemptedPointer({ repository, task: selected, contractId: input.contractId });
-                const concurrentHead = refHead(hubCwd, branch.ref);
-                if (taskContractAtCommit(hubCwd, concurrentHead, selected.id) === input.contractId) {
-                    await publishForwardTaskBoardCommit({
-                        cwd: hubCwd,
-                        ref: branch.ref,
-                        gitDir: transaction.location.gitDir,
-                        root: transaction.location.root,
-                        sources: transaction.sources,
-                        subject: `Clear failed contract ${input.contractId} from task ${selected.id}`,
-                    }, deps);
-                }
-            }
-            throw error;
-        }
-        try {
-            reconcileTaskIndex(hubCwd, firstCommit);
-        }
-        catch (indexError) {
-            if (selected) {
-                await clearAttemptedPointer({ repository, task: selected, contractId: input.contractId });
-                await publishForwardTaskBoardCommit({
-                    cwd: hubCwd,
-                    ref: branch.ref,
-                    gitDir: transaction.location.gitDir,
-                    root: transaction.location.root,
-                    sources: transaction.sources,
-                    subject: `Clear failed contract ${input.contractId} from task ${selected.id}`,
-                }, deps);
-            }
-            throw indexError;
-        }
-        try {
-            const ledger = await input.publishLedger(firstCommit);
-            return {
-                boardCommit: firstCommit,
-                ledger,
-                ...(selected ? { task: requireSettledTask(await repository.read(), selected.id) } : {}),
-            };
-        }
-        catch (publishError) {
-            if (!selected)
-                throw publishError;
-            await clearAttemptedPointer({ repository, task: selected, contractId: input.contractId });
-            await publishForwardTaskBoardCommit({
-                cwd: hubCwd,
-                ref: branch.ref,
-                gitDir: transaction.location.gitDir,
-                root: transaction.location.root,
-                sources: transaction.sources,
-                subject: `Clear failed contract ${input.contractId} from task ${selected.id}`,
-            }, deps);
-            throw publishError;
-        }
-    });
-}
-export async function reconcileTaskForfeit(input) {
-    await requireGitRepository(input.cwd, "task forfeit");
-    const hubRoot = await stableRepoRoot(input.cwd);
-    return withLockHeldTaskBoard(hubRoot, async (transaction) => {
-        if (transaction.location.mode !== "git") {
-            if (transaction.location.capability === "unavailable") {
-                assertGitObservation({ capability: "unavailable" }, "task forfeit");
-            }
-            throw new FlowError("NOT_GIT_REPO", "task forfeit requires Git task storage");
-        }
-        const repository = taskRepositoryFromLockedBoard(transaction);
-        const matched = taskForContract(await repository.read(), input.contractId);
-        const ledger = await input.publishLedger();
-        if (!matched)
-            return { ledger };
-        const task = await replaceTaskDocument(repository, reopenedTaskDocument(matched));
-        return {
-            ledger,
-            task,
-        };
-    });
-}
-/**
- * Claim owns the sole task-board settlement after target CAS. Contract branch
- * task trees are fossils: the candidate is the code-only three-way merge plus
- * one complete snapshot of the common hub board held under its repository lock.
- */
-export async function settleTaskBoardForLanding(input) {
-    await requireGitRepository(input.cwd, "task landing");
-    const hubRoot = await stableRepoRoot(input.cwd);
-    let lastTargetHead = input.targetHead;
-    let lastPublishError;
-    let acceptedMovement;
-    for (let attempt = 0; attempt < 4; attempt += 1) {
-        const result = await withLockHeldTaskBoard(hubRoot, async (transaction) => {
-            if (transaction.location.mode !== "git") {
-                if (transaction.location.capability === "unavailable") {
-                    assertGitObservation({ capability: "unavailable" }, "task landing");
-                }
-                throw new FlowError("NOT_GIT_REPO", "task landing requires Git task storage");
-            }
-            // Each attempt reads fresh target and board facts while holding the
-            // common task lock. A losing CAS exits before the next attempt.
-            const targetHead = refHead(input.cwd, input.targetRef);
-            lastTargetHead = targetHead;
-            const repository = taskRepositoryFromLockedBoard(transaction);
-            const board = requireHealthySettlementBoard(await repository.read());
-            const replacement = doneTaskReplacement(board, input.contractId);
-            const prepared = replacement
-                ? prepareTaskDocumentReplacements(transaction.sources, [replacement])
-                : { sources: transaction.sources, board };
-            const finalSources = prepared.sources;
-            requireHealthySettlementBoard(prepared.board);
-            let mergeCommit = targetHead;
-            let movement = acceptedMovement?.mergeCommit === targetHead ? acceptedMovement : undefined;
-            if (!containsCommit(input.cwd, input.deliveryHead, targetHead)) {
-                mergeCommit = createLandingCommit({
-                    cwd: input.cwd,
-                    gitDir: transaction.location.gitDir,
-                    root: transaction.location.root,
-                    base: input.baseCommit,
-                    target: targetHead,
-                    delivery: input.deliveryHead,
-                    sources: finalSources,
-                    contractId: input.contractId,
-                    targetBranch: input.targetBranch,
-                });
-                await input.beforeCas?.(mergeCommit, targetHead);
-                try {
-                    updateTargetRef(input.cwd, input.targetRef, mergeCommit, targetHead);
-                    movement = { mergeCommit, oldHead: targetHead };
-                    acceptedMovement = movement;
-                }
-                catch {
-                    const current = readableRefHead(input.cwd, input.targetRef);
-                    if (!current || !containsCommit(input.cwd, input.deliveryHead, current)) {
-                        return { kind: "retry" };
-                    }
-                    mergeCommit = current;
-                    movement = acceptedMovement?.mergeCommit === mergeCommit ? acceptedMovement : undefined;
-                }
-            }
-            const warnings = [];
-            if (!sameTaskSourceBytes(transaction.location.root, transaction.sources, finalSources)) {
-                await transaction.replace(taskWritesFromSources(finalSources));
-            }
-            try {
-                reconcileTaskIndex(transaction.location.root, mergeCommit);
-            }
-            catch (error) {
-                warnings.push(`Accepted landing ${mergeCommit}, but task index reconciliation failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-            try {
-                await input.publishLedger?.(mergeCommit);
-            }
-            catch (error) {
-                lastPublishError = error;
-                return { kind: "retry" };
-            }
-            const reconcileWarnings = movement
-                ? await input.afterCas?.(mergeCommit, movement.oldHead)
-                : undefined;
-            warnings.push(...(reconcileWarnings ?? []));
-            return {
-                kind: movement ? "accepted" : "idempotent",
-                mergeCommit,
-                ...(movement ? { oldHead: movement.oldHead } : {}),
-                ...(warnings.length > 0 ? { warnings } : {}),
-            };
-        });
-        if (result.kind === "retry")
-            continue;
-        if (result.kind === "idempotent") {
-            return {
-                mergeCommit: result.mergeCommit,
-                ...(result.warnings ? { warnings: result.warnings } : {}),
-            };
-        }
-        return {
-            mergeCommit: result.mergeCommit,
-            oldHead: result.oldHead,
-            ...(result.warnings ? { warnings: result.warnings } : {}),
-        };
-    }
-    if (lastPublishError !== undefined)
-        throw lastPublishError;
-    throw new FlowError("CONCURRENT_MODIFICATION", `target branch kept moving while claiming ${input.contractId}; last observed ${lastTargetHead}`);
-}

package/build/core/task.js

@@ -1,4 +0,0 @@
-export { parseTaskDocument, serializeTaskDocument, } from "./task/document.js";
-export { resolveTaskReadId, } from "./task/board.js";
-export { buildTaskBoard } from "./task/source-board.js";
-export { readTaskBoard, createTask, updateTask, startTask, stopTask, doneTask, dropTask, selectSoleInProgress, rollbackOrphanTaskPointers, } from "./task/commands.js";