@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/library/contract-handle.js

@@ -1,385 +0,0 @@
-/** @architectureCompositionRoot */
-import { documentDiff } from "../markdown/diff.js";
-import { startContractExecution } from "./execution.js";
-import { applyAmendDocument } from "../body/amend.js";
-import { decodeArcDocument } from "../body/arc.js";
-import { decodeContractDocument } from "../body/decode.js";
-import { renderContractGuidance } from "../contract-guidance.js";
-import { actorOption, contractTerms, documentDerivation, normalizedGates, normalizedList, optionalBoolean, optionalNonblank, optionalSignal, invalidInput, requireInput, requireMarkdown, } from "./input.js";
-import { observeChangedRegion } from "./region.js";
-import { worktreeHooksOption } from "./configuration.js";
-import { contractId } from "../core/facts/types.js";
-import { contractObservationOperation, deliveryDiffOperation, deliveryOperation, stateOperation, } from "../protocol/operations.js";
-import { abandonOperation } from "../protocol/abandon.js";
-import { amendOperation } from "../protocol/amend.js";
-import { arcOperation } from "../protocol/arc.js";
-import { readDispatchesAt } from "../dispatch/index.js";
-import { mintSnapshotId } from "../git/identity.js";
-import { observeContractsForAdmissionInObservationAt } from "../git/observe.js";
-import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
-import { releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection } from "../settlement/holder.js";
-import { reconcileInput } from "./repo.js";
-import { executionChannel, localExecutionContext } from "../akuma/requests.js";
-import { auditContract } from "./audit.js";
-import { deliveryHandle } from "./delivery.js";
-import { completionInput, completeHolderMutation, completeMutation } from "./mutation.js";
-import { completeReconcile } from "./reconcile.js";
-import { executeLocalDelivery, executeLocalReview, requestForwardedContractLive, } from "./contract-operations.js";
-import { KeiyakuRefused, requireAccepted } from "./refusal.js";
-import { composeContractLibrary } from "./composition.js";
-const KEIYAKU_HANDLE = Symbol("Keiyaku handle");
-export class Keiyaku {
-    id;
-    scope;
-    execution;
-    composition;
-    static with(input) {
-        return composeContractLibrary(input, createKeiyakuHandle);
-    }
-    constructor(token, id, scope, execution = localExecutionContext(), composition) {
-        this.id = id;
-        this.scope = scope;
-        this.execution = execution;
-        this.composition = composition;
-        if (token !== KEIYAKU_HANDLE)
-            throw new TypeError("Keiyaku handles are created by Keiyaku.with");
-        KEIYAKU_SEATS.set(this, { id, scope });
-        Object.freeze(this);
-    }
-    async state() {
-        return withGitDecodeChannel(this.scope, (channel) => stateOperation({
-            scope: this.scope,
-            channel,
-            contractId: this.id,
-        }));
-    }
-    async history() {
-        return withGitDecodeChannel(this.scope, (channel) => withGitReadObservation(this.scope, channel, async (observation) => {
-            const [journals, dispatches] = await Promise.all([
-                observeContractsForAdmissionInObservationAt(observation, [this.id]),
-                readDispatchesAt(observation),
-            ]);
-            const record = journals.journals.get(this.id);
-            if (record === undefined)
-                throw new Error(`missing requested contract observation: ${this.id}`);
-            if (record.state === null)
-                throw new KeiyakuRefused({ kind: "contract-missing", contractId: this.id });
-            const commit = observation.snapshot.commit;
-            if (commit === null)
-                throw new Error("contract history requires a keiyaku-state snapshot");
-            const recordedAt = (event) => event.source === "journal" ? event.fact.at : event.dispatch.dispatchedAt;
-            const events = [
-                ...record.entries.map((fact) => ({ source: "journal", fact })),
-                ...dispatches
-                    .filter((dispatch) => dispatch.contractId === this.id)
-                    .map((dispatch) => ({ source: "dispatch", dispatch })),
-            ].sort((left, right) => {
-                const leftAt = recordedAt(left);
-                const rightAt = recordedAt(right);
-                if (leftAt !== rightAt)
-                    return leftAt < rightAt ? -1 : 1;
-                if (left.source !== right.source)
-                    return left.source === "journal" ? -1 : 1;
-                return 0;
-            });
-            return { id: this.id, state: mintSnapshotId(commit), events };
-        }));
-    }
-    async guidance() {
-        return withGitDecodeChannel(this.scope, async (channel) => {
-            const observed = await contractObservationOperation({ scope: this.scope, channel, contractId: this.id });
-            if (observed.kind === "missing")
-                throw new KeiyakuRefused({ kind: "contract-missing", contractId: this.id });
-            return renderContractGuidance(await stateOperation({ scope: this.scope, channel, contractId: this.id }));
-        });
-    }
-    async delivery() {
-        const delivery = await withGitDecodeChannel(this.scope, (channel) => deliveryOperation({
-            scope: this.scope,
-            channel,
-            contractId: this.id,
-        }));
-        return delivery === null ? null : this.deliveryHandle(delivery);
-    }
-    async amend(input) {
-        const values = requireInput(input, "amend input");
-        const hooks = worktreeHooksOption(values.hooks);
-        const markdown = values.markdown === undefined ? undefined : requireMarkdown(values.markdown);
-        const actor = actorOption(values.actor);
-        const gates = values.gates === undefined ? undefined : normalizedGates(values.gates);
-        const prerequisites = values.after === undefined ? undefined : normalizedList(values.after, "after", contractId);
-        if (markdown === undefined && gates === undefined && prerequisites === undefined) {
-            return invalidInput("amend requires markdown, after, or gates");
-        }
-        const amendment = await withGitDecodeChannel(this.scope, async (channel) => {
-            let changedSections;
-            const accepted = requireAccepted(await amendOperation({
-                scope: this.scope,
-                channel,
-                contractId: this.id,
-                ...actor,
-                deriveAmendment: (source) => {
-                    const amendment = markdown === undefined
-                        ? undefined
-                        : applyAmendDocument(markdown, decodeContractDocument(source.document.bytes));
-                    changedSections = amendment?.changedSections;
-                    const document = amendment === undefined
-                        ? decodeContractDocument(source.document.bytes)
-                        : decodeContractDocument(amendment.document);
-                    const terms = markdown === undefined
-                        ? {
-                            document: source.document,
-                            segments: source.segments,
-                            gates: gates ?? source.gates,
-                            after: prerequisites ?? source.after,
-                        }
-                        : contractTerms(document, gates ?? source.gates, prerequisites ?? source.after);
-                    return {
-                        terms,
-                        verification: documentDerivation(document, terms.gates, this.id).verification,
-                    };
-                },
-            }));
-            const completed = await completeMutation({
-                ...completionInput({
-                    operation: "amend",
-                    scope: this.scope,
-                    channel,
-                    contractId: this.id,
-                    value: () => undefined,
-                    hooks,
-                }),
-                accepted,
-            });
-            return {
-                completed,
-                document: decodeContractDocument(accepted.value.terms.document.bytes),
-                changedSections,
-                documentDiff: documentDiff("before", "after", accepted.value.source.document.bytes, accepted.value.terms.document.bytes),
-            };
-        });
-        const regionObservation = await observeChangedRegion(this.scope, this.id, amendment.changedSections, amendment.document.region);
-        return {
-            ...amendment.completed,
-            documentDiff: amendment.documentDiff,
-            ...regionObservation,
-        };
-    }
-    startDelivery(input) {
-        return startContractExecution((observe) => this.runDelivery(input, observe));
-    }
-    async deliver(input) {
-        return this.startDelivery(input).result;
-    }
-    async runDelivery(input, observe) {
-        const values = input === undefined
-            ? undefined
-            : requireInput(input, "deliver input", [
-                "message",
-                "includeDirty",
-                "materializeConflict",
-                "overwrite",
-                "signal",
-            ]);
-        const message = optionalNonblank(values?.message, "deliver message");
-        const includeDirty = optionalBoolean(values?.includeDirty, "includeDirty") ?? false;
-        const materializeConflict = optionalBoolean(values?.materializeConflict, "materializeConflict") ?? false;
-        const overwrite = optionalBoolean(values?.overwrite, "overwrite") ?? false;
-        const signal = optionalSignal(values?.signal);
-        const channel = executionChannel(this.execution);
-        const result = channel.kind === "local"
-            ? await executeLocalDelivery({
-                scope: this.scope,
-                contractId: this.id,
-                ...(this.composition.actor === undefined ? {} : { actor: this.composition.actor }),
-                ...(message === undefined ? {} : { message }),
-                requireBranchesToBeUpToDate: this.composition.requireBranchesToBeUpToDate,
-                includeDirty,
-                materializeConflict,
-                overwrite,
-                ...(signal === undefined ? {} : { signal }),
-                hooks: this.composition.hooks,
-                observe,
-            })
-            : await requestForwardedContractLive({
-                directory: channel.directory,
-                action: "contract.deliver",
-                observe,
-                request: {
-                    action: "contract.deliver",
-                    repoRoot: this.scope.primaryWorktree,
-                    contractId: this.id,
-                    ...(message === undefined ? {} : { message }),
-                    includeDirty,
-                    materializeConflict,
-                    overwrite,
-                },
-                ...(signal === undefined ? {} : { signal }),
-            });
-        return "facts" in result ? { ...result, value: this.deliveryHandle(result.value) } : result;
-    }
-    startReview(input) {
-        return startContractExecution((observe) => this.runReview(input, observe));
-    }
-    async review(input) {
-        return this.startReview(input).result;
-    }
-    async runReview(input, observe) {
-        const values = requireInput(input, "review input", ["verdict", "summary", "signal"]);
-        const verdict = values.verdict;
-        if (verdict !== "satisfied" && verdict !== "unsatisfied") {
-            return invalidInput("verdict must be satisfied or unsatisfied");
-        }
-        const summary = optionalNonblank(values.summary, "review summary");
-        const signal = optionalSignal(values.signal);
-        const channel = executionChannel(this.execution);
-        if (channel.kind === "body-request") {
-            return await requestForwardedContractLive({
-                directory: channel.directory,
-                action: "contract.review",
-                observe,
-                ...(signal === undefined ? {} : { signal }),
-                request: {
-                    action: "contract.review",
-                    repoRoot: this.scope.primaryWorktree,
-                    contractId: this.id,
-                    verdict,
-                    ...(summary === undefined ? {} : { summary }),
-                },
-            });
-        }
-        return await executeLocalReview({
-            scope: this.scope,
-            contractId: this.id,
-            ...(this.composition.actor === undefined ? {} : { actor: this.composition.actor }),
-            verdict,
-            ...(summary === undefined ? {} : { summary }),
-            hooks: this.composition.hooks,
-            observe,
-            ...(signal === undefined ? {} : { signal }),
-        });
-    }
-    async abandon(input) {
-        const values = input === undefined ? undefined : requireInput(input, "abandon input");
-        const hooks = worktreeHooksOption(values?.hooks);
-        const note = optionalNonblank(values?.note, "abandon note");
-        return withGitDecodeChannel(this.scope, async (channel) => {
-            const admission = await releaseTaskHolderWithFence(this.scope, channel, this.id, () => abandonOperation({
-                scope: this.scope,
-                channel,
-                contractId: this.id,
-                ...actorOption(values?.actor),
-                ...(note === undefined ? {} : { note }),
-                observationSelection: taskHolderObservationSelection(),
-                decorateOffer: async ({ observation, contractId: owner }) => {
-                    const companion = await releaseTaskHolder(channel, observation, owner);
-                    return companion === null ? [] : [companion];
-                },
-            }));
-            return completeHolderMutation({
-                completion: completionInput({
-                    operation: "abandon",
-                    scope: this.scope,
-                    channel,
-                    contractId: this.id,
-                    value: () => undefined,
-                    hooks,
-                }),
-                admission,
-                requireAccepted,
-            });
-        });
-    }
-    async arc(input) {
-        const values = requireInput(input, "arc input");
-        const hooks = worktreeHooksOption(values.hooks);
-        const chapter = decodeArcDocument(requireMarkdown(values.markdown));
-        return withGitDecodeChannel(this.scope, async (channel) => {
-            const accepted = requireAccepted(await arcOperation({
-                scope: this.scope,
-                channel,
-                contractId: this.id,
-                ...actorOption(values.actor),
-                chapter,
-            }));
-            return completeMutation({
-                ...completionInput({
-                    operation: "arc",
-                    scope: this.scope,
-                    channel,
-                    contractId: this.id,
-                    value: () => undefined,
-                    hooks,
-                }),
-                accepted,
-            });
-        });
-    }
-    startAudit(input) {
-        return startContractExecution((observe) => this.runAudit(input, observe));
-    }
-    async audit(input) {
-        return this.startAudit(input).result;
-    }
-    async runAudit(input, observe) {
-        const values = input === undefined ? undefined : requireInput(input, "audit input", ["includeDirty", "showDiff", "signal"]);
-        const includeDirty = optionalBoolean(values?.includeDirty, "includeDirty") ?? false;
-        const showDiff = optionalBoolean(values?.showDiff, "showDiff") ?? false;
-        const signal = optionalSignal(values?.signal);
-        const auditInput = {
-            includeDirty,
-            showDiff,
-            ...(signal === undefined ? {} : { signal }),
-        };
-        const channel = executionChannel(this.execution);
-        if (channel.kind === "body-request") {
-            return await requestForwardedContractLive({
-                directory: channel.directory,
-                action: "contract.audit",
-                observe,
-                request: {
-                    action: "contract.audit",
-                    repoRoot: this.scope.primaryWorktree,
-                    contractId: this.id,
-                    includeDirty,
-                    showDiff,
-                },
-                ...(signal === undefined ? {} : { signal }),
-            });
-        }
-        return auditContract({
-            scope: this.scope,
-            contractId: this.id,
-            input: auditInput,
-            composition: this.composition,
-            observe,
-        });
-    }
-    async reconcile(input) {
-        const options = reconcileInput(input);
-        return withGitDecodeChannel(this.scope, (channel) => completeReconcile({
-            scope: this.scope,
-            channel,
-            contractId: this.id,
-            ...options,
-        }));
-    }
-    deliveryHandle(delivery) {
-        return deliveryHandle(delivery, () => deliveryDiffOperation({
-            scope: this.scope,
-            integrationPredecessor: delivery.integration.predecessor,
-            integrationSnapshot: delivery.integration.snapshot,
-        }));
-    }
-}
-const KEIYAKU_SEATS = new WeakMap();
-/** Internal constructor capability; callers select a Contract through Keiyaku.with. */
-export function createKeiyakuHandle(id, scope, execution, composition) {
-    return new Keiyaku(KEIYAKU_HANDLE, id, scope, execution, composition);
-}
-/** Internal package composition capability; not exported from the package root. */
-export function seatForKeiyaku(value) {
-    return value !== null && (typeof value === "object" || typeof value === "function")
-        ? (KEIYAKU_SEATS.get(value) ?? null)
-        : null;
-}

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

@@ -1,46 +0,0 @@
-import { actorOption } from "./input.js";
-import { worktreeHooksOption } from "./configuration.js";
-import type { RegionOverlap } from "./region.js";
-import { type ChangeId, type FactKind, type ContractId, type ContractState, type SnapshotId } from "../core/facts/types.js";
-export { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { type PlacementStop, type VerificationStop, type DeliveryPreparationRefusal } from "../protocol/operations.js";
-import type { ContractBoard, ContractCatalogue, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow, AfterEndpointObservation, ContractAfterEdge, ContractDependent, ContractWorkspaceObservation } from "../protocol/read/status.js";
-import type { AuditReport } from "../protocol/audit.js";
-import type { IntegrationConflictMaterialized, VerificationReuse } from "../protocol/deliver.js";
-import type { TaskId } from "../task/identity.js";
-import { type Repo } from "./repo.js";
-import { type ExecutionContext } from "../akuma/requests.js";
-import type { AuditInput } from "./audit.js";
-import { Delivery } from "./delivery.js";
-import { type ContinuationReport } from "./continuation.js";
-import type { MutationResult } from "./mutation.js";
-export { projectMutationFinality } from "./mutation.js";
-export type { MutationFinality, MutationFinalityInput, MutationFinalitySurface, MutationPendingSurface, } from "./mutation.js";
-import type { Keiyaku, createKeiyakuHandle } from "./contract-handle.js";
-import type { AbandonInput, AmendInput, AmendResult, ArcInput, BindInput, BindResult, ContractList, ContractListInput, ContractObservationInput, DeliverInput, ForkBindInput, KeiyakuSelectInput, LocalContractComposition, MarkdownBindInput, ReconcileReport, ReviewInput, ContractHistory, ContractHistoryEvent, Fact, Lag, TopologyEffect } from "./contract-types.js";
-import type { AttestationVerdict as OperationAttestationVerdict, Review as OperationReview } from "./contract-operations.js";
-import { KeiyakuRetry, type KeiyakuRefusal, type KeiyakuRetryReason } from "./refusal.js";
-export { KeiyakuRefused } from "./refusal.js";
-export { KeiyakuRetry, type KeiyakuRefusal, type KeiyakuRetryReason };
-export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
-export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
-export type { AbandonInput, AmendInput, AmendResult, ArcInput, AuditInput, AuditReport, ChangeId, ContinuationReport, ContractBoard, ContractCatalogue, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractAfterEdge, ContractId, ContractHistory, ContractHistoryEvent, ContractDependent, ContractObservation, ContractPhase, ContractRow, ContractState, ContractWorkspaceObservation, BindInput, BindResult, ContractList, ContractListInput, ContractObservationInput, DeliverInput, ForkBindInput, KeiyakuSelectInput, MarkdownBindInput, ReconcileReport, ReviewInput, DeliveryPreparationRefusal, Fact, FactKind, IntegrationConflictMaterialized, Lag, LocalContractComposition, MutationResult, PlacementStop, RegionOverlap, SnapshotId, TaskId, TopologyEffect, VerificationReuse, VerificationStop, };
-export type { AfterEndpointObservation };
-export type ActorId = string;
-export type AttestationVerdict = OperationAttestationVerdict;
-export type Review = OperationReview;
-export { Delivery };
-export type { SettlementAction, SettlementLag, SettlementReport } from "../settlement/settle.js";
-export type LocalContractCompositionCapture = Readonly<{
-    actor?: NonNullable<ReturnType<typeof actorOption>["actor"]>;
-    hooks: ReturnType<typeof worktreeHooksOption>;
-    requireBranchesToBeUpToDate: boolean;
-}>;
-type KeiyakuHandleFactory = typeof createKeiyakuHandle;
-export declare function captureLocalContractComposition(input?: LocalContractComposition): LocalContractCompositionCapture;
-export declare function selectKeiyaku(input: KeiyakuSelectInput, createHandle: KeiyakuHandleFactory, execution?: ExecutionContext, composition?: LocalContractCompositionCapture): Keiyaku;
-export declare function listCompleteContractBoard(repo: Repo): Promise<ContractBoard>;
-export declare function listKeiyaku(input: ContractListInput): Promise<ContractList>;
-export declare function observeKeiyaku(input: ContractObservationInput): Promise<ContractObservation>;
-export declare function bindKeiyaku(input: BindInput, createHandle: KeiyakuHandleFactory, execution?: ExecutionContext, composition?: LocalContractCompositionCapture): Promise<BindResult>;
-export { parseMarkdownBindDocument } from "./contract-bind.js";

package/build/src/library/contract.js

@@ -1,73 +0,0 @@
-// Contract composition depends only on construction and observation.
-import { actorOption, optionalBoolean, requireInput } from "./input.js";
-import { worktreeHooksOption } from "./configuration.js";
-import { contractId, } from "../core/facts/types.js";
-export { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { contractCatalogueOperation, contractObservationOperation, contractsOperation, } from "../protocol/operations.js";
-import { withGitDecodeChannel } from "../git/read-observation.js";
-import { scopeForRepo } from "./repo.js";
-import { localExecutionContext } from "../akuma/requests.js";
-import { Delivery } from "./delivery.js";
-export { projectMutationFinality } from "./mutation.js";
-import { bindKeiyaku as bindKeiyakuImplementation } from "./contract-bind.js";
-import { KeiyakuRetry } from "./refusal.js";
-export { KeiyakuRefused } from "./refusal.js";
-export { KeiyakuRetry };
-export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
-export { Delivery };
-export function captureLocalContractComposition(input) {
-    const values = requireInput(input ?? {}, "Keiyaku.with input", ["actor", "hooks", "requireBranchesToBeUpToDate"]);
-    const actor = actorOption(values.actor).actor;
-    return Object.freeze({
-        ...(actor === undefined ? {} : { actor }),
-        hooks: worktreeHooksOption(values.hooks),
-        requireBranchesToBeUpToDate: optionalBoolean(values.requireBranchesToBeUpToDate, "Keiyaku.with requireBranchesToBeUpToDate") ?? false,
-    });
-}
-export function selectKeiyaku(input, createHandle, execution = localExecutionContext(), composition = captureLocalContractComposition()) {
-    const values = requireInput(input, "Keiyaku.with().select input");
-    const scope = scopeForRepo(values.repo);
-    if (typeof values.id !== "string")
-        throw new TypeError("contract ID must be a string");
-    return createHandle(contractId(values.id), scope, execution, composition);
-}
-export async function listCompleteContractBoard(repo) {
-    const scope = scopeForRepo(repo);
-    return withGitDecodeChannel(scope, (channel) => contractsOperation({ scope, channel }));
-}
-export async function listKeiyaku(input) {
-    const values = requireInput(input, "Keiyaku.with().list input");
-    for (const key of Object.keys(values)) {
-        if (key !== "repo" && key !== "limit")
-            throw new TypeError(`Keiyaku.with().list input has unknown field: ${key}`);
-    }
-    const scope = scopeForRepo(values.repo);
-    if (values.limit === undefined) {
-        const board = await withGitDecodeChannel(scope, (channel) => contractsOperation({ scope, channel }));
-        return { ...board, hasMore: false };
-    }
-    if (typeof values.limit !== "number")
-        throw new TypeError("Contract list limit must be a number");
-    return withGitDecodeChannel(scope, (channel) => contractCatalogueOperation({ scope, channel, limit: values.limit }));
-}
-export async function observeKeiyaku(input) {
-    const values = requireInput(input, "Keiyaku.observe input");
-    for (const key of Object.keys(values))
-        if (key !== "repo" && key !== "id")
-            throw new TypeError(`Keiyaku.observe input has unknown field: ${key}`);
-    const scope = scopeForRepo(values.repo);
-    if (typeof values.id !== "string")
-        throw new TypeError("contract ID must be a string");
-    let id;
-    try {
-        id = contractId(values.id);
-    }
-    catch (error) {
-        throw new TypeError(error instanceof Error ? error.message : "contract ID is invalid");
-    }
-    return withGitDecodeChannel(scope, (channel) => contractObservationOperation({ scope, channel, contractId: id }));
-}
-export async function bindKeiyaku(input, createHandle, execution = localExecutionContext(), composition = captureLocalContractComposition()) {
-    return bindKeiyakuImplementation(input, (id, scope) => createHandle(id, scope, execution, composition));
-}
-export { parseMarkdownBindDocument } from "./contract-bind.js";