@astrosheep/keiyaku 2.9.9 → 2.9.10

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

@@ -0,0 +1,310 @@
+import * as path from "node:path";
+import { REPOSITORY_DELIVERY_REF_PREFIX, REPOSITORY_LEDGER_REF } from "./codec.js";
+export function nonblank(value) {
+    return value.trim().length > 0;
+}
+export function isCanonicalAbsolute(value) {
+    return path.isAbsolute(value) && path.resolve(value) === value;
+}
+function isContained(root, candidate) {
+    if (!isCanonicalAbsolute(root) || !isCanonicalAbsolute(candidate))
+        return false;
+    const relative = path.relative(root, candidate);
+    return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function completeObjectId(format, value) {
+    return new RegExp(`^[0-9a-f]{${format === "sha1" ? 40 : 64}}$`, "i").test(value);
+}
+function completeHostObjectId(value) {
+    return value !== undefined && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(value);
+}
+function refAction(observation, owner) {
+    return {
+        refName: observation.refName,
+        canonicalRoot: observation.canonicalRoot,
+        noSymlink: true,
+        objectFormat: observation.objectFormat,
+        exactObjectId: observation.exactObjectId,
+        owner,
+    };
+}
+function pathAction(observation, owner) {
+    return {
+        canonicalRoot: observation.canonicalRoot,
+        absoluteRealpath: observation.absoluteRealpath,
+        noSymlink: true,
+        owner,
+    };
+}
+function refusal(observation, reason) {
+    return {
+        observation,
+        classification: "unknown",
+        migration: { kind: "refuse-preserve", reason },
+        nuke: { kind: "refuse-preserve", reason },
+    };
+}
+function validRefObservation(observation) {
+    if (!isCanonicalAbsolute(observation.canonicalRoot))
+        return "ref observation lacks a canonical repository root";
+    if (!observation.noSymlink)
+        return "ref observation traverses a symlink";
+    if (!completeObjectId(observation.objectFormat, observation.exactObjectId)) {
+        return `ref observation lacks a complete ${observation.objectFormat} exact object ID`;
+    }
+    return null;
+}
+function classifyRef(observation, authority) {
+    const invalid = validRefObservation(observation);
+    if (invalid)
+        return refusal(observation, invalid);
+    if (!isCanonicalAbsolute(authority.canonicalRoot) || observation.canonicalRoot !== authority.canonicalRoot) {
+        return refusal(observation, "ref observation does not belong to the authority repository root");
+    }
+    const candidates = [];
+    if (observation.refName === REPOSITORY_LEDGER_REF) {
+        const action = refAction(observation, { kind: "repository-ledger" });
+        candidates.push({
+            observation,
+            classification: "repository-ledger-ref",
+            migration: { kind: "preserve" },
+            nuke: { kind: "delete-ref-exact-oid", ...action },
+        });
+    }
+    const deliveryPrefix = REPOSITORY_DELIVERY_REF_PREFIX;
+    if (observation.refName.startsWith(deliveryPrefix)) {
+        const contractId = observation.refName.slice(deliveryPrefix.length);
+        const contract = authority.fold.contracts.get(contractId);
+        const bindObjectId = contract?.entryObjectIds[0];
+        if (contract && contract.contract === contractId && contract.bind.contract === contractId &&
+            !contractId.includes("/") && completeHostObjectId(bindObjectId)) {
+            const action = refAction(observation, { kind: "contract-delivery", contractId, bindObjectId });
+            candidates.push({
+                observation,
+                classification: "contract-delivery-ref",
+                migration: { kind: "preserve" },
+                nuke: { kind: "delete-ref-exact-oid", ...action },
+            });
+        }
+    }
+    for (const legacy of authority.legacyRefs) {
+        if (!legacy.closureVerified || !nonblank(legacy.legacyIdentity))
+            continue;
+        if (legacy.canonicalRoot !== observation.canonicalRoot || legacy.refName !== observation.refName ||
+            legacy.objectFormat !== observation.objectFormat || legacy.exactObjectId !== observation.exactObjectId)
+            continue;
+        const action = refAction(observation, { kind: "legacy-ref", legacyIdentity: legacy.legacyIdentity });
+        candidates.push({
+            observation,
+            classification: "legacy-ref",
+            migration: { kind: "retire-after-closure-cas", ready: legacy.migrationReady, ...action },
+            nuke: { kind: "delete-ref-exact-oid", ...action },
+        });
+    }
+    if (candidates.length === 0)
+        return refusal(observation, "ref has no unique typed owner relationship");
+    if (candidates.length > 1)
+        return refusal(observation, "ref ownership is ambiguous");
+    return candidates[0];
+}
+function worktreeOwner(registration, authority) {
+    if (registration.canonicalRoot !== authority.canonicalRoot || !isCanonicalAbsolute(registration.canonicalRoot) ||
+        !isContained(registration.canonicalRoot, registration.canonicalRealpath) ||
+        !nonblank(registration.registrationIdentity))
+        return null;
+    const prefix = REPOSITORY_DELIVERY_REF_PREFIX;
+    if (!registration.branch.startsWith(prefix))
+        return null;
+    const contractId = registration.branch.slice(prefix.length);
+    if (!contractId || contractId.includes("/"))
+        return null;
+    const contract = authority.fold.contracts.get(contractId);
+    if (!contract || contract.bind.contract !== contractId || contract.bind.data.workspace !== "worktree")
+        return null;
+    const bindObjectId = contract.entryObjectIds[0];
+    if (!completeHostObjectId(bindObjectId))
+        return null;
+    const expectedRealpath = path.join(registration.canonicalRoot, ".keiyaku", "wt", contract.bind.data.place);
+    if (registration.canonicalRealpath !== expectedRealpath)
+        return null;
+    return {
+        kind: "contract-worktree",
+        contractId,
+        bindObjectId,
+        branch: registration.branch,
+        registeredWorktreeRealpath: registration.canonicalRealpath,
+        registrationIdentity: registration.registrationIdentity,
+    };
+}
+function provenRenderingOwner(observation, authority, worktree) {
+    if (authority.canonicalRoot !== observation.canonicalRoot || authority.absoluteRealpath !== observation.absoluteRealpath ||
+        authority.noSymlink !== true || authority.gitTracking !== "untracked" ||
+        observation.gitTracking !== authority.gitTracking ||
+        !nonblank(authority.immutableFileIdentity) || observation.immutableFileIdentity !== authority.immutableFileIdentity ||
+        authority.contractId !== worktree.contractId || authority.bindObjectId !== worktree.bindObjectId ||
+        authority.branch !== worktree.branch || authority.registeredWorktreeRealpath !== worktree.registeredWorktreeRealpath ||
+        authority.registrationIdentity !== worktree.registrationIdentity)
+        return null;
+    const expectedPath = authority.rendering === "contract-view"
+        ? path.join(worktree.registeredWorktreeRealpath, ".keiyaku", "KEIYAKU.md")
+        : path.join(worktree.registeredWorktreeRealpath, ".gitignore");
+    if (authority.absoluteRealpath !== expectedPath)
+        return null;
+    return { ...worktree, kind: "worktree-rendering", rendering: authority.rendering };
+}
+function residueCandidates(observation, authority, registrations) {
+    const candidates = [];
+    for (const root of authority.projectionResidueRoots) {
+        if (root.canonicalRoot !== observation.canonicalRoot || !nonblank(root.runtimeIdentity) ||
+            !isContained(root.canonicalRoot, root.projectionRootRealpath))
+            continue;
+        const relative = path.relative(root.projectionRootRealpath, observation.absoluteRealpath);
+        const match = /^([a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*)\/\.mint-([0-9a-f]{8})$/.exec(relative.split(path.sep).join("/"));
+        if (!match)
+            continue;
+        const owner = {
+            kind: "generated-residue",
+            family: "projection-mint",
+            runtimeIdentity: root.runtimeIdentity,
+            projectionRootRealpath: root.projectionRootRealpath,
+            akuma: match[1],
+        };
+        const action = pathAction(observation, owner);
+        candidates.push({ classification: "generated-residue", migration: { kind: "cleanup-generated-residue", ...action }, nuke: { kind: "cleanup-generated-residue", ...action } });
+    }
+    for (const root of authority.projectionAliasResidueRoots) {
+        if (root.canonicalRoot !== observation.canonicalRoot || !nonblank(root.runtimeIdentity) ||
+            !isContained(root.canonicalRoot, root.projectionAliasRootRealpath))
+            continue;
+        const relative = path.relative(root.projectionAliasRootRealpath, observation.absoluteRealpath);
+        if (!/^\.tmp\.[0-9a-f]{8}$/.test(relative))
+            continue;
+        const owner = {
+            kind: "generated-residue",
+            family: "projection-alias-temp",
+            runtimeIdentity: root.runtimeIdentity,
+            projectionAliasRootRealpath: root.projectionAliasRootRealpath,
+        };
+        const action = pathAction(observation, owner);
+        candidates.push({ classification: "generated-residue", migration: { kind: "cleanup-generated-residue", ...action }, nuke: { kind: "cleanup-generated-residue", ...action } });
+    }
+    for (const registration of registrations) {
+        const relative = path.relative(registration.registeredWorktreeRealpath, observation.absoluteRealpath).split(path.sep).join("/");
+        if (!/^\.keiyaku\/\.KEIYAKU\.md\.[0-9]+\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.tmp$/.test(relative))
+            continue;
+        const { kind: _kind, ...worktree } = registration;
+        const owner = { kind: "generated-residue", family: "worktree-rendering-temp", ...worktree };
+        const action = pathAction(observation, owner);
+        candidates.push({ classification: "generated-residue", migration: { kind: "cleanup-generated-residue", ...action }, nuke: { kind: "cleanup-generated-residue", ...action } });
+    }
+    return candidates;
+}
+function classifyPath(observation, authority) {
+    if (!isCanonicalAbsolute(authority.canonicalRoot) || observation.canonicalRoot !== authority.canonicalRoot) {
+        return refusal(observation, "path observation does not belong to the authority repository root");
+    }
+    if (!isCanonicalAbsolute(observation.canonicalRoot) || !isContained(observation.canonicalRoot, observation.absoluteRealpath)) {
+        return refusal(observation, "path observation is not a canonical contained realpath");
+    }
+    if (!observation.noSymlink)
+        return refusal(observation, "path observation traverses a symlink");
+    const registrations = authority.worktrees.flatMap((registration) => {
+        const owner = worktreeOwner(registration, authority);
+        return owner === null ? [] : [owner];
+    });
+    const candidates = [];
+    for (const owner of registrations) {
+        if (owner.registeredWorktreeRealpath === observation.absoluteRealpath) {
+            const action = pathAction(observation, owner);
+            candidates.push({ classification: "contract-worktree", migration: { kind: "preserve" }, nuke: { kind: "remove-proven-worktree", ...action } });
+        }
+        for (const rendering of authority.generatedWorktreeRenderings) {
+            const renderingOwner = provenRenderingOwner(observation, rendering, owner);
+            if (renderingOwner === null)
+                continue;
+            const action = pathAction(observation, renderingOwner);
+            candidates.push({
+                classification: "worktree-rendering",
+                migration: { kind: "preserve" },
+                nuke: { kind: "delete-proven-path", ...action },
+                ignorePattern: rendering.rendering === "contract-view" ? ".keiyaku/KEIYAKU.md" : ".gitignore",
+            });
+        }
+    }
+    for (const runtime of authority.runtimePaths) {
+        if (runtime.canonicalRoot !== observation.canonicalRoot || runtime.absoluteRealpath !== observation.absoluteRealpath ||
+            !isContained(runtime.canonicalRoot, runtime.absoluteRealpath) || !nonblank(runtime.runtimeIdentity))
+            continue;
+        const owner = { kind: "runtime-path", runtimeKind: runtime.runtimeKind, runtimeIdentity: runtime.runtimeIdentity };
+        const action = pathAction(observation, owner);
+        candidates.push({
+            classification: "runtime-path",
+            migration: runtime.migration === "retire-after-hard-cut"
+                ? { kind: "retire-after-hard-cut", ready: runtime.migrationReady === true, ...action }
+                : { kind: "preserve" },
+            nuke: { kind: "delete-proven-path", ...action },
+        });
+    }
+    candidates.push(...residueCandidates(observation, authority, registrations));
+    if (candidates.length === 0)
+        return refusal(observation, "path has no unique typed owner relationship");
+    if (candidates.length > 1)
+        return refusal(observation, "path ownership is ambiguous");
+    const candidate = candidates[0];
+    return { observation, ...candidate };
+}
+export function classifyRepositoryInventory(observations, authority) {
+    return observations.map((observation) => {
+        switch (observation.kind) {
+            case "ref": return classifyRef(observation, authority);
+            case "path": return classifyPath(observation, authority);
+            case "excluded-user-data":
+                return { observation, classification: "excluded-user-data", migration: { kind: "preserve" }, nuke: { kind: "preserve" } };
+            case "unknown": return refusal(observation, observation.reason);
+        }
+    });
+}
+export function createRepositoryInventoryManifest(rows, authority, receipt) {
+    return { authority, receipt, rows };
+}
+export function inventoryIgnorePatterns(rows) {
+    return rows.flatMap((row) => row.ignorePattern === undefined ? [] : [row.ignorePattern]).sort();
+}
+function foldedWorktreeCoordinate(model) {
+    const bind = model.history.find(({ entry }) => entry.kind === "bind")?.entry;
+    if (!bind || bind.kind !== "bind")
+        throw new Error(`contract ${model.contract} has no accepted bind coordinate`);
+    return bind.data.workspace === "here"
+        ? { workspace: "here" }
+        : { workspace: "worktree", place: bind.data.place };
+}
+function sameWorktree(left, right) {
+    if (left.workspace !== right.workspace)
+        return false;
+    if (left.workspace === "here")
+        return true;
+    return right.workspace === "worktree" && left.place === right.place;
+}
+/** Nonterminal contracts that physically occupy the repository-root carrier. */
+export function activeWorkspaceHereContracts(read) {
+    return read.contracts
+        .filter((candidate) => (!["claimed", "forfeited"].includes(candidate.phase)
+        && foldedWorktreeCoordinate(candidate).workspace === "here"))
+        .map(({ contract }) => contract)
+        .sort();
+}
+/** Runtime ignore projection for one worktree from a single typed repository fold. */
+export function inventoryIgnorePatternsForWorktree(read, targetLifecycle) {
+    if (read.observedLedgerHead !== targetLifecycle.observedLedgerHead) {
+        throw new Error("narrow-ignore inventory requires one repository-ledger observation");
+    }
+    const acceptedTarget = read.contracts.find(({ contract }) => contract === targetLifecycle.contract);
+    if (!acceptedTarget)
+        throw new Error(`contract ${targetLifecycle.contract} is absent from narrow-ignore inventory`);
+    const target = foldedWorktreeCoordinate(acceptedTarget);
+    const required = target.workspace === "here"
+        ? activeWorkspaceHereContracts(read).length > 0
+        : read.contracts.some((candidate) => (!["claimed", "forfeited"].includes(candidate.phase)
+            && sameWorktree(foldedWorktreeCoordinate(candidate), target)));
+    return required ? [".gitignore", ".keiyaku/KEIYAKU.md"] : [];
+}

package/build/core/repository-ledger/publication-admission.js

@@ -0,0 +1,125 @@
+import { foldRepositoryLedger } from "./fold-repository.js";
+const VIRTUAL_JOIN_OBJECT_ID = "publication-admission:join";
+const CURRENT_CODEC_PHASE = "repository-ledger-transaction-v1";
+function typedRoot(traversal) {
+    const roots = [...traversal.nodes.values()].filter((node) => node.type !== "lifecycle" && node.ledgerParents.length === 0);
+    return roots.length === 1 && roots[0]?.type === "transaction" && roots[0].transaction.verb === "bind"
+        ? roots[0].objectId
+        : null;
+}
+export function cleanTip(head, traversal) {
+    const fold = foldRepositoryLedger(traversal);
+    const root = typedRoot(traversal);
+    if (traversal.diseases.length > 0
+        || fold.diseases.length > 0
+        || fold.isolatedContracts.size > 0
+        || root === null) {
+        return {
+            status: "refused",
+            code: "LEDGER_CLOSURE_DISEASE",
+            localTip: null,
+            remoteTip: null,
+            cause: "ledger tip does not have complete clean typed closure",
+            diagnostics: fold.diseases,
+        };
+    }
+    return { status: "clean", head, traversal, fold, root, phase: CURRENT_CODEC_PHASE };
+}
+function sideOnlyLifecycle(side, other) {
+    const rows = new Map();
+    for (const objectId of side.order) {
+        if (other.nodes.has(objectId))
+            continue;
+        const node = side.nodes.get(objectId);
+        if (node?.type !== "transaction")
+            continue;
+        for (const entryObjectId of node.entryObjectIds) {
+            const entryNode = side.nodes.get(entryObjectId);
+            if (entryNode?.type !== "lifecycle")
+                continue;
+            const contractRows = rows.get(entryNode.entry.contract) ?? [];
+            contractRows.push(entryNode);
+            rows.set(entryNode.entry.contract, contractRows);
+        }
+    }
+    return rows;
+}
+function virtualJoinTraversal(remote, local, join) {
+    const nodes = new Map();
+    const order = [];
+    const add = (traversal) => {
+        for (const objectId of traversal.order) {
+            if (nodes.has(objectId))
+                continue;
+            const node = traversal.nodes.get(objectId);
+            if (node !== undefined)
+                nodes.set(objectId, node);
+            order.push(objectId);
+        }
+    };
+    add(remote.traversal);
+    add(local.traversal);
+    nodes.set(VIRTUAL_JOIN_OBJECT_ID, {
+        type: "join",
+        objectId: VIRTUAL_JOIN_OBJECT_ID,
+        join,
+        ledgerParents: [remote.head, local.head],
+        evidenceParent: null,
+    });
+    order.push(VIRTUAL_JOIN_OBJECT_ID);
+    return {
+        head: VIRTUAL_JOIN_OBJECT_ID,
+        coordinates: local.traversal.coordinates,
+        nodes,
+        order,
+        diseases: [],
+    };
+}
+export function admitJoin(remote, local, join) {
+    if (remote.root !== local.root) {
+        return {
+            status: "refused",
+            code: "LEDGER_DIVERGENCE",
+            localTip: local.head,
+            remoteTip: remote.head,
+            cause: `typed ledger roots differ (${local.root} local, ${remote.root} remote)`,
+        };
+    }
+    if (remote.phase !== local.phase) {
+        return {
+            status: "refused",
+            code: "LEDGER_PHASE_MISMATCH",
+            localTip: local.head,
+            remoteTip: remote.head,
+            cause: `typed ledger codec phases differ (${local.phase} local, ${remote.phase} remote)`,
+        };
+    }
+    const remoteOnly = sideOnlyLifecycle(remote.traversal, local.traversal);
+    const localOnly = sideOnlyLifecycle(local.traversal, remote.traversal);
+    const racedContract = [...remoteOnly.keys()].sort().find((contract) => localOnly.has(contract));
+    if (racedContract !== undefined) {
+        return {
+            status: "refused",
+            code: "LEDGER_ENTRY_RACE",
+            localTip: local.head,
+            remoteTip: remote.head,
+            contract: racedContract,
+            localEntry: localOnly.get(racedContract).at(-1).objectId,
+            remoteEntry: remoteOnly.get(racedContract).at(-1).objectId,
+            cause: `contract ${racedContract} has divergent admitted lifecycle entries`,
+        };
+    }
+    const combined = virtualJoinTraversal(remote, local, join);
+    const folded = foldRepositoryLedger(combined);
+    if (folded.diseases.length > 0 || folded.isolatedContracts.size > 0) {
+        return {
+            status: "refused",
+            code: "LEDGER_SEMANTIC_COLLISION",
+            localTip: local.head,
+            remoteTip: remote.head,
+            cause: "joined ledger tips produce semantic collisions",
+            diagnostics: folded.diseases,
+        };
+    }
+    return { status: "admitted", combined };
+}