@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/registry.js

@@ -1,100 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { createGit, wrapGitError } from "../git/core.js";
-import { patternsOverlap, scopePathEvidence } from "./scope.js";
-import { readRepositoryLifecycle } from "./repository-ledger/read-model.js";
-export const SCOPE_OVERLAP_PATH_PREVIEW_LIMIT = 10;
-function activeRegistrations(read) {
-    return read.contracts
-        .filter((model) => !["claimed", "forfeited"].includes(model.phase))
-        .map((model) => ({ contract: model.contract, scope: [...model.effectiveScope] }));
-}
-async function trackedRepositoryPaths(cwd, tree) {
-    try {
-        return (await createGit(cwd).raw(["ls-tree", "-r", "-z", "--name-only", tree]))
-            .split("\0")
-            .filter(Boolean)
-            .sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-    }
-    catch (error) {
-        throw wrapGitError(`ls-tree ${tree}`, error, cwd);
-    }
-}
-async function scopeRegistrationAdmission(cwd, input, read, trackedPaths) {
-    const nextOverlaps = [];
-    const active = activeRegistrations(read);
-    for (const existing of active) {
-        if (existing.contract === input.contractId)
-            continue;
-        const [nextEvidence, existingEvidence] = await Promise.all([
-            scopePathEvidence(cwd, input.scope, trackedPaths),
-            scopePathEvidence(cwd, existing.scope, trackedPaths),
-        ]);
-        const existingByPath = new Map(existingEvidence.map((evidence) => [evidence.path, evidence]));
-        const concreteByPatterns = new Map();
-        for (const next of nextEvidence) {
-            const prior = existingByPath.get(next.path);
-            if (!next.matched || !prior?.matched || !next.decisivePattern || !prior.decisivePattern)
-                continue;
-            const key = `${next.decisivePattern.index}:${prior.decisivePattern.index}`;
-            const group = concreteByPatterns.get(key) ?? {
-                next: next.decisivePattern.pattern,
-                existing: prior.decisivePattern.pattern,
-                paths: [],
-            };
-            group.paths.push(next.path);
-            concreteByPatterns.set(key, group);
-        }
-        for (const concrete of concreteByPatterns.values()) {
-            const preview = concrete.paths.slice(0, SCOPE_OVERLAP_PATH_PREVIEW_LIMIT);
-            nextOverlaps.push({
-                contracts: [input.contractId, existing.contract],
-                patterns: [concrete.next, concrete.existing],
-                kind: "concrete",
-                paths: {
-                    preview,
-                    count: concrete.paths.length,
-                    truncated: preview.length < concrete.paths.length,
-                },
-            });
-        }
-        for (const nextPattern of input.scope) {
-            for (const existingPattern of existing.scope) {
-                if (patternsOverlap(nextPattern, existingPattern)) {
-                    const [nextPatternEvidence, existingPatternEvidence] = await Promise.all([
-                        scopePathEvidence(cwd, [nextPattern], trackedPaths),
-                        scopePathEvidence(cwd, [existingPattern], trackedPaths),
-                    ]);
-                    const existingPatternByPath = new Map(existingPatternEvidence.map((evidence) => [evidence.path, evidence]));
-                    const hasCurrentWitness = nextPatternEvidence.some((evidence) => (evidence.matched && existingPatternByPath.get(evidence.path)?.matched));
-                    if (!hasCurrentWitness) {
-                        nextOverlaps.push({
-                            contracts: [input.contractId, existing.contract],
-                            patterns: [nextPattern, existingPattern],
-                            kind: "potential",
-                            paths: { preview: [], count: 0, truncated: false },
-                        });
-                    }
-                }
-            }
-        }
-    }
-    return nextOverlaps;
-}
-function refuseExclusiveOverlap(contractId, overlaps) {
-    const occupants = [...new Set(overlaps.map((overlap) => overlap.contracts[1]))].sort();
-    throw new FlowError("INVALID_TARGET", `exclusive bind ${contractId} overlaps active contract${occupants.length === 1 ? "" : "s"}: ${occupants.join(", ")}`);
-}
-/** Bind admission against one immutable repository fold and candidate Git tree. */
-export async function admitScopeRegistration(cwd, input, read) {
-    const overlaps = await scopeRegistrationAdmission(cwd, input, read, await trackedRepositoryPaths(cwd, input.tree));
-    if (input.exclusive && overlaps.length > 0)
-        refuseExclusiveOverlap(input.contractId, overlaps);
-    return overlaps;
-}
-/** Read-only preview observes the repository once and shares mutation admission. */
-export async function previewScopeRegistration(cwd, input) {
-    return await admitScopeRegistration(cwd, input, await readRepositoryLifecycle(cwd));
-}
-export function bindScope(entry) {
-    return entry.data.scope;
-}

package/build/core/renew-build.js

@@ -1,554 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { assertHostObjectId, deriveHostGitCoordinates, readCommitObject } from "./repository-ledger/git-object-store.js";
-import { runGitProcess, runGitProcessBytes } from "../git/core.js";
-import { stableRepoRoot } from "./worktree-path.js";
-const SCRATCH_VERSION = 3;
-const SCRATCH_DIRECTORY = path.join("keiyaku", "renew-scratch");
-const SCRATCH_STATE_FILE = "state.json";
-const SCRATCH_FILES_DIRECTORY = "files";
-const SCRATCH_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-export class RenewBuildError extends Error {
-    code;
-    constructor(code, message, options) {
-        super(message, options);
-        this.code = code;
-        this.name = "RenewBuildError";
-    }
-}
-export function assertScratchName(scratchName) {
-    if (!SCRATCH_NAME_PATTERN.test(scratchName)) {
-        throw new RenewBuildError("INVALID_SCRATCH_NAME", `invalid renew scratch name ${JSON.stringify(scratchName)}`);
-    }
-}
-export function scratchPaths(scratchBase, scratchName) {
-    assertScratchName(scratchName);
-    const root = path.join(scratchBase, scratchName);
-    return {
-        root,
-        state: path.join(root, SCRATCH_STATE_FILE),
-        files: path.join(root, SCRATCH_FILES_DIRECTORY),
-    };
-}
-export async function renewScratchBase(cwd) {
-    const commonDirectory = (await successfulGit(cwd, [
-        "rev-parse",
-        "--path-format=absolute",
-        "--git-common-dir",
-    ])).trim();
-    if (!path.isAbsolute(commonDirectory)) {
-        throw new RenewBuildError("GIT_RENEW_BUILD_FAILED", `Git common directory is not absolute: ${commonDirectory}`);
-    }
-    return path.join(await fs.realpath(commonDirectory), SCRATCH_DIRECTORY);
-}
-function gitFailure(args, detail, cause) {
-    return new RenewBuildError("GIT_RENEW_BUILD_FAILED", `git ${args.join(" ")} failed: ${detail}`, cause ? { cause } : undefined);
-}
-export async function successfulGit(cwd, args, options) {
-    const result = await runGitProcess(cwd, args, options);
-    if (result.status !== 0 || result.error) {
-        throw gitFailure(args, result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`, result.error);
-    }
-    return result.stdout;
-}
-export async function assertTree(cwd, coordinates, tree) {
-    assertHostObjectId(coordinates, tree);
-    const result = await runGitProcess(cwd, ["cat-file", "-t", tree]);
-    if (result.status !== 0 || result.error || result.stdout.trim() !== "tree") {
-        throw new RenewBuildError("INVALID_RENEW_RESOLUTION", `renew resolution ${tree} is not a tree`, {
-            cause: result.error,
-        });
-    }
-}
-function parseIdentity(header, label, objectId) {
-    const value = header.slice(label.length + 1);
-    const emailEnd = value.lastIndexOf("> ");
-    const emailStart = emailEnd < 0 ? -1 : value.lastIndexOf(" <", emailEnd);
-    if (emailStart <= 0 || emailEnd <= emailStart || !/^\d+ [+-]\d{4}$/.test(value.slice(emailEnd + 2))) {
-        throw new RenewBuildError("INVALID_DELIVERY_CHAIN", `commit ${objectId} has an invalid ${label} header`);
-    }
-    return {
-        name: value.slice(0, emailStart),
-        email: value.slice(emailStart + 2, emailEnd),
-        date: value.slice(emailEnd + 2),
-    };
-}
-async function readOriginalCommit(cwd, coordinates, objectId, expectedParent) {
-    const commit = await readCommitObject(cwd, coordinates, objectId);
-    if (commit.parents.length !== 1 || commit.parents[0] !== expectedParent) {
-        throw new RenewBuildError("INVALID_DELIVERY_CHAIN", `delivery commit ${objectId} must have exactly parent ${expectedParent}`);
-    }
-    const raw = await successfulGit(cwd, ["cat-file", "commit", objectId]);
-    const headers = raw.slice(0, raw.indexOf("\n\n")).split("\n");
-    const authorRows = headers.filter((row) => row.startsWith("author "));
-    const committerRows = headers.filter((row) => row.startsWith("committer "));
-    if (authorRows.length !== 1 || committerRows.length !== 1) {
-        throw new RenewBuildError("INVALID_DELIVERY_CHAIN", `commit ${objectId} has invalid identity headers`);
-    }
-    return {
-        objectId,
-        parent: expectedParent,
-        message: commit.messageBytes,
-        author: parseIdentity(authorRows[0], "author", objectId),
-        committer: parseIdentity(committerRows[0], "committer", objectId),
-    };
-}
-export async function validateCoordinates(input) {
-    for (const coordinate of [input.oldBase, input.oldHead, input.newBase]) {
-        assertHostObjectId(input.coordinates, coordinate);
-        await readCommitObject(input.cwd, input.coordinates, coordinate);
-    }
-    if (input.deliveryCommits.length === 0) {
-        if (input.oldHead !== input.oldBase) {
-            throw new RenewBuildError("INVALID_DELIVERY_CHAIN", "an empty delivery chain requires oldHead to equal oldBase");
-        }
-        return [];
-    }
-    if (input.deliveryCommits.at(-1) !== input.oldHead) {
-        throw new RenewBuildError("INVALID_DELIVERY_CHAIN", "the delivery chain must terminate at oldHead");
-    }
-    const commits = [];
-    let parent = input.oldBase;
-    for (const objectId of input.deliveryCommits) {
-        assertHostObjectId(input.coordinates, objectId);
-        const commit = await readOriginalCommit(input.cwd, input.coordinates, objectId, parent);
-        commits.push(commit);
-        parent = objectId;
-    }
-    return commits;
-}
-async function mergeCommitTree(input) {
-    const args = [
-        "--no-replace-objects",
-        "merge-tree",
-        "--write-tree",
-        `--merge-base=${input.original.parent}`,
-        input.currentHead,
-        input.original.objectId,
-    ];
-    const result = await runGitProcess(input.cwd, args);
-    if (result.error || (result.status !== 0 && result.status !== 1)) {
-        throw gitFailure(args, result.stderr.trim() || result.error?.message || `exit ${String(result.status)}`, result.error);
-    }
-    const lines = result.stdout.split(/\r?\n/);
-    const tree = lines[0]?.trim() ?? "";
-    assertHostObjectId(input.coordinates, tree);
-    await assertTree(input.cwd, input.coordinates, tree);
-    if (result.status === 0)
-        return { status: "clean", tree };
-    const index = lines.flatMap((line) => {
-        const match = /^(\d{6}) ([0-9a-f]+) ([123])\t(.+)$/.exec(line);
-        return match ? [{ mode: match[1], objectId: match[2], stage: Number(match[3]), path: match[4] }] : [];
-    });
-    const paths = Array.from(new Set(index.map((entry) => entry.path)));
-    return { status: "conflict", tree, paths, index };
-}
-/** Replay a resolved delivery tree from its captured target onto a later target. */
-export async function replayResolvedDelivery(input) {
-    for (const commit of [input.capturedTarget, input.latestTarget]) {
-        assertHostObjectId(input.coordinates, commit);
-        await readCommitObject(input.cwd, input.coordinates, commit);
-    }
-    const resolvedCommit = await buildCommit(input.cwd, input.coordinates, input.identity, input.resolvedTree, input.capturedTarget);
-    const replay = await mergeCommitTree({
-        cwd: input.cwd,
-        coordinates: input.coordinates,
-        original: {
-            ...input.identity,
-            objectId: resolvedCommit,
-            parent: input.capturedTarget,
-        },
-        currentHead: input.latestTarget,
-    });
-    return { ...replay, resolvedCommit };
-}
-export async function buildCommit(cwd, coordinates, original, tree, parent) {
-    await assertTree(cwd, coordinates, tree);
-    const args = ["commit-tree", tree, "-p", parent];
-    const result = await runGitProcessBytes(cwd, args, {
-        input: original.message,
-        env: {
-            GIT_AUTHOR_NAME: original.author.name,
-            GIT_AUTHOR_EMAIL: original.author.email,
-            GIT_AUTHOR_DATE: original.author.date,
-            GIT_COMMITTER_NAME: original.committer.name,
-            GIT_COMMITTER_EMAIL: original.committer.email,
-            GIT_COMMITTER_DATE: original.committer.date,
-        },
-    });
-    if (result.status !== 0 || result.error) {
-        throw gitFailure(args, result.stderr.toString("utf8").trim() || result.error?.message || `exit ${String(result.status)}`, result.error);
-    }
-    const objectId = result.stdout.toString("utf8").trim();
-    assertHostObjectId(coordinates, objectId);
-    return objectId;
-}
-export function interrupted(signal) {
-    if (signal?.aborted) {
-        throw new RenewBuildError("RENEW_BUILD_INTERRUPTED", "detached renew build was interrupted", {
-            cause: signal.reason instanceof Error ? signal.reason : undefined,
-        });
-    }
-}
-async function materializeConflict(cwd, scratch, state, create) {
-    if (create) {
-        await successfulGit(cwd, ["worktree", "add", "--detach", scratch.files, state.currentHead]);
-    }
-    else {
-        await validateScratchWorktree(cwd, scratch, state, { requireRecordedHead: false });
-        await successfulGit(scratch.files, ["reset", "--hard", state.currentHead]);
-        await successfulGit(scratch.files, ["clean", "-ffdx"]);
-    }
-    await successfulGit(scratch.files, ["read-tree", "--reset", "-u", state.conflictTree]);
-    await successfulGit(scratch.files, [
-        "update-index",
-        "--force-remove",
-        "--",
-        ...Array.from(new Set(state.conflictIndex.map((entry) => entry.path))),
-    ]);
-    await successfulGit(scratch.files, ["update-index", "--index-info"], { input: state.conflictIndex.map((entry) => `${entry.mode} ${entry.objectId} ${entry.stage}\t${entry.path}\n`).join("") });
-}
-async function scratchCommonDirectory(cwd) {
-    const commonDirectory = (await successfulGit(cwd, [
-        "rev-parse",
-        "--path-format=absolute",
-        "--git-common-dir",
-    ])).trim();
-    return await fs.realpath(commonDirectory);
-}
-async function validateScratchWorktree(cwd, scratch, state, options) {
-    let filesPath;
-    try {
-        filesPath = await fs.realpath(scratch.files);
-    }
-    catch (error) {
-        throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} has no linked worktree`, { cause: error });
-    }
-    try {
-        const [topLevel, commonDirectory] = await Promise.all([
-            successfulGit(filesPath, ["rev-parse", "--show-toplevel"]),
-            scratchCommonDirectory(filesPath),
-        ]);
-        if (path.resolve(topLevel.trim()) !== filesPath || commonDirectory !== await scratchCommonDirectory(cwd)) {
-            throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} is not the recorded linked worktree`);
-        }
-        const symbolicHead = await runGitProcess(filesPath, ["symbolic-ref", "-q", "HEAD"]);
-        if (symbolicHead.status === 0 || symbolicHead.status !== 1 || symbolicHead.error) {
-            throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} must retain a detached HEAD`);
-        }
-        if (options.requireRecordedHead) {
-            const head = (await successfulGit(filesPath, ["rev-parse", "HEAD"])).trim();
-            if (head !== state.currentHead) {
-                throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} HEAD no longer matches the recorded replay head`);
-            }
-        }
-    }
-    catch (error) {
-        if (error instanceof RenewBuildError)
-            throw error;
-        throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} has invalid linked worktree metadata`, { cause: error });
-    }
-}
-async function writeScratchState(scratch, state) {
-    const temporary = `${scratch.state}.next`;
-    await fs.rm(temporary, { force: true });
-    await fs.writeFile(temporary, `${JSON.stringify(state, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
-    await fs.rename(temporary, scratch.state);
-}
-async function hasRegisteredScratchWorktree(cwd, scratch) {
-    const worktrees = await successfulGit(cwd, ["worktree", "list", "--porcelain", "-z"]);
-    const expected = path.resolve(scratch.files);
-    return worktrees.split("\0").some((field) => field.startsWith("worktree ") && path.resolve(field.slice("worktree ".length)) === expected);
-}
-async function scratchRootExists(scratch) {
-    try {
-        await fs.lstat(scratch.root);
-        return true;
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return false;
-        throw error;
-    }
-}
-/** Remove only the deterministic scratch root and its exact Git registration. */
-export async function cleanupRenewScratch(input) {
-    const [registered, rootExists] = await Promise.all([
-        hasRegisteredScratchWorktree(input.cwd, input.scratch),
-        scratchRootExists(input.scratch),
-    ]);
-    if (!registered && !rootExists)
-        return { status: "absent" };
-    if (registered) {
-        await successfulGit(input.cwd, ["worktree", "remove", "--force", input.scratch.files]);
-    }
-    await fs.rm(input.scratch.root, { recursive: true, force: true });
-    return { status: "deleted" };
-}
-export function evidenceResult(state) {
-    return {
-        observedLedgerHead: state.observedLedgerHead,
-        lifecycleHead: state.lifecycleHead,
-        deliveryRef: state.deliveryRef,
-        targetRef: state.targetRef,
-        effectiveScope: [...state.effectiveScope],
-        oldBase: state.oldBase,
-        oldHead: state.oldHead,
-        newBase: state.newBase,
-        deliveryCommits: [...state.deliveryCommits],
-        evidenceMap: { ...state.evidenceMap },
-    };
-}
-export async function persistConflict(cwd, scratchBase, state, create) {
-    const scratch = scratchPaths(scratchBase, state.scratchName);
-    let previous;
-    if (create) {
-        await fs.mkdir(path.dirname(scratch.root), { recursive: true });
-        try {
-            await fs.mkdir(scratch.root);
-        }
-        catch (error) {
-            if (error.code === "EEXIST") {
-                throw new RenewBuildError("RENEW_SCRATCH_EXISTS", `renew scratch ${state.scratchName} already exists`, { cause: error });
-            }
-            throw error;
-        }
-    }
-    else {
-        previous = await readScratchState(scratch);
-    }
-    try {
-        await materializeConflict(cwd, scratch, state, create);
-        await writeScratchState(scratch, state);
-    }
-    catch (error) {
-        if (create) {
-            await cleanupRenewScratch({ cwd, scratch });
-        }
-        else if (previous) {
-            try {
-                await materializeConflict(cwd, scratch, previous, false);
-            }
-            catch (restoreError) {
-                throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${state.scratchName} could not restore its prior conflict state`, { cause: restoreError instanceof Error ? restoreError : undefined });
-            }
-        }
-        throw error;
-    }
-    return {
-        status: "conflict",
-        ...evidenceResult(state),
-        scratchName: state.scratchName,
-        scratchPath: scratch.root,
-        filesPath: scratch.files,
-        conflictCommit: state.conflictCommit,
-        conflictPaths: [...state.conflictPaths],
-    };
-}
-export async function replayFrom(input) {
-    let currentHead = input.state.currentHead;
-    for (let index = input.state.nextIndex; index < input.commits.length; index += 1) {
-        interrupted(input.signal);
-        const original = input.commits[index];
-        const merged = await mergeCommitTree({
-            cwd: input.cwd,
-            coordinates: input.coordinates,
-            original,
-            currentHead,
-        });
-        if (merged.status === "conflict") {
-            const state = {
-                ...input.state,
-                nextIndex: index,
-                currentHead,
-                conflictCommit: original.objectId,
-                conflictTree: merged.tree,
-                conflictPaths: merged.paths,
-                conflictIndex: merged.index,
-            };
-            return await persistConflict(input.cwd, input.scratchBase, state, input.createScratch);
-        }
-        currentHead = await buildCommit(input.cwd, input.coordinates, original, merged.tree, currentHead);
-        input.state.evidenceMap[original.objectId] = currentHead;
-        input.state.currentHead = currentHead;
-        input.state.nextIndex = index + 1;
-    }
-    interrupted(input.signal);
-    return {
-        status: "clean",
-        ...evidenceResult(input.state),
-        newHead: currentHead,
-    };
-}
-export async function buildDetachedRenewChain(input) {
-    assertScratchName(input.scratchName);
-    const repositoryRoot = await stableRepoRoot(input.cwd);
-    const scratchBase = await renewScratchBase(repositoryRoot);
-    const coordinates = await deriveHostGitCoordinates(repositoryRoot);
-    const commits = await validateCoordinates({ ...input, cwd: repositoryRoot, coordinates });
-    const existingScratch = scratchPaths(scratchBase, input.scratchName);
-    const hasExistingScratch = await Promise.all([
-        scratchRootExists(existingScratch),
-        hasRegisteredScratchWorktree(repositoryRoot, existingScratch),
-    ]).then(([rootExists, registered]) => rootExists || registered);
-    if (hasExistingScratch) {
-        let state;
-        try {
-            state = await readScratchState(existingScratch);
-        }
-        catch (error) {
-            if (!(error instanceof RenewBuildError)
-                || (error.code !== "RENEW_SCRATCH_NOT_FOUND" && error.code !== "INVALID_RENEW_SCRATCH")) {
-                throw error;
-            }
-            await cleanupRenewScratch({ cwd: repositoryRoot, scratch: existingScratch });
-        }
-        if (state) {
-            if (state.observedLedgerHead !== input.observedLedgerHead
-                || state.lifecycleHead !== input.lifecycleHead
-                || state.deliveryRef !== input.deliveryRef
-                || state.targetRef !== input.targetRef
-                || state.oldBase !== input.oldBase
-                || state.oldHead !== input.oldHead
-                || state.newBase !== input.newBase
-                || JSON.stringify(state.effectiveScope) !== JSON.stringify(input.effectiveScope)
-                || JSON.stringify(state.deliveryCommits) !== JSON.stringify(input.deliveryCommits)) {
-                await cleanupRenewScratch({ cwd: repositoryRoot, scratch: existingScratch });
-            }
-            else {
-                await validateScratchProgress(repositoryRoot, coordinates, state, commits);
-                await validateScratchWorktree(repositoryRoot, existingScratch, state, { requireRecordedHead: true });
-                return {
-                    status: "conflict",
-                    ...evidenceResult(state),
-                    scratchName: state.scratchName,
-                    scratchPath: existingScratch.root,
-                    filesPath: existingScratch.files,
-                    conflictCommit: state.conflictCommit,
-                    conflictPaths: [...state.conflictPaths],
-                };
-            }
-        }
-    }
-    const state = {
-        version: SCRATCH_VERSION,
-        scratchName: input.scratchName,
-        observedLedgerHead: input.observedLedgerHead,
-        lifecycleHead: input.lifecycleHead,
-        deliveryRef: input.deliveryRef,
-        targetRef: input.targetRef,
-        effectiveScope: [...input.effectiveScope],
-        oldBase: input.oldBase,
-        oldHead: input.oldHead,
-        newBase: input.newBase,
-        deliveryCommits: [...input.deliveryCommits],
-        evidenceMap: {},
-        nextIndex: 0,
-        currentHead: input.newBase,
-        conflictCommit: "",
-        conflictTree: "",
-        conflictPaths: [],
-        conflictIndex: [],
-    };
-    return await replayFrom({
-        cwd: repositoryRoot,
-        scratchBase,
-        coordinates,
-        state,
-        commits,
-        createScratch: true,
-        signal: input.signal,
-    });
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export async function readScratchState(scratch) {
-    let parsed;
-    try {
-        parsed = JSON.parse(await fs.readFile(scratch.state, "utf8"));
-    }
-    catch (error) {
-        if (error.code === "ENOENT") {
-            throw new RenewBuildError("RENEW_SCRATCH_NOT_FOUND", `renew scratch ${path.basename(scratch.root)} was not found`, { cause: error });
-        }
-        throw new RenewBuildError("INVALID_RENEW_SCRATCH", `cannot read renew scratch ${path.basename(scratch.root)}`, { cause: error });
-    }
-    if (!isRecord(parsed)
-        || parsed.version !== SCRATCH_VERSION
-        || parsed.scratchName !== path.basename(scratch.root)
-        || typeof parsed.observedLedgerHead !== "string"
-        || typeof parsed.lifecycleHead !== "string"
-        || typeof parsed.deliveryRef !== "string"
-        || typeof parsed.targetRef !== "string"
-        || !Array.isArray(parsed.effectiveScope)
-        || parsed.effectiveScope.some((value) => typeof value !== "string")
-        || typeof parsed.oldBase !== "string"
-        || typeof parsed.oldHead !== "string"
-        || typeof parsed.newBase !== "string"
-        || !Array.isArray(parsed.deliveryCommits)
-        || parsed.deliveryCommits.some((value) => typeof value !== "string")
-        || !isRecord(parsed.evidenceMap)
-        || Object.values(parsed.evidenceMap).some((value) => typeof value !== "string")
-        || !Number.isSafeInteger(parsed.nextIndex)
-        || typeof parsed.currentHead !== "string"
-        || typeof parsed.conflictCommit !== "string"
-        || typeof parsed.conflictTree !== "string"
-        || !Array.isArray(parsed.conflictPaths)
-        || parsed.conflictPaths.some((value) => typeof value !== "string")
-        || !Array.isArray(parsed.conflictIndex)
-        || parsed.conflictIndex.some((entry) => !isRecord(entry)
-            || !/^\d{6}$/.test(String(entry.mode))
-            || !/^[0-9a-f]+$/.test(String(entry.objectId))
-            || ![1, 2, 3].includes(entry.stage)
-            || typeof entry.path !== "string")) {
-        throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch ${path.basename(scratch.root)} has invalid state`);
-    }
-    return parsed;
-}
-export async function treeFromScratchFiles(cwd, coordinates, scratch, state) {
-    await validateScratchWorktree(cwd, scratch, state, { requireRecordedHead: true });
-    const indexPath = (await successfulGit(scratch.files, [
-        "rev-parse",
-        "--path-format=absolute",
-        "--git-path",
-        "index",
-    ])).trim();
-    const temporaryDirectory = await fs.mkdtemp(path.join(scratch.root, "tree-index-"));
-    const temporaryIndex = path.join(temporaryDirectory, "index");
-    try {
-        // Candidate construction must not stage or otherwise alter the retryable scratch.
-        await fs.copyFile(indexPath, temporaryIndex);
-        const env = { ...process.env, GIT_INDEX_FILE: temporaryIndex };
-        await successfulGit(scratch.files, ["add", "--all", "--", "."], { env });
-        const tree = (await successfulGit(scratch.files, ["write-tree"], { env })).trim();
-        await assertTree(cwd, coordinates, tree);
-        return tree;
-    }
-    finally {
-        await fs.rm(temporaryDirectory, { recursive: true, force: true });
-    }
-}
-export async function validateScratchProgress(cwd, coordinates, state, commits) {
-    if (state.nextIndex < 0 || state.nextIndex >= commits.length || commits[state.nextIndex]?.objectId !== state.conflictCommit) {
-        throw new RenewBuildError("INVALID_RENEW_SCRATCH", "renew scratch does not identify the stopped delivery commit");
-    }
-    if (state.conflictPaths.length === 0 || state.conflictIndex.length === 0) {
-        throw new RenewBuildError("INVALID_RENEW_SCRATCH", "renew scratch has no captured conflict index");
-    }
-    let parent = state.newBase;
-    for (let index = 0; index < state.nextIndex; index += 1) {
-        const original = commits[index].objectId;
-        const rewritten = state.evidenceMap[original];
-        if (!rewritten)
-            throw new RenewBuildError("INVALID_RENEW_SCRATCH", `renew scratch is missing evidence for ${original}`);
-        const commit = await readCommitObject(cwd, coordinates, rewritten);
-        if (commit.parents.length !== 1 || commit.parents[0] !== parent) {
-            throw new RenewBuildError("INVALID_RENEW_SCRATCH", `rewritten commit ${rewritten} is not attached to its scratch predecessor`);
-        }
-        parent = rewritten;
-    }
-    if (parent !== state.currentHead || Object.keys(state.evidenceMap).length !== state.nextIndex) {
-        throw new RenewBuildError("INVALID_RENEW_SCRATCH", "renew scratch evidence does not match its stopped head");
-    }
-}