@astrosheep/keiyaku 2.9.13 → 4.0.0

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

@@ -1,310 +0,0 @@
-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) {
-    const acceptedTarget = read.contracts.find(({ contract }) => contract === targetLifecycle.contract);
-    if (!acceptedTarget)
-        throw new Error(`contract ${targetLifecycle.contract} is absent from narrow-ignore inventory`);
-    if (acceptedTarget.contractHead !== targetLifecycle.contractHead) {
-        throw new Error("narrow-ignore inventory requires the current contract semantic head");
-    }
-    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

@@ -1,125 +0,0 @@
-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 };
-}