@astrosheep/keiyaku 4.0.4 → 4.0.5

package/build/src/git/repository.js

@@ -1,8 +1,7 @@
-import { spawn } from "node:child_process";
 import { isAbsolute, resolve } from "node:path";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { consumeProcessStdout } from "../runtime/proc/run.js";
 import { gitObjectId } from "./identity.js";
+import { GitPlumbingError, runGit, runGitWithEnvironment } from "./process.js";
 import { parseTreeObject, prepareTreeUpdate, treeUpdate, validPath, } from "./tree.js";
 export const GIT_REF = "refs/heads/keiyaku-state";
 export const DELIVERY_REF_NAMESPACE = "refs/heads/keiyaku-delivery";
@@ -25,21 +24,6 @@ export class NoGitWorldError extends Error {
         this.path = path;
     }
 }
-export class GitPlumbingError extends Error {
-    stdout;
-    stderr;
-    status;
-    pid;
-    constructor(input) {
-        super(input.message);
-        this.name = "GitPlumbingError";
-        this.stdout = Buffer.from(input.stdout ?? "");
-        this.stderr = Buffer.from(input.stderr);
-        this.status = input.status;
-        this.pid = input.pid ?? null;
-    }
-}
-const GIT_STDERR_BYTES = 16 * 1024;
 function worktreesFromPorcelain(output) {
     const fields = output.toString("utf8").split("\0");
     const worktrees = [];
@@ -79,12 +63,13 @@ export async function registeredWorktrees(repository) {
 export async function registeredWorktreePaths(repository) {
     return (await registeredWorktrees(repository)).map((worktree) => worktree.path);
 }
-export async function repositoryAt(cwd) {
+export async function repositoryAt(cwd, gitPath = "git") {
     if (typeof cwd !== "string" || cwd.length === 0) {
         throw new Error("repository path must be a nonempty string");
     }
     const effectiveCwd = resolve(cwd);
     const provisional = {
+        gitPath,
         effectiveCwd,
         primaryWorktree: effectiveCwd,
         commonDirectory: effectiveCwd,
@@ -101,7 +86,7 @@ export async function repositoryAt(cwd) {
         }
         throw error;
     }
-    return { effectiveCwd, primaryWorktree, commonDirectory };
+    return { gitPath, effectiveCwd, primaryWorktree, commonDirectory };
 }
 async function absoluteGitPath(repository, args, label) {
     const value = (await runGit(repository, ["rev-parse", "--path-format=absolute", ...args])).toString("utf8").trim();
@@ -119,83 +104,6 @@ export async function worktreeGitDirectory(repository, worktree) {
 export async function worktreeRoot(repository) {
     return await absoluteGitPath(repository, ["--show-toplevel"], "worktree root");
 }
-function commandError(command, error) {
-    const candidate = error;
-    const stderr = candidate.stderr === undefined ? Buffer.alloc(0) : Buffer.from(candidate.stderr);
-    const stdout = candidate.stdout === undefined ? Buffer.alloc(0) : Buffer.from(candidate.stdout);
-    const detail = stderr.length === 0 ? candidate.message ?? "git command failed" : stderr.toString("utf8");
-    return new GitPlumbingError({
-        stdout,
-        stderr,
-        status: candidate.status ?? null,
-        message: `${command.join(" ")}: ${detail}`,
-        pid: candidate.pid ?? null,
-    });
-}
-async function executeGit(repository, args, input, environment) {
-    const stdout = [];
-    const stderr = [];
-    let stderrBytes = 0;
-    let inputError;
-    const child = spawn("git", [...args], {
-        cwd: repository.effectiveCwd,
-        ...(environment === undefined ? {} : { env: { ...process.env, ...environment } }),
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true,
-    });
-    child.stdout.on("data", (chunk) => stdout.push(chunk));
-    child.stderr.on("data", (chunk) => {
-        if (stderrBytes >= GIT_STDERR_BYTES)
-            return;
-        const retained = chunk.subarray(0, GIT_STDERR_BYTES - stderrBytes);
-        stderr.push(retained);
-        stderrBytes += retained.length;
-    });
-    child.stdin.on("error", (error) => { inputError = error; });
-    child.stdin.end(input);
-    const terminal = await new Promise((resolveTerminal) => {
-        child.once("error", (error) => resolveTerminal({ code: null, error }));
-        child.once("close", (code) => resolveTerminal({ code }));
-    });
-    const output = Buffer.concat(stdout);
-    if (terminal.code === 0 && inputError === undefined)
-        return output;
-    throw commandError(args, {
-        message: terminal.error?.message ?? inputError?.message ?? `git exited with status ${terminal.code ?? "unknown"}`,
-        stdout: output,
-        stderr: Buffer.concat(stderr),
-        status: terminal.code,
-        pid: child.pid,
-    });
-}
-export async function runGit(repository, args, input) {
-    return await executeGit(repository, args, input);
-}
-export async function consumeGitStdout(repository, args, consume) {
-    const result = await consumeProcessStdout({
-        argv: ["git", ...args],
-        cwd: repository.effectiveCwd,
-    }, consume);
-    const { outcome } = result;
-    if (outcome.kind === "terminal" && outcome.code === 0)
-        return;
-    const status = outcome.kind === "terminal" ? outcome.code : null;
-    const stderr = outcome.kind === "terminal" ? outcome.stderr : "";
-    const message = outcome.kind === "terminal"
-        ? `git exited with status ${outcome.code}`
-        : outcome.kind === "spawn-error" || outcome.kind === "stream-error"
-            ? outcome.diagnostic
-            : `git process ended with ${outcome.kind}`;
-    throw commandError(args, {
-        message,
-        stderr,
-        status,
-        pid: result.pid ?? undefined,
-    });
-}
-export async function runGitWithEnvironment(repository, args, input, environment) {
-    return await executeGit(repository, args, input, environment);
-}
 function assertOid(oid, label) {
     gitObjectId(oid, label);
 }
@@ -282,28 +190,6 @@ export async function readGitPaths(repository, requestedPaths) {
     await validateGitFormat(repository, paths);
     return { commit, tree, paths };
 }
-/** Add paths from the same immutable Git tree without rereading its ref. */
-export async function extendGitPaths(repository, snapshot, requestedPaths) {
-    for (const path of requestedPaths)
-        validPath(path);
-    if (snapshot.tree === null || requestedPaths.length === 0)
-        return snapshot;
-    const additions = parseTreeEntries(await runGit(repository, [
-        "ls-tree",
-        "-z",
-        "--full-tree",
-        snapshot.tree,
-        "--",
-        ...requestedPaths,
-    ]));
-    return { ...snapshot, paths: new Map([...snapshot.paths, ...additions]) };
-}
-/** Expand a targeted immutable snapshot to its complete already-pinned tree. */
-export async function expandGitSnapshot(repository, snapshot) {
-    if (snapshot.tree === null)
-        return snapshot;
-    return { ...snapshot, paths: await readTreeEntries(repository, snapshot.tree) };
-}
 export async function writeBlob(repository, bytes) {
     const oid = (await runGit(repository, ["hash-object", "-w", "--stdin"], bytes)).toString("utf8").trim();
     assertOid(oid, "written blob");

package/build/src/git/scratch.d.ts

@@ -1,5 +1,5 @@
 import type { SnapshotId } from "../core/facts/types.js";
-import { type GitRepository } from "./repository.js";
+import { type GitRepository } from "./process.js";
 export type MaterializedScratchCandidate = Readonly<{
     cwd: string;
     dispose: () => Promise<WorktreeLeak | null>;

package/build/src/git/scratch.js

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { tryAcquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
 import { gitObjectIdForSnapshot } from "./identity.js";
-import { runGit } from "./repository.js";
+import { runGit } from "./process.js";
 const SCRATCH_PREFIX = "keiyaku-v4-verify-";
 const SCRATCH_ROOT = await realpath(tmpdir());
 const SCRATCH_PATTERN = /^keiyaku-v4-verify-([0-9a-f]{24})$/;

package/build/src/git/target-placement.d.ts

@@ -1,7 +1,7 @@
 import { type HeldSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
 import type { ContractId, ContractState, SnapshotId } from "../core/facts/types.js";
 import type { RefOperation } from "../core/facts/offer.js";
-import { type GitRepository } from "./repository.js";
+import { type GitRepository } from "./process.js";
 export type WorkspaceNotOnTargetRefusal = Readonly<{
     kind: "workspace-not-on-target";
     contractId: ContractId;

package/build/src/git/target-placement.js

@@ -3,7 +3,8 @@ import { resolve } from "node:path";
 import { acquireSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
 import { gitObjectId, gitObjectIdForSnapshot, gitRefLocator, mintSnapshotId } from "./identity.js";
 import { currentBranch } from "./observe.js";
-import { commonGitDirectory, consumeGitStdout, GitPlumbingError, readRef, registeredWorktrees, runGit, } from "./repository.js";
+import { commonGitDirectory, readRef, registeredWorktrees, } from "./repository.js";
+import { consumeGitStdout, GitPlumbingError, runGit, } from "./process.js";
 import { captureWorkspaceTree } from "./workspace.js";
 export async function observeTargetHead(repository, target) {
     const value = await readRef(repository, target);
@@ -254,7 +255,7 @@ export async function adjudicateAuditTarget(repository, input) {
     }
 }
 export async function prepareTargetPlacement(repository, state, target) {
-    if (state.coordinates.target !== target.target || state.delivery?.data.integration.snapshot !== target.newOid) {
+    if (state.coordinates.target !== target.target || state.currentIntegration?.snapshot !== target.newOid) {
         throw new Error("placement state does not match its offered target movement");
     }
     const observation = await observeTargetPlacement(repository, {
@@ -340,10 +341,11 @@ export async function recoverTargetPlacement(repository, state) {
     const delivery = state.delivery;
     if (state.terminal?.kind !== "claimed" || target === undefined || delivery === null)
         return { effects: [], lag: [] };
-    if (await readRef(repository, target) !== delivery.data.integration.snapshot)
+    const integration = state.currentIntegration;
+    if (integration === null || await readRef(repository, target) !== integration.snapshot)
         return { effects: [], lag: [] };
-    const candidateTree = await commitTree(repository, delivery.data.integration.snapshot);
-    const predecessorTree = await commitTree(repository, delivery.data.integration.predecessor);
+    const candidateTree = await commitTree(repository, integration.snapshot);
+    const predecessorTree = await commitTree(repository, integration.predecessor);
     const worktrees = (await registeredWorktrees(repository))
         .filter((worktree) => worktree.branch === target)
         .sort((left, right) => left.path.localeCompare(right.path));
@@ -354,8 +356,8 @@ export async function recoverTargetPlacement(repository, state) {
             const recovery = await recoverCheckout({
                 repository,
                 path: worktree.path,
-                predecessor: delivery.data.integration.predecessor,
-                candidate: delivery.data.integration.snapshot,
+                predecessor: integration.predecessor,
+                candidate: integration.snapshot,
                 predecessorTree,
                 candidateTree,
             });

package/build/src/git/tender.d.ts

@@ -1,7 +1,7 @@
 import type { Preparation } from "../core/decide.js";
 import type { ActorId, ContractCoordinates, ContractId, SnapshotId } from "../core/facts/types.js";
 import { type GitObjectId } from "./identity.js";
-import { type GitRepository } from "./repository.js";
+import { type GitRepository } from "./process.js";
 import { captureWorkspaceTree } from "./workspace.js";
 export type TenderCaptureCoordinates = Readonly<{
     contractId: ContractId;

package/build/src/git/tender.js

@@ -1,6 +1,7 @@
 import { access } from "node:fs/promises";
 import { gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
-import { decodeGitNumstat, GitPlumbingError, registeredWorktreePaths, runGit, runGitWithEnvironment, } from "./repository.js";
+import { decodeGitNumstat, registeredWorktreePaths, } from "./repository.js";
+import { GitPlumbingError, runGit, runGitWithEnvironment, } from "./process.js";
 import { captureWorkspaceTree, worktreePath } from "./workspace.js";
 async function workspaceExists(repository, workspace, path) {
     const exists = await access(path).then(() => true, () => false);

package/build/src/git/terminal-seal.d.ts

@@ -1,6 +1,7 @@
 import type { ContractState, SnapshotId } from "../core/facts/types.js";
 import { type GitObjectId } from "./identity.js";
-import { type GitOid, type GitRepository } from "./repository.js";
+import type { GitOid } from "./repository.js";
+import { type GitRepository } from "./process.js";
 import { captureWorkspaceTree } from "./workspace.js";
 export type UnsealedBytes = Readonly<{
     kind: "unsealed-bytes";
@@ -33,6 +34,5 @@ export type TerminalWorkspaceObservation = Readonly<{
 export declare function terminalSealSnapshots(state: ContractState): readonly SnapshotId[];
 export declare function terminalSealExpectations(state: ContractState, objects: ReadonlyMap<GitOid, TerminalSealObject>): TerminalSealExpectations;
 export declare function unsealedWorkspaceBytes(repository: GitRepository, path: string, expected: TerminalSealExpectations, workspace: WorkspaceTree): Promise<UnsealedBytes | null>;
-export declare function unsealedBytes(repository: GitRepository, path: string, expected: TerminalSealExpectations): Promise<UnsealedBytes | null>;
 export declare function observeTerminalWorkspace(repository: GitRepository, path: string, expected: TerminalSealExpectations): Promise<TerminalWorkspaceObservation>;
 export {};

package/build/src/git/terminal-seal.js

@@ -1,12 +1,12 @@
 import { gitObjectId, gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
-import { runGit } from "./repository.js";
+import { runGit } from "./process.js";
 import { captureWorkspaceTree } from "./workspace.js";
 export function terminalSealSnapshots(state) {
     return [...new Set([
             state.coordinates.start,
             ...(state.delivery === null ? [] : [
                 state.delivery.data.tenderSnapshot,
-                state.delivery.data.integration.snapshot,
+                ...(state.currentIntegration === null ? [] : [state.currentIntegration.snapshot]),
             ]),
         ])];
 }
@@ -51,7 +51,7 @@ export function terminalSealExpectations(state, objects) {
                 state.coordinates.start,
                 ...(tenderParent === undefined ? [] : [tenderParent]),
                 tender,
-                state.delivery.data.integration.snapshot,
+                state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot,
             ])],
         trees: [...treeBySnapshot.values()],
         treeBySnapshot,
@@ -86,9 +86,6 @@ export async function unsealedWorkspaceBytes(repository, path, expected, workspa
         ...(headIsSealed ? {} : { head: workspace.head }),
     };
 }
-export async function unsealedBytes(repository, path, expected) {
-    return (await observeTerminalWorkspace(repository, path, expected)).unsealed;
-}
 export async function observeTerminalWorkspace(repository, path, expected) {
     const captured = await captureWorkspaceTree(repository, path);
     return {

package/build/src/git/workspace.d.ts

@@ -1,6 +1,6 @@
 import type { SnapshotId } from "../core/facts/types.js";
 import { type GitObjectId } from "./identity.js";
-import { type GitRepository } from "./repository.js";
+import { type GitRepository } from "./process.js";
 export type WorkspaceChanges = Readonly<{
     staged: readonly string[];
     unstaged: readonly string[];

package/build/src/git/workspace.js

@@ -2,7 +2,7 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { gitObjectId, mintSnapshotId } from "./identity.js";
-import { runGit, runGitWithEnvironment } from "./repository.js";
+import { runGit, runGitWithEnvironment } from "./process.js";
 const WORKTREE_DIRECTORY = ["keiyaku", "wt"];
 export function worktreePath(repository, place) {
     return resolve(repository.commonDirectory, ...WORKTREE_DIRECTORY, place);

package/build/src/index.d.ts

@@ -1,6 +1,5 @@
-export { AuthorityCorruptionError, AkumaWorldScopeError, Delivery, gatesFrom, Keiyaku, KeiyakuRefused, KeiyakuRetry, NoGitWorldError, Repo, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./library/keiyaku.js";
+export * from "./library/keiyaku.js";
 export { settings } from "./settings.js";
 export { World, WorldError } from "./world.js";
 export type { WorldResolution, WorldResolutionInput, WorldRoot } from "./world.js";
 export type { Settings, SettingsEntry, SettingsInput, SettingsNamespaceFailure, SettingsNamespaceView, SettingsScope, SettingsScopeState, } from "./settings.js";
-export type { AttestationVerdict, AbandonInput, ActorId, AkuId, AllowedAction, AllowedActions, AkumaAddressInput, AkumaAlias, AkumaGlob, AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaObservation, AkumaSetAddressInput, AkumaStatus, AkumaTellInput, CreatedTaskObservation, AkumaTellResult, AkumaWaitInput, AkumaWaitResult, AkumaWorldScopeRefusal, AliasBinding, AliasStage, AmendResult, AmendInput, ArcInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, CallInput, CallObservation, CallResult, Catalog, CatalogInput, CatalogQuery, ChangeId, ContractId, ContractState, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, FactKind, Dispatch, DispatchFailure, DispatchStage, DirectAkumaSelector, Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, ForkInput, ForkResult, IntegrationFailure, Lag, MutationResult, PlacementStop, RegionOverlap, ReconcileInput, RepoReconcileReport, Review, ReconcileReport, ReviewInput, RepoAtInput, AuditInput, SnapshotId, SettlementAction, SettlementLag, SettlementReport, SetAkumaSelector, TaskId, TopologyEffect, VerificationReuse, VerificationStop, WorktreeHooks, } from "./library/keiyaku.js";

package/build/src/index.js

@@ -1,3 +1,3 @@
-export { AuthorityCorruptionError, AkumaWorldScopeError, Delivery, gatesFrom, Keiyaku, KeiyakuRefused, KeiyakuRetry, NoGitWorldError, Repo, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./library/keiyaku.js";
+export * from "./library/keiyaku.js";
 export { settings } from "./settings.js";
 export { World, WorldError } from "./world.js";

package/build/src/library/address.js

@@ -116,7 +116,13 @@ function addSelectorIds(selector, sources, selected, contractMembers) {
     selected.add(selector.value);
 }
 async function contractMemberInWorld(path, id) {
-    return await probeBornAkuma(path, id);
+    try {
+        return await probeBornAkuma(path, id);
+    }
+    catch {
+        // A dispatched physical member remains selected when its Heart cannot be read.
+        return true;
+    }
 }
 async function refuseForeignContractMembers(path, ids, contractMembers) {
     const foreign = [];

package/build/src/library/audit.d.ts

@@ -1,5 +1,6 @@
 import type { ContractId } from "../core/facts/types.js";
-import { type AuditReport, type RepositoryScope } from "../protocol/operations.js";
+import { type AuditReport } from "../protocol/audit.js";
+import type { RepositoryScope } from "../protocol/operations.js";
 import { type WorktreeHooks } from "./configuration.js";
 import { type MutationResult } from "./mutation.js";
 export type AuditInput = Readonly<{

package/build/src/library/audit.js

@@ -1,6 +1,6 @@
 import { decodeContractDocument } from "../body/decode.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
-import { auditOperation, } from "../protocol/operations.js";
+import { auditOperation } from "../protocol/audit.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { actorOption, documentDerivation, optionalBoolean, optionalSignal, requireInput, } from "./input.js";
 import { completeMutation } from "./mutation.js";

package/build/src/library/bind.d.ts

@@ -1,6 +1,7 @@
 import { type ActorId, type ContractId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
-import { bindOperation, type IntentOutcome, type RepositoryScope } from "../protocol/operations.js";
+import { bindOperation } from "../protocol/bind.js";
+import type { IntentOutcome, RepositoryScope } from "../protocol/operations.js";
 import type { TaskId } from "../task/identity.js";
 import type { VerificationDeclarationPreparation } from "../verification/declaration.js";
 import type { KeiyakuRefusal } from "./refusal.js";

package/build/src/library/bind.js

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import { releaseContractWorktree, reserveContractWorktree, withContractWorktreeAppointment, } from "../contract-worktree.js";
 import { contractIdFromSegment } from "../core/facts/types.js";
 import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
-import { bindOperation } from "../protocol/operations.js";
+import { bindOperation } from "../protocol/bind.js";
 import { claimTaskHolder } from "../settlement/holder.js";
 function candidateId(title, collision) {
     const stem = fitIdentityStem({ stem: normalizeIdentityStem({ source: title }) || "contract", maxBytes: 48 });

package/build/src/library/configuration.d.ts

@@ -4,7 +4,7 @@ export type { HookCommand, WorktreeHooks } from "../git/hooks.js";
 export type Gate = string;
 export type GatesFromInput = Readonly<{
     settings: Settings;
-    name?: string;
+    names?: readonly string[];
 }>;
 export type RequireBranchesToBeUpToDateFromInput = Readonly<{
     settings: Settings;

package/build/src/library/configuration.js

@@ -9,31 +9,65 @@ function namespaceFailure(view) {
         throw new Error("settings namespace failure expected");
     throw new SettingsError(view.failures.map((failure) => `${failure.scope}: ${failure.diagnostic}`).join("; "));
 }
+function bundleGates(name, value) {
+    if (!record(value))
+        throw new SettingsError(`gate bundle '${name}' must be an object`);
+    if (value.kind !== "bundle") {
+        throw new SettingsError(`gate bundle '${name}' has unsupported kind: ${String(value.kind)}`);
+    }
+    for (const field of Object.keys(value)) {
+        if (field !== "kind" && field !== "gates") {
+            throw new SettingsError(`gate bundle '${name}' has unknown field: ${field}`);
+        }
+    }
+    if (!Array.isArray(value.gates)) {
+        throw new SettingsError(`gate bundle '${name}'.gates must be an array`);
+    }
+    return value.gates.map((gate) => {
+        if (!gateWord(gate)) {
+            throw new SettingsError(`gate bundle '${name}' contains an invalid gate word`);
+        }
+        if (gate !== "reviewed" && gate !== "verified") {
+            throw new SettingsError(`gate bundle '${name}' contains a gate without a producer: ${gate}`);
+        }
+        return gate;
+    });
+}
 export function gatesFrom(input) {
     if (!record(input))
         throw new TypeError("gatesFrom input must be an object");
-    const name = input.name ?? "default";
-    if (!gateWord(name))
-        throw new SettingsError("gate set name must match ^[a-z][a-z0-9-]{0,63}$");
+    if (input.names !== undefined && !Array.isArray(input.names)) {
+        throw new TypeError("gatesFrom names must be an array");
+    }
+    const names = input.names ?? ["default"];
+    for (const name of names) {
+        if (!gateWord(name))
+            throw new SettingsError("gate bundle name must match ^[a-z][a-z0-9-]{0,63}$");
+    }
     const view = input.settings.namespace("gates");
     if (view.kind === "failed")
         namespaceFailure(view);
-    const selected = view.entries.find((entry) => entry.name === name);
-    if (selected === undefined) {
-        if (input.name === undefined)
-            return Object.freeze([]);
-        throw new SettingsError(`unknown gate set: ${name}`);
+    const expanded = [];
+    const seen = new Set();
+    for (const name of names) {
+        const selected = view.entries.find((entry) => entry.name === name);
+        if (selected === undefined) {
+            if (input.names === undefined) {
+                if (!seen.has("reviewed"))
+                    expanded.push("reviewed");
+                seen.add("reviewed");
+                continue;
+            }
+            throw new SettingsError(`unknown gate bundle: ${name}`);
+        }
+        for (const gate of bundleGates(name, selected.value)) {
+            if (seen.has(gate))
+                continue;
+            seen.add(gate);
+            expanded.push(gate);
+        }
     }
-    if (!Array.isArray(selected.value))
-        throw new SettingsError(`gate set '${name}' must be an array`);
-    const values = selected.value.map((value) => {
-        if (!gateWord(value))
-            throw new SettingsError(`gate set '${name}' contains an invalid gate word`);
-        return value;
-    });
-    if (new Set(values).size !== values.length)
-        throw new SettingsError(`gate set '${name}' contains duplicate gates`);
-    return Object.freeze(values);
+    return Object.freeze(expanded);
 }
 function command(value, coordinate, ErrorType) {
     if (!record(value))

package/build/src/library/contract.d.ts

@@ -3,7 +3,13 @@ import { type RegionObservation, type RegionOverlap } from "./region.js";
 import { type Gate, type WorktreeHooks } from "./configuration.js";
 import { type ChangeId, type ContractId, type ContractState, type JournalEntry, type SnapshotId } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { type AuditReport, type ContractBoard, type ContractDisposition, type ContractGateCurrent, type ContractGateReport, type ContractObservation, type ContractPhase, type ContractRow, type FactKind, type PlacementStop, type ReconcileReport as ProtocolReconcileReport, type RepositoryScope, type ReviewValue, type VerificationReuse, type VerificationStop, type DeliveryPreparationRefusal } from "../protocol/operations.js";
+import { type PlacementStop, type RepositoryScope, type VerificationStop, type DeliveryPreparationRefusal } from "../protocol/operations.js";
+import type { ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow } from "../protocol/read/status.js";
+import type { AuditReport } from "../protocol/audit.js";
+import { type DeliverValue, type VerificationReuse } from "../protocol/deliver.js";
+import type { ReconcileReport as ProtocolReconcileReport } from "../protocol/reconcile.js";
+import { type ReviewValue } from "../protocol/review.js";
+import type { FactKind } from "../core/facts/types.js";
 import { type Dispatch } from "../dispatch/index.js";
 import { type SettlementReport } from "../settlement/settle.js";
 import { type TaskId } from "../task/identity.js";
@@ -11,7 +17,10 @@ import { Repo, type ReconcileInput } from "./repo.js";
 import { type AuditInput } from "./audit.js";
 import { Delivery } from "./delivery.js";
 import { type MutationResult } from "./mutation.js";
-export { KeiyakuRefused, KeiyakuRetry, type ContractAppointmentRefusal, type KeiyakuRefusal, type KeiyakuRetryReason, } from "./refusal.js";
+import { KeiyakuRetry, type KeiyakuRefusal, type KeiyakuRetryReason } from "./refusal.js";
+export { KeiyakuRefused, type ContractAppointmentRefusal, } from "./refusal.js";
+export { KeiyakuRetry };
+export type { KeiyakuRefusal, KeiyakuRetryReason };
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
 export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks } from "./configuration.js";
 export type { AuditReport, DeliveryPreparationRefusal, ChangeId, ContractId, ContractState, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow, FactKind, SnapshotId, };
@@ -103,7 +112,51 @@ export type DeliverInput = ActorOptions & Readonly<{
     includeDirty?: boolean;
     signal?: AbortSignal;
 }>;
+type ForwardedDeliveryReceipt = Readonly<{
+    kind: "accepted";
+    result: MutationResult<DeliverValue>;
+}> | Readonly<{
+    kind: "refused";
+    refusal: KeiyakuRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: KeiyakuRetryReason;
+}>;
+type ForwardedReviewReceipt = Readonly<{
+    kind: "accepted";
+    result: MutationResult<ReviewValue>;
+}> | Readonly<{
+    kind: "refused";
+    refusal: KeiyakuRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: KeiyakuRetryReason;
+}>;
 export type { AuditInput };
+export declare function executeForwardedDeliver(input: Readonly<{
+    repo: Repo;
+    contractId: string;
+    requester: string;
+    message?: string;
+    includeDirty: boolean;
+    requireBranchesToBeUpToDate: boolean;
+    hooks: WorktreeHooks;
+    signal?: AbortSignal;
+}>): Promise<Readonly<{
+    result: ForwardedDeliveryReceipt;
+    deliveryFactId?: string;
+}>>;
+export declare function executeForwardedReview(input: Readonly<{
+    repo: Repo;
+    contractId: string;
+    requester: string;
+    verdict: AttestationVerdict;
+    summary?: string;
+    hooks: WorktreeHooks;
+}>): Promise<Readonly<{
+    result: ForwardedReviewReceipt;
+    reviewFactId?: string;
+}>>;
 export declare class KeiyakuHandle {
     private readonly id;
     private readonly scope;