@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/repository-ledger/git-object-store.js

@@ -1,243 +0,0 @@
-import { isFullGitObjectId, runGitProcess, runGitProcessBytes } from "../../git/core.js";
-import { openGitStreamingBatch } from "../../git/streaming-batch.js";
-const NO_LAZY_FETCH_ENV = { GIT_NO_LAZY_FETCH: "1" };
-export class RepositoryObjectError extends Error {
-    reason;
-    code = "INVALID_REPOSITORY_OBJECT";
-    constructor(reason, message, options) {
-        super(message, options);
-        this.reason = reason;
-        this.name = "RepositoryObjectError";
-    }
-}
-function expectedObjectId(objectFormat, value) {
-    const length = objectFormat === "sha1" ? 40 : 64;
-    return value.length === length && isFullGitObjectId(value);
-}
-async function successfulGit(cwd, args, input, signal) {
-    const result = await runGitProcess(cwd, args, { ...(input === undefined ? {} : { input }), signal });
-    if (result.status !== 0 || result.error) {
-        if (result.error?.name === "AbortError")
-            throw result.error;
-        const detail = result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`;
-        throw new RepositoryObjectError("git-failure", `git ${args.join(" ")} failed: ${detail}`, { cause: result.error });
-    }
-    return result.stdout;
-}
-async function successfulGitBytes(cwd, args, signal) {
-    const result = await runGitProcessBytes(cwd, args, { env: NO_LAZY_FETCH_ENV, signal });
-    if (result.status !== 0 || result.error) {
-        if (result.error?.name === "AbortError")
-            throw result.error;
-        const detail = result.stderr.toString("utf8").trim() || result.error?.message || `exit ${String(result.status)}`;
-        throw new RepositoryObjectError("git-failure", `git ${args.join(" ")} failed: ${detail}`, { cause: result.error });
-    }
-    return result.stdout;
-}
-async function gitIdentity(cwd, kind, identity) {
-    const result = await runGitProcess(cwd, ["var", `GIT_${kind}_IDENT`], {
-        env: {
-            [`GIT_${kind}_NAME`]: identity.name,
-            [`GIT_${kind}_EMAIL`]: identity.email,
-            [`GIT_${kind}_DATE`]: identity.date,
-        },
-    });
-    if (result.status !== 0 || result.error) {
-        const detail = result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`;
-        throw new RepositoryObjectError("git-failure", `cannot format Git ${kind.toLowerCase()} identity: ${detail}`, {
-            cause: result.error,
-        });
-    }
-    const formatted = result.stdout.trimEnd();
-    if (!formatted || formatted.includes("\n") || formatted.includes("\r")) {
-        throw new RepositoryObjectError("commit-format", `Git returned an invalid ${kind.toLowerCase()} identity`);
-    }
-    return formatted;
-}
-export async function deriveHostGitCoordinates(cwd, signal) {
-    const objectFormatText = (await successfulGit(cwd, ["rev-parse", "--show-object-format"], undefined, signal)).trim();
-    if (objectFormatText !== "sha1" && objectFormatText !== "sha256") {
-        throw new RepositoryObjectError("object-format", `unsupported Git object format: ${objectFormatText || "<empty>"}`);
-    }
-    const emptyTree = (await successfulGit(cwd, ["hash-object", "-t", "tree", "--stdin"], "", signal)).trim();
-    if (!expectedObjectId(objectFormatText, emptyTree)) {
-        throw new RepositoryObjectError("object-id", `Git returned an invalid ${objectFormatText} empty-tree object ID`);
-    }
-    return {
-        objectFormat: objectFormatText,
-        objectIdLength: objectFormatText === "sha1" ? 40 : 64,
-        emptyTree,
-    };
-}
-export function assertHostObjectId(coordinates, objectId) {
-    if (!expectedObjectId(coordinates.objectFormat, objectId)) {
-        throw new RepositoryObjectError("object-id", `expected a complete ${coordinates.objectFormat} object ID, received ${JSON.stringify(objectId)}`);
-    }
-}
-/** Write one exact commit object without normalizing its ordered parent headers. */
-export async function writeCommitObject(input) {
-    assertHostObjectId(input.coordinates, input.tree);
-    for (const parent of input.parents)
-        assertHostObjectId(input.coordinates, parent);
-    const [author, committer] = await Promise.all([
-        gitIdentity(input.cwd, "AUTHOR", input.author),
-        gitIdentity(input.cwd, "COMMITTER", input.committer),
-    ]);
-    const headers = [
-        `tree ${input.tree}`,
-        ...input.parents.map((parent) => `parent ${parent}`),
-        `author ${author}`,
-        `committer ${committer}`,
-    ];
-    const raw = Buffer.from(`${headers.join("\n")}\n\n${input.message}`, "utf8");
-    const result = await runGitProcessBytes(input.cwd, ["hash-object", "-w", "-t", "commit", "--stdin"], {
-        input: raw,
-        env: NO_LAZY_FETCH_ENV,
-    });
-    if (result.status !== 0 || result.error) {
-        const detail = result.stderr.toString("utf8").trim() || result.error?.message || `exit ${String(result.status)}`;
-        throw new RepositoryObjectError("git-failure", `cannot write exact Git commit object: ${detail}`, {
-            cause: result.error,
-        });
-    }
-    const objectId = result.stdout.toString("utf8").trim();
-    assertHostObjectId(input.coordinates, objectId);
-    const written = await readCommitObject(input.cwd, input.coordinates, objectId);
-    if (written.tree !== input.tree ||
-        written.parents.length !== input.parents.length ||
-        written.parents.some((parent, index) => parent !== input.parents[index]) ||
-        !Buffer.from(written.messageBytes).equals(Buffer.from(input.message, "utf8"))) {
-        throw new RepositoryObjectError("commit-format", `Git did not preserve exact commit object ${objectId}`);
-    }
-    return objectId;
-}
-async function assertExactReadableCommit(cwd, coordinates, objectId, signal) {
-    assertHostObjectId(coordinates, objectId);
-    const type = await runGitProcess(cwd, ["cat-file", "-t", objectId], { env: NO_LAZY_FETCH_ENV, signal });
-    if (type.status !== 0 || type.error || type.stdout.trim() !== "commit") {
-        if (type.error?.name === "AbortError")
-            throw type.error;
-        throw new RepositoryObjectError("unreadable-commit", `object ${objectId} is not exactly a commit`, { cause: type.error });
-    }
-    const readable = await runGitProcess(cwd, ["cat-file", "-e", objectId], { env: NO_LAZY_FETCH_ENV, signal });
-    if (readable.status !== 0 || readable.error) {
-        if (readable.error?.name === "AbortError")
-            throw readable.error;
-        throw new RepositoryObjectError("unreadable-commit", `commit ${objectId} is not readable`, { cause: readable.error });
-    }
-}
-export async function readCommitObject(cwd, coordinates, objectId, signal) {
-    await assertExactReadableCommit(cwd, coordinates, objectId, signal);
-    let raw;
-    try {
-        raw = await successfulGitBytes(cwd, ["cat-file", "commit", objectId], signal);
-    }
-    catch (error) {
-        throw new RepositoryObjectError("unreadable-commit", `cannot read commit ${objectId}`, { cause: error });
-    }
-    return parseRawCommitObject(coordinates, objectId, raw);
-}
-function parseRawCommitObject(coordinates, objectId, raw) {
-    const bytes = Buffer.from(raw);
-    const separator = bytes.indexOf("\n\n");
-    if (separator < 0) {
-        throw new RepositoryObjectError("commit-format", `commit ${objectId} has no header/message separator`);
-    }
-    const headers = bytes.subarray(0, separator).toString("utf8").split("\n");
-    const treeRows = headers.filter((line) => line.startsWith("tree "));
-    const parentRows = headers.filter((line) => line.startsWith("parent "));
-    if (treeRows.length !== 1) {
-        throw new RepositoryObjectError("commit-format", `commit ${objectId} must have exactly one tree header`);
-    }
-    const tree = treeRows[0].slice("tree ".length);
-    const parents = parentRows.map((line) => line.slice("parent ".length));
-    assertHostObjectId(coordinates, tree);
-    for (const parent of parents)
-        assertHostObjectId(coordinates, parent);
-    const messageBytes = bytes.subarray(separator + 2);
-    const subjectEnd = messageBytes.indexOf(0x0a);
-    const subjectBytes = messageBytes.subarray(0, subjectEnd < 0 ? messageBytes.length : subjectEnd);
-    let subjectHint;
-    try {
-        subjectHint = new TextDecoder("utf-8", { fatal: true }).decode(subjectBytes);
-    }
-    catch {
-        subjectHint = undefined;
-    }
-    return { objectId, tree, parents, messageBytes, ...(subjectHint === undefined ? {} : { subjectHint }) };
-}
-/** Read many repository commits through one no-lazy-fetch Git batch process. */
-export function openRepositoryCommitReader(cwd, coordinates, signal) {
-    const session = openGitStreamingBatch(cwd, { env: NO_LAZY_FETCH_ENV, signal });
-    let transportFailed = false;
-    return {
-        async read(objectId) {
-            signal?.throwIfAborted();
-            assertHostObjectId(coordinates, objectId);
-            let response;
-            try {
-                response = await session.request(objectId);
-            }
-            catch (error) {
-                transportFailed = true;
-                signal?.throwIfAborted();
-                throw new RepositoryObjectError("unreadable-commit", `cannot read commit ${objectId}`, { cause: error });
-            }
-            if (response.kind !== "object"
-                || response.record.oid !== objectId
-                || response.record.type !== "commit") {
-                throw new RepositoryObjectError("unreadable-commit", `object ${objectId} is not exactly a commit`);
-            }
-            return parseRawCommitObject(coordinates, objectId, response.record.content);
-        },
-        async close() {
-            try {
-                const fact = await session.close();
-                if (signal?.aborted)
-                    return;
-                if (!transportFailed && (fact.timedOut || fact.code !== 0 || fact.signal !== null)) {
-                    const detail = fact.stderr.toString("utf8").trim() || `exit ${String(fact.code)}`;
-                    throw new RepositoryObjectError("git-failure", `git cat-file --batch failed: ${detail}`);
-                }
-            }
-            catch (error) {
-                if (transportFailed)
-                    return;
-                if (error instanceof RepositoryObjectError)
-                    throw error;
-                throw new RepositoryObjectError("git-failure", "cannot close git cat-file --batch", { cause: error });
-            }
-        },
-    };
-}
-/** Prove the complete persisted object closure of one observed ledger head in one Git walk. */
-export async function assertReadableCommitClosure(cwd, objectId, signal) {
-    const closure = await runGitProcess(cwd, ["--no-replace-objects", "rev-list", "--objects", "--missing=print", objectId], { env: { GIT_NO_LAZY_FETCH: "1", GIT_SHALLOW_FILE: "" }, signal });
-    if (closure.error?.name === "AbortError")
-        throw closure.error;
-    if (closure.status !== 0 || closure.error) {
-        const detail = closure.stderr.trim() || closure.error?.message || `exit ${String(closure.status)}`;
-        throw new RepositoryObjectError("unreadable-commit", `commit ${objectId} does not have complete local reachability: ${detail}`, { cause: closure.error });
-    }
-    const missing = closure.stdout.split(/\r?\n/).filter((line) => line.startsWith("?"));
-    if (missing.length > 0) {
-        throw new RepositoryObjectError("incomplete-commit-closure", `commit ${objectId} has ${missing.length} missing object${missing.length === 1 ? "" : "s"} in its persisted closure`);
-    }
-}
-export async function assertReadableCommit(cwd, coordinates, objectId) {
-    await assertExactReadableCommit(cwd, coordinates, objectId);
-    const closure = await runGitProcess(cwd, ["--no-replace-objects", "rev-list", "--objects", "--missing=print", objectId], {
-        env: {
-            GIT_NO_LAZY_FETCH: "1",
-            GIT_SHALLOW_FILE: "",
-        },
-    });
-    if (closure.status !== 0 || closure.error) {
-        const detail = closure.stderr.trim() || closure.error?.message || `exit ${String(closure.status)}`;
-        throw new RepositoryObjectError("unreadable-commit", `commit ${objectId} does not have complete local reachability: ${detail}`, { cause: closure.error });
-    }
-    const missing = closure.stdout.split(/\r?\n/).filter((line) => line.startsWith("?"));
-    if (missing.length > 0) {
-        throw new RepositoryObjectError("incomplete-commit-closure", `commit ${objectId} has ${missing.length} missing object${missing.length === 1 ? "" : "s"} in its persisted closure`);
-    }
-}

package/build/core/repository-ledger/history-read.js

@@ -1,15 +0,0 @@
-import { historyConsequencesForContract, lookupCurrentContract, readRepositoryLifecycle, unavailableContractHistoryConsequences, } from "./read-model.js";
-export { unavailableContractHistoryConsequences } from "./read-model.js";
-/** Fold the current transaction topology once for every requested contract. */
-export async function readContractHistoryConsequences(cwd, contractIds) {
-    const requested = [...new Set(contractIds)].sort();
-    if (requested.length === 0)
-        return new Map();
-    try {
-        const lifecycle = await readRepositoryLifecycle(cwd);
-        return new Map(requested.map((contract) => [contract, historyConsequencesForContract(lookupCurrentContract(lifecycle, contract))]));
-    }
-    catch {
-        return new Map(requested.map((contract) => [contract, unavailableContractHistoryConsequences("repository-unavailable")]));
-    }
-}

package/build/core/repository-ledger/incremental-read.js

@@ -1,153 +0,0 @@
-import { runGitProcess } from "../../git/core.js";
-import { evidenceObjectId, parseRepositoryLedgerMessage, } from "./codec.js";
-import { deriveHostGitCoordinates, openRepositoryCommitReader, RepositoryObjectError, } from "./git-object-store.js";
-import { transactionEntryBoundaryError } from "./traversal.js";
-export class IncrementalLedgerValidationError extends Error {
-    code = "INVALID_REPOSITORY_LEDGER_SUCCESSOR";
-    constructor(message = "repository ledger successor failed typed delta validation") {
-        super(message);
-        this.name = "IncrementalLedgerValidationError";
-    }
-}
-function decode(bytes) {
-    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-}
-async function assertDeltaClosure(cwd, head, pinnedHead, signal) {
-    const result = await runGitProcess(cwd, [
-        "--no-replace-objects",
-        "rev-list",
-        "--objects",
-        "--missing=print",
-        head,
-        `^${pinnedHead}`,
-    ], { env: { GIT_NO_LAZY_FETCH: "1", GIT_SHALLOW_FILE: "" }, signal });
-    if (result.error?.name === "AbortError")
-        throw result.error;
-    if (result.status !== 0 || result.error || result.stdout.split(/\r?\n/).some((line) => line.startsWith("?"))) {
-        throw new RepositoryObjectError("incomplete-commit-closure", `incremental ledger segment ${pinnedHead}..${head} is not completely readable`, { cause: result.error });
-    }
-}
-/** Read the typed objects introduced since a head-pinned accepted topology. */
-export async function readIncrementalRepositorySegment(cwd, pinnedHead, observedHead, signal, acceptedState = { ledgerParents: new Map([[pinnedHead, []]]), entryIntroductions: new Map() }) {
-    const coordinates = await deriveHostGitCoordinates(cwd, signal);
-    await assertDeltaClosure(cwd, observedHead, pinnedHead, signal);
-    const reader = openRepositoryCommitReader(cwd, coordinates, signal);
-    const transactions = [];
-    const joins = [];
-    const seen = new Set();
-    const ledgerParents = new Map(acceptedState.ledgerParents);
-    const entryIntroductions = new Map(acceptedState.entryIntroductions);
-    const isAncestor = (ancestor, descendant) => {
-        if (ancestor === descendant)
-            return true;
-        const pending = [descendant];
-        const seenAncestors = new Set();
-        while (pending.length > 0) {
-            const cursor = pending.pop();
-            if (seenAncestors.has(cursor))
-                continue;
-            seenAncestors.add(cursor);
-            for (const parent of ledgerParents.get(cursor) ?? []) {
-                if (parent === ancestor)
-                    return true;
-                pending.push(parent);
-            }
-        }
-        return false;
-    };
-    try {
-        const invalid = (detail) => { throw new IncrementalLedgerValidationError(detail); };
-        const visit = async (cursor) => {
-            if (ledgerParents.has(cursor))
-                return true;
-            if (seen.has(cursor))
-                return true;
-            seen.add(cursor);
-            const raw = await reader.read(cursor);
-            if (raw.tree !== coordinates.emptyTree)
-                return invalid("incremental node has the wrong tree");
-            let record;
-            try {
-                record = parseRepositoryLedgerMessage(decode(raw.messageBytes), coordinates.objectFormat);
-            }
-            catch {
-                return invalid("incremental node has an invalid codec");
-            }
-            if (record.kind === "join") {
-                if (raw.parents.length !== 2 || raw.parents[0] === raw.parents[1])
-                    return invalid("incremental join has invalid parents");
-                if (!await visit(raw.parents[0]) || !await visit(raw.parents[1]))
-                    return false;
-                joins.push({ objectId: cursor, parents: [raw.parents[0], raw.parents[1]] });
-                ledgerParents.set(cursor, [raw.parents[0], raw.parents[1]]);
-                return true;
-            }
-            if (record.kind !== "transaction")
-                return invalid("incremental ledger node is not a transaction or join");
-            const predecessorCount = record.predecessor === "p1" ? 1 : 0;
-            if (raw.parents.length <= predecessorCount)
-                return invalid("incremental transaction has no introduced member");
-            const predecessor = predecessorCount === 1 ? raw.parents[0] : null;
-            if (predecessor !== null && !await visit(predecessor))
-                return false;
-            const entryIds = raw.parents.slice(predecessorCount);
-            if (new Set(raw.parents).size !== raw.parents.length)
-                return invalid("incremental transaction repeats a parent");
-            const entries = [];
-            for (const objectId of entryIds) {
-                const entryRaw = await reader.read(objectId);
-                if (entryRaw.tree !== coordinates.emptyTree)
-                    return invalid("incremental entry has the wrong tree");
-                let entryRecord;
-                try {
-                    entryRecord = parseRepositoryLedgerMessage(decode(entryRaw.messageBytes), coordinates.objectFormat);
-                }
-                catch {
-                    return invalid("incremental entry has an invalid codec");
-                }
-                if (entryRecord.kind === "transaction" || entryRecord.kind === "join")
-                    return invalid("incremental member is not a lifecycle entry");
-                const evidence = evidenceObjectId(entryRecord);
-                const expectedParents = evidence === null ? (entryRaw.parents.length <= 1) : (entryRaw.parents.length === 2 && entryRaw.parents[1] === evidence);
-                if (!expectedParents || (entryRaw.parents.length === 0 && entryRecord.kind !== "bind"))
-                    return invalid("incremental entry has invalid parent topology");
-                if ((entryRecord.kind === "bind") !== (entryRaw.parents.length === 0))
-                    return invalid("incremental bind parent topology is invalid");
-                if (evidence !== null)
-                    await reader.read(evidence);
-                entries.push({ objectId, entry: entryRecord, causalParent: entryRaw.parents[0] ?? null });
-            }
-            const nodes = new Map();
-            for (const entry of entries)
-                nodes.set(entry.objectId, {
-                    type: "lifecycle",
-                    objectId: entry.objectId,
-                    entry: entry.entry,
-                    ledgerParents: entry.causalParent === null ? [] : [entry.causalParent],
-                    evidenceParent: evidenceObjectId(entry.entry),
-                });
-            const typedTransaction = {
-                type: "transaction", objectId: cursor, transaction: record,
-                ledgerParents: predecessor === null ? [] : [predecessor], entryObjectIds: entryIds,
-                contract: "", finalEntryObjectId: entryIds.at(-1), evidenceParent: null,
-            };
-            const boundaryError = transactionEntryBoundaryError(typedTransaction, nodes, (objectId) => {
-                const introduction = entryIntroductions.get(objectId);
-                return introduction !== undefined && predecessor !== null && isAncestor(introduction, predecessor);
-            });
-            if (boundaryError)
-                throw new IncrementalLedgerValidationError(boundaryError);
-            ledgerParents.set(cursor, predecessor === null ? [] : [predecessor]);
-            for (const entry of entries)
-                entryIntroductions.set(entry.objectId, cursor);
-            transactions.push({ objectId: cursor, predecessor, transaction: record, entries });
-            return true;
-        };
-        if (!await visit(observedHead))
-            throw new IncrementalLedgerValidationError();
-        return { coordinates, transactions, joins };
-    }
-    finally {
-        await reader.close();
-    }
-}

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

@@ -1,15 +0,0 @@
-export * from "./codec.js";
-export * from "./git-object-store.js";
-export * from "./traversal.js";
-export * from "./fold.js";
-export * from "./fold-repository.js";
-export * from "./read-model.js";
-export * from "./accepted-fold-read.js";
-export * from "./history-read.js";
-export * from "./accepted-tail.js";
-export * from "./inventory.js";
-export * from "./inventory-plan.js";
-export * from "./write-transaction.js";
-export * from "./claim-evidence.js";
-export * from "./publication.js";
-export * from "./publication-admission.js";

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

@@ -1,75 +0,0 @@
-import { isCanonicalAbsolute, nonblank, } from "./inventory.js";
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function completeScanPlane(value) {
-    return isRecord(value) && value.complete === true && typeof value.collectorIdentity === "string" && nonblank(value.collectorIdentity);
-}
-function hasObservedRef(rows, authority) {
-    return rows.some((row) => {
-        const observation = row.observation;
-        return observation.kind === "ref" && observation.canonicalRoot === authority.canonicalRoot &&
-            observation.refName === authority.refName && observation.objectFormat === authority.objectFormat &&
-            observation.exactObjectId === authority.exactObjectId;
-    });
-}
-function hasObservedPath(rows, canonicalRoot, absoluteRealpath) {
-    return rows.some((row) => {
-        const observation = row.observation;
-        return observation.kind === "path" && observation.canonicalRoot === canonicalRoot && observation.absoluteRealpath === absoluteRealpath;
-    });
-}
-function manifestIssue(candidate) {
-    if (!isRecord(candidate) || !isRecord(candidate.authority) || !isRecord(candidate.receipt) || !Array.isArray(candidate.rows)) {
-        return "planner requires a typed repository inventory manifest";
-    }
-    const authority = candidate.authority;
-    const receipt = candidate.receipt;
-    const rows = candidate.rows;
-    if (!isCanonicalAbsolute(authority.canonicalRoot) || !nonblank(authority.authoritySnapshotIdentity)) {
-        return "manifest authority lacks a canonical root or snapshot identity";
-    }
-    if (receipt.canonicalRoot !== authority.canonicalRoot || receipt.authoritySnapshotIdentity !== authority.authoritySnapshotIdentity ||
-        !nonblank(receipt.scanIdentity)) {
-        return "manifest receipt does not match the authority root and snapshot identity";
-    }
-    if (!completeScanPlane(receipt.gitRefs) || receipt.gitRefs.unknownFormerKeiyakuNamespacesIncluded !== true ||
-        !completeScanPlane(receipt.registeredWorktrees) || !completeScanPlane(receipt.repositoryRuntimeAndRenderings) ||
-        !completeScanPlane(receipt.projectionRuntimeAndResidue) || !completeScanPlane(receipt.excludedUserDataBoundaries)) {
-        return "manifest receipt does not prove every required repository discovery plane complete";
-    }
-    if (!authority.legacyRefs.every((legacy) => hasObservedRef(rows, legacy))) {
-        return "manifest omits a known legacy ref authority coordinate";
-    }
-    if (!authority.worktrees.every((worktree) => hasObservedPath(rows, worktree.canonicalRoot, worktree.canonicalRealpath))) {
-        return "manifest omits a known registered worktree coordinate";
-    }
-    if (!authority.runtimePaths.every((runtime) => hasObservedPath(rows, runtime.canonicalRoot, runtime.absoluteRealpath))) {
-        return "manifest omits a known repository runtime coordinate";
-    }
-    if (!authority.generatedWorktreeRenderings.every((rendering) => hasObservedPath(rows, rendering.canonicalRoot, rendering.absoluteRealpath))) {
-        return "manifest omits a known generated rendering coordinate";
-    }
-    return null;
-}
-export function planRepositoryMigration(manifest) {
-    const issue = manifestIssue(manifest);
-    if (issue)
-        return { status: "refused", reason: issue, refusals: [], actions: [] };
-    const rows = manifest.rows;
-    const refusals = rows.filter((row) => row.migration.kind === "refuse-preserve" ||
-        ((row.migration.kind === "retire-after-closure-cas" || row.migration.kind === "retire-after-hard-cut") && !row.migration.ready));
-    if (refusals.length > 0)
-        return { status: "refused", refusals, actions: [] };
-    return { status: "ready", actions: rows.filter((row) => row.migration.kind !== "preserve") };
-}
-export function planRepositoryNuke(manifest) {
-    const issue = manifestIssue(manifest);
-    if (issue)
-        return { status: "refused", reason: issue, refusals: [], actions: [] };
-    const rows = manifest.rows;
-    const refusals = rows.filter((row) => row.nuke.kind === "refuse-preserve");
-    if (refusals.length > 0)
-        return { status: "refused", refusals, actions: [] };
-    return { status: "ready", actions: rows.filter((row) => row.nuke.kind !== "preserve") };
-}