@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/repository-ledger/fold-repository.js

@@ -1,374 +0,0 @@
-import { isLifecycleCausalAncestor, isTypedLedgerAncestor, ledgerTopologyParents, } from "./traversal.js";
-import { applyFoldEntry, } from "./fold.js";
-function ancestorSet(ledger, start) {
-    const ancestors = new Set();
-    const pending = [start];
-    while (pending.length > 0) {
-        const objectId = pending.pop();
-        if (ancestors.has(objectId))
-            continue;
-        ancestors.add(objectId);
-        const node = ledger.nodes.get(objectId);
-        if (node)
-            pending.push(...ledgerTopologyParents(node));
-    }
-    return ancestors;
-}
-function typedRoots(ledger, start) {
-    const roots = new Set();
-    for (const objectId of ancestorSet(ledger, start)) {
-        const node = ledger.nodes.get(objectId);
-        if (node && node.type !== "lifecycle" && ledgerTopologyParents(node).length === 0)
-            roots.add(objectId);
-    }
-    return roots;
-}
-function lifecycleContracts(ledger, objectIds) {
-    const contracts = new Set();
-    for (const objectId of objectIds) {
-        const node = ledger.nodes.get(objectId);
-        if (node?.type === "transaction")
-            contracts.add(node.contract);
-    }
-    return contracts;
-}
-function analyzeJoinBoundaries(ledger, diseases) {
-    const blocked = new Set();
-    const collisionContracts = new Set();
-    const invalidJoinScopes = new Map();
-    const closureDiseaseIds = new Set(ledger.diseases.map((disease) => disease.objectId));
-    const closureDiseasesByObject = new Map();
-    for (const disease of ledger.diseases) {
-        const rows = closureDiseasesByObject.get(disease.objectId) ?? [];
-        rows.push(disease);
-        closureDiseasesByObject.set(disease.objectId, rows);
-    }
-    for (const objectId of ledger.order) {
-        const node = ledger.nodes.get(objectId);
-        if (!node || (node.type !== "join" && !(node.type === "disease" && node.boundary === "join")))
-            continue;
-        if (node.ledgerParents.length !== 2) {
-            invalidJoinScopes.set(objectId, { kind: "repository" });
-            diseases.push({ objectId, code: "invalid-join", detail: "diseased join does not expose exactly two ledger parents" });
-            continue;
-        }
-        const left = ancestorSet(ledger, node.ledgerParents[0]);
-        const right = ancestorSet(ledger, node.ledgerParents[1]);
-        const common = new Set([...left].filter((candidate) => right.has(candidate)));
-        const leftOnly = new Set([...left].filter((candidate) => !common.has(candidate)));
-        const rightOnly = new Set([...right].filter((candidate) => !common.has(candidate)));
-        const leftContracts = lifecycleContracts(ledger, leftOnly);
-        const rightContracts = lifecycleContracts(ledger, rightOnly);
-        const collisions = [...leftContracts].filter((contract) => rightContracts.has(contract));
-        const leftRoots = typedRoots(ledger, node.ledgerParents[0]);
-        const rightRoots = typedRoots(ledger, node.ledgerParents[1]);
-        const badRoot = leftRoots.size !== 1 || rightRoots.size !== 1 || [...leftRoots][0] !== [...rightRoots][0];
-        const inheritedContractDisease = new Set();
-        let inheritedRepositoryDisease = false;
-        for (const candidate of [...left, ...right]) {
-            const scope = invalidJoinScopes.get(candidate);
-            if (scope?.kind === "repository")
-                inheritedRepositoryDisease = true;
-            if (scope?.kind === "contracts") {
-                for (const contract of scope.contracts)
-                    inheritedContractDisease.add(contract);
-            }
-        }
-        const attributedClosureDisease = new Set();
-        let unattributedClosureDisease = false;
-        for (const candidate of [...left, ...right]) {
-            const candidateNode = ledger.nodes.get(candidate);
-            if (candidateNode === undefined) {
-                unattributedClosureDisease = true;
-                continue;
-            }
-            if (candidateNode.type === "disease") {
-                if (candidateNode.contract === undefined)
-                    unattributedClosureDisease = true;
-                else
-                    attributedClosureDisease.add(candidateNode.contract);
-            }
-            for (const disease of closureDiseasesByObject.get(candidate) ?? []) {
-                if (disease.contract === undefined)
-                    unattributedClosureDisease = true;
-                else
-                    attributedClosureDisease.add(disease.contract);
-            }
-        }
-        const closureDisease = [...left, ...right].some((candidate) => {
-            const candidateNode = ledger.nodes.get(candidate);
-            return candidateNode === undefined || candidateNode.type === "disease" || closureDiseaseIds.has(candidate);
-        });
-        const inheritedDisease = inheritedRepositoryDisease || inheritedContractDisease.size > 0;
-        const structuralInvalid = node.type === "disease" || badRoot || inheritedDisease || closureDisease;
-        if (structuralInvalid) {
-            const repositoryScope = node.type === "disease" || badRoot || inheritedRepositoryDisease || unattributedClosureDisease;
-            if (repositoryScope) {
-                invalidJoinScopes.set(objectId, { kind: "repository" });
-                for (const candidate of [...leftOnly, ...rightOnly])
-                    blocked.add(candidate);
-            }
-            else {
-                invalidJoinScopes.set(objectId, {
-                    kind: "contracts",
-                    contracts: new Set([...inheritedContractDisease, ...attributedClosureDisease]),
-                });
-            }
-            if (badRoot) {
-                diseases.push({ objectId, code: "join-root-divergence", detail: "join parents do not share exactly one typed root" });
-            }
-            else {
-                diseases.push({ objectId, code: "invalid-join", detail: "join typed closure is diseased and selects neither parent side" });
-            }
-        }
-        for (const contract of collisions) {
-            collisionContracts.add(contract);
-            diseases.push({
-                objectId,
-                code: "same-contract-divergence",
-                contract,
-                detail: "join parents contain incomparable lifecycle histories for the same contract",
-            });
-        }
-    }
-    return { blocked, collisionContracts };
-}
-function afterCycleContracts(contracts) {
-    let nextIndex = 0;
-    const indices = new Map();
-    const lowlinks = new Map();
-    const stack = [];
-    const onStack = new Set();
-    const cycles = new Set();
-    const visit = (contract) => {
-        const index = nextIndex++;
-        indices.set(contract, index);
-        lowlinks.set(contract, index);
-        stack.push(contract);
-        onStack.add(contract);
-        const dependencies = contracts.get(contract)?.bind.data.after ?? [];
-        for (const dependency of dependencies) {
-            if (!contracts.has(dependency))
-                continue;
-            if (!indices.has(dependency)) {
-                visit(dependency);
-                lowlinks.set(contract, Math.min(lowlinks.get(contract), lowlinks.get(dependency)));
-            }
-            else if (onStack.has(dependency)) {
-                lowlinks.set(contract, Math.min(lowlinks.get(contract), indices.get(dependency)));
-            }
-        }
-        if (lowlinks.get(contract) !== indices.get(contract))
-            return;
-        const component = [];
-        while (stack.length > 0) {
-            const member = stack.pop();
-            onStack.delete(member);
-            component.push(member);
-            if (member === contract)
-                break;
-        }
-        const selfCycle = component.length === 1 &&
-            (contracts.get(component[0])?.bind.data.after ?? []).includes(component[0]);
-        if (component.length > 1 || selfCycle) {
-            for (const member of component)
-                cycles.add(member);
-        }
-    };
-    for (const contract of contracts.keys()) {
-        if (!indices.has(contract))
-            visit(contract);
-    }
-    return cycles;
-}
-function validateAfterPrerequisites(ledger, contracts, isolatedContracts, diseases) {
-    const containingTransactions = new Map();
-    for (const node of ledger.nodes.values()) {
-        if (node.type !== "transaction")
-            continue;
-        for (const entryObjectId of node.entryObjectIds)
-            containingTransactions.set(entryObjectId, node.objectId);
-    }
-    const cycles = afterCycleContracts(contracts);
-    for (const contract of cycles) {
-        const state = contracts.get(contract);
-        diseases.push({
-            objectId: state.entryObjectIds[0],
-            code: "causal-cycle",
-            contract,
-            detail: `after dependency cycle includes ${[...cycles].sort().join(", ")}`,
-        });
-        contracts.delete(contract);
-        isolatedContracts.add(contract);
-    }
-    const valid = new Set();
-    for (const [contract, state] of contracts) {
-        if (!state.bind.data.after)
-            valid.add(contract);
-    }
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const [contract, state] of contracts) {
-            if (valid.has(contract))
-                continue;
-            const bindObjectId = state.entryObjectIds[0];
-            const bindTransaction = containingTransactions.get(bindObjectId);
-            const ready = state.bind.data.after.every((dependency) => {
-                const prerequisite = contracts.get(dependency);
-                const prerequisiteBindTransaction = prerequisite === undefined
-                    ? undefined
-                    : containingTransactions.get(prerequisite.entryObjectIds[0]);
-                return prerequisite !== undefined &&
-                    valid.has(dependency) &&
-                    prerequisiteBindTransaction !== undefined &&
-                    bindTransaction !== undefined &&
-                    isTypedLedgerAncestor(ledger, prerequisiteBindTransaction, bindTransaction);
-            });
-            if (ready) {
-                valid.add(contract);
-                changed = true;
-            }
-        }
-    }
-    for (const [contract, state] of [...contracts]) {
-        if (!state.bind.data.after || valid.has(contract))
-            continue;
-        const bindObjectId = state.entryObjectIds[0];
-        diseases.push({
-            objectId: bindObjectId,
-            code: "causal-prerequisite",
-            contract,
-            detail: `after prerequisite binds were not in typed ancestry: ${state.bind.data.after.join(", ")}`,
-        });
-        contracts.delete(contract);
-        isolatedContracts.add(contract);
-    }
-}
-function isolateWorktreePlaceCollisions(contracts, isolatedContracts, diseases) {
-    const occupants = new Map();
-    for (const state of contracts.values()) {
-        if (state.terminalObjectId !== null || state.bind.data.workspace !== "worktree")
-            continue;
-        const states = occupants.get(state.bind.data.place) ?? [];
-        states.push(state);
-        occupants.set(state.bind.data.place, states);
-    }
-    for (const [place, states] of occupants) {
-        if (states.length < 2)
-            continue;
-        const contractsForPlace = states.map((state) => state.contract).sort();
-        for (const state of states) {
-            diseases.push({
-                objectId: state.entryObjectIds[0],
-                code: "worktree-place-collision",
-                contract: state.contract,
-                detail: `worktree place ${place} is assigned to active contracts ${contractsForPlace.join(", ")}`,
-            });
-            contracts.delete(state.contract);
-            isolatedContracts.add(state.contract);
-        }
-    }
-}
-function isolateTaskOwnershipCollisions(contracts, isolatedContracts, diseases) {
-    const owners = new Map();
-    for (const state of contracts.values()) {
-        const terminal = state.terminal;
-        const released = terminal?.kind === "forfeit";
-        if (released)
-            continue;
-        for (const taskId of new Set(state.bind.data.taskIds ?? [])) {
-            const rows = owners.get(taskId) ?? [];
-            rows.push(state);
-            owners.set(taskId, rows);
-        }
-    }
-    for (const [taskId, states] of owners) {
-        if (states.length < 2)
-            continue;
-        const contractsForTask = states.map((state) => state.contract).sort();
-        for (const state of states) {
-            diseases.push({
-                objectId: state.entryObjectIds[0],
-                code: "task-ownership-collision",
-                contract: state.contract,
-                detail: `task ${taskId} is bound by contracts ${contractsForTask.join(", ")}`,
-            });
-            contracts.delete(state.contract);
-            isolatedContracts.add(state.contract);
-        }
-    }
-}
-export function foldRepositoryLedger(ledger) {
-    const diseases = [...ledger.diseases];
-    const { blocked, collisionContracts } = analyzeJoinBoundaries(ledger, diseases);
-    const traversalDiseaseContracts = new Set(ledger.diseases.flatMap((disease) => disease.contract === undefined ? [] : [disease.contract]));
-    const byContract = new Map();
-    const positions = new Map();
-    for (const objectId of ledger.order) {
-        if (blocked.has(objectId))
-            continue;
-        const node = ledger.nodes.get(objectId);
-        if (node?.type !== "transaction")
-            continue;
-        const transactions = byContract.get(node.contract) ?? [];
-        const rows = [];
-        let position = positions.get(node.contract) ?? 0;
-        for (const entryObjectId of node.entryObjectIds) {
-            const entryNode = ledger.nodes.get(entryObjectId);
-            if (entryNode?.type !== "lifecycle")
-                continue;
-            rows.push({ objectId: entryObjectId, entry: entryNode.entry, position });
-            position += 1;
-        }
-        positions.set(node.contract, position);
-        transactions.push({ objectId: node.objectId, rows });
-        byContract.set(node.contract, transactions);
-    }
-    const contracts = new Map();
-    const isolatedContracts = new Set([...collisionContracts, ...traversalDiseaseContracts]);
-    for (const contract of [...byContract.keys()].sort()) {
-        if (isolatedContracts.has(contract))
-            continue;
-        const transactions = byContract.get(contract);
-        const rows = transactions.flatMap((transaction) => transaction.rows);
-        let divergent = false;
-        for (let left = 0; left < rows.length && !divergent; left += 1) {
-            for (let right = left + 1; right < rows.length; right += 1) {
-                const a = rows[left].objectId;
-                const b = rows[right].objectId;
-                if (!isLifecycleCausalAncestor(ledger, a, b) && !isLifecycleCausalAncestor(ledger, b, a)) {
-                    diseases.push({ objectId: b, code: "same-contract-divergence", contract, detail: `incomparable lifecycle entries ${a} and ${b}` });
-                    divergent = true;
-                    break;
-                }
-            }
-        }
-        if (divergent) {
-            isolatedContracts.add(contract);
-            continue;
-        }
-        let state;
-        for (const transaction of transactions) {
-            let staged = state === undefined ? undefined : structuredClone(state);
-            let rejected = false;
-            for (const row of transaction.rows) {
-                const result = applyFoldEntry(staged, row);
-                staged = result.state;
-                if (result.disease) {
-                    diseases.push({ ...result.disease, transactionObjectId: transaction.objectId });
-                    rejected = true;
-                    break;
-                }
-            }
-            if (!rejected)
-                state = staged;
-        }
-        if (state)
-            contracts.set(contract, state);
-    }
-    validateAfterPrerequisites(ledger, contracts, isolatedContracts, diseases);
-    isolateWorktreePlaceCollisions(contracts, isolatedContracts, diseases);
-    isolateTaskOwnershipCollisions(contracts, isolatedContracts, diseases);
-    return { contracts, isolatedContracts, diseases };
-}

package/build/core/repository-ledger/fold.js

@@ -1,248 +0,0 @@
-function illegal(objectId, entry, detail) {
-    return { objectId, code: "illegal-transition", contract: entry.contract, detail };
-}
-function openSegment(state, objectId) {
-    state.segmentOpen = true;
-    state.segments.push({ intent: state.currentIntent, openedBy: objectId, entryObjectIds: [objectId], seal: null });
-}
-function appendToOpenSegment(state, objectId) {
-    if (!state.segmentOpen)
-        return;
-    state.segments.at(-1)?.entryObjectIds.push(objectId);
-}
-function bootstrapFailed(entry) {
-    return entry.data.result.kind !== "exit" || entry.data.result.code !== 0;
-}
-/** Bind-owned automatic paths are admitted and folded with the same ordering. */
-export function bindEffectiveScope(entry) {
-    const taskPaths = (entry.data.taskIds ?? []).map((taskId) => `.keiyaku/tasks/${taskId}.md`);
-    return [...new Set([...entry.data.scope, ...taskPaths])];
-}
-export function applyFoldEntry(state, row) {
-    const { objectId, entry, position } = row;
-    if (!state) {
-        if (entry.kind !== "bind")
-            return { disease: illegal(objectId, entry, `${entry.kind} cannot precede bind`) };
-        return {
-            state: {
-                contract: entry.contract,
-                phase: "active",
-                bind: entry,
-                effectiveScope: bindEffectiveScope(entry),
-                base: entry.data.base,
-                target: entry.data.target,
-                fence: entry.data.base,
-                deliveryHead: entry.data.base,
-                greatestExplicitArc: 0,
-                currentIntent: 0,
-                segmentOpen: true,
-                segments: [{ intent: 0, openedBy: objectId, entryObjectIds: [objectId], seal: null }],
-                sealedBy: null,
-                petition: null,
-                petitionIntent: null,
-                approvedTargetSnapshot: null,
-                verdict: null,
-                terminal: null,
-                terminalObjectId: null,
-                bootstrap: null,
-                bootstrapFailure: "none",
-                entryObjectIds: [objectId],
-                lastAcceptedKind: "bind",
-            },
-        };
-    }
-    const accept = (appendToSegment = true) => {
-        state.entryObjectIds.push(objectId);
-        state.lastAcceptedKind = entry.kind;
-        if (appendToSegment)
-            appendToOpenSegment(state, objectId);
-        return { state };
-    };
-    const reject = (detail) => ({ state, disease: illegal(objectId, entry, detail) });
-    if (state.phase === "claimed" || state.phase === "forfeited") {
-        return reject(`terminal ${state.phase} contract has no lifecycle successor`);
-    }
-    if (state.bootstrapFailure === "interrupted") {
-        return reject("failed bootstrap must be followed immediately by bind-failed forfeit");
-    }
-    if (state.bootstrapFailure === "awaiting-forfeit") {
-        if (entry.kind === "forfeit" &&
-            entry.data.reason === "bind-failed" &&
-            position === state.bootstrap.position + 1) {
-            state.phase = "forfeited";
-            state.deliveryHead = entry.data.finalHead;
-            state.terminal = entry;
-            state.terminalObjectId = objectId;
-            state.bootstrapFailure = "none";
-            return accept(false);
-        }
-        state.bootstrapFailure = "interrupted";
-        return reject("failed bootstrap must be followed immediately by bind-failed forfeit");
-    }
-    if (entry.kind === "bind")
-        return reject("bind may occur only once");
-    if (entry.kind === "bootstrap") {
-        if (position !== 1 || state.entryObjectIds.length !== 1) {
-            return reject("bootstrap must immediately follow bind");
-        }
-        if (state.bind.data.workspace !== "worktree" || !state.bind.data.bootstrap) {
-            return reject("bootstrap without bind plan");
-        }
-        const failed = bootstrapFailed(entry);
-        state.bootstrap = { objectId, position, result: entry.data.result, failed };
-        if (failed)
-            state.bootstrapFailure = "awaiting-forfeit";
-        return accept();
-    }
-    if (entry.kind === "amend") {
-        const extendScope = () => {
-            if (entry.data.scopeDelta)
-                state.effectiveScope.push(...entry.data.scopeDelta.add);
-        };
-        if (state.phase === "active" && state.segmentOpen) {
-            extendScope();
-            return accept();
-        }
-        if (state.phase === "awaiting-verdict" || state.phase === "approved") {
-            state.phase = "active";
-            state.sealedBy = null;
-            state.petition = null;
-            state.petitionIntent = null;
-            state.approvedTargetSnapshot = null;
-            state.verdict = null;
-            openSegment(state, objectId);
-            extendScope();
-            return accept(false);
-        }
-        return reject("amend requires an active segment or a petitioned state");
-    }
-    if (entry.kind === "seal") {
-        if (state.phase !== "active" || !state.segmentOpen)
-            return reject("seal requires an active open segment");
-        if (entry.data.arc !== state.currentIntent)
-            return reject("seal arc does not match current intent");
-        if (entry.data.oldFence !== state.fence)
-            return reject("seal oldFence does not continue the folded fence");
-        const segment = state.segments.at(-1);
-        segment.entryObjectIds.push(objectId);
-        segment.seal = {
-            objectId,
-            sealedBy: entry.data.sealedBy,
-            oldFence: entry.data.oldFence,
-            receipts: [...entry.data.receipts],
-            newFence: entry.data.newFence,
-            diffstat: { ...entry.data.diffstat },
-            scopeAudit: { violations: [...entry.data.scopeAudit.violations] },
-        };
-        state.phase = "sealed";
-        state.segmentOpen = false;
-        state.sealedBy = entry.data.sealedBy;
-        state.fence = entry.data.newFence;
-        state.deliveryHead = entry.data.newFence;
-        return accept(false);
-    }
-    if (entry.kind === "arc") {
-        if (state.phase !== "sealed" || state.sealedBy !== "arc")
-            return reject("arc must consume an arc seal");
-        if (entry.data.arc !== state.greatestExplicitArc + 1)
-            return reject("explicit arcs must increase by exactly one");
-        state.greatestExplicitArc = entry.data.arc;
-        state.currentIntent = entry.data.arc;
-        state.phase = "active";
-        state.sealedBy = null;
-        openSegment(state, objectId);
-        return accept(false);
-    }
-    if (entry.kind === "renew") {
-        if (state.phase !== "sealed" || state.sealedBy !== "renew")
-            return reject("renew must consume a renew seal");
-        const seal = state.segments.at(-1)?.seal;
-        if (!seal)
-            return reject("renew seal facts are missing");
-        const replacedHead = seal.receipts.at(-1) ?? seal.oldFence;
-        if (entry.data.oldBase !== state.base || entry.data.oldHead !== replacedHead) {
-            return reject("renew old coordinates do not match folded coordinates");
-        }
-        if (entry.data.newHead !== seal.newFence)
-            return reject("renew newHead does not match its seal fence");
-        state.base = entry.data.newBase;
-        state.fence = entry.data.newHead;
-        state.deliveryHead = entry.data.newHead;
-        state.phase = "active";
-        state.sealedBy = null;
-        openSegment(state, objectId);
-        return accept(false);
-    }
-    if (entry.kind === "petition") {
-        const currentSegment = state.segments.at(-1);
-        const consumesImmediateRenewSeal = state.phase === "active"
-            && state.segmentOpen
-            && state.lastAcceptedKind === "renew"
-            && currentSegment?.seal === null
-            && currentSegment.entryObjectIds.length === 1
-            && state.entryObjectIds.at(-1) === currentSegment.openedBy;
-        if (state.phase !== "sealed" && !consumesImmediateRenewSeal) {
-            return reject("petition must consume a seal");
-        }
-        if (entry.data.target !== state.target)
-            return reject("petition target does not match bind target");
-        state.phase = "awaiting-verdict";
-        state.sealedBy = null;
-        state.petition = entry;
-        state.petitionIntent = entry.data.intent;
-        state.approvedTargetSnapshot = null;
-        state.verdict = null;
-        return accept(false);
-    }
-    if (entry.kind === "verdict") {
-        if (state.phase !== "awaiting-verdict" || !state.petition)
-            return reject("verdict requires a pending petition");
-        state.verdict = entry;
-        if (entry.data.result === "approved") {
-            state.phase = "approved";
-            const petitionData = state.petition.data;
-            state.approvedTargetSnapshot = petitionData.intent === "claim"
-                ? { target: petitionData.target, targetHead: petitionData.targetHead }
-                : null;
-            return accept(false);
-        }
-        state.phase = "active";
-        state.petition = null;
-        state.petitionIntent = null;
-        state.approvedTargetSnapshot = null;
-        state.verdict = null;
-        openSegment(state, objectId);
-        return accept(false);
-    }
-    if (entry.kind === "claim") {
-        const petitionData = state.petition?.data;
-        if (state.phase !== "approved" || !petitionData || petitionData.intent !== "claim") {
-            return reject("claim requires an approved claim petition");
-        }
-        if (entry.data.target !== state.target ||
-            entry.data.base !== state.base ||
-            entry.data.targetHead !== petitionData.targetHead ||
-            entry.data.deliveryHead !== state.deliveryHead)
-            return reject("claim coordinates do not match folded petition coordinates");
-        state.phase = "claimed";
-        state.terminal = entry;
-        state.terminalObjectId = objectId;
-        return accept(false);
-    }
-    if (entry.kind === "forfeit") {
-        if (entry.data.reason === "bind-failed")
-            return reject("bind-failed forfeit requires an immediately preceding failed bootstrap");
-        if (state.phase === "awaiting-verdict") {
-            return reject("manual forfeit cannot bypass a pending settlement");
-        }
-        if (state.phase === "approved" && state.petition?.data.intent !== "forfeit") {
-            return reject("approved settlement permits forfeit only for forfeit intent");
-        }
-        state.phase = "forfeited";
-        state.deliveryHead = entry.data.finalHead;
-        state.terminal = entry;
-        state.terminalObjectId = objectId;
-        return accept(false);
-    }
-    return reject(`unsupported transition ${entry.kind}`);
-}