@astrosheep/keiyaku 2.9.12 → 4.0.0

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

@@ -0,0 +1,145 @@
+import { type RegionObservation, type RegionOverlap } from "./region.js";
+import { type Gate, type WorktreeHooks } from "./configuration.js";
+import { type ChangeId, type ContractHead, 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 DeliverValue, type FactKind, type IntentRefusal, type IntentRetry, type PlacementStop, type ReconcileReport as ProtocolReconcileReport, type RepositoryScope, type ReviewValue, type TimelineEntry, type VerificationStop } from "../protocol/operations.js";
+import { type SettlementReport } from "../settlement/settle.js";
+import { type TaskHolder } from "../settlement/holder.js";
+import { type TaskId } from "../task/identity.js";
+import { Repo, type ReconcileInput } from "./repo.js";
+export { gatesFrom, SettingsError, worktreeHooksFrom } from "./configuration.js";
+export type { Gate, GatesFromInput, HookCommand, WorktreeHooks, WorktreeHooksFromInput } from "./configuration.js";
+export type { AuditReport, ChangeId, ContractId, ContractState, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow, FactKind, SnapshotId, TimelineEntry, };
+export type { TaskId };
+export type { RegionOverlap };
+export type Fact = JournalEntry;
+export type ActorId = string;
+export type AttestationVerdict = "satisfied" | "unsatisfied";
+export type Review = ReviewValue;
+export type KeiyakuRefusal = IntentRefusal;
+export type KeiyakuRetryReason = IntentRetry;
+export type { PlacementStop, VerificationStop };
+export type TopologyEffect = ProtocolReconcileReport["effects"][number];
+export type Lag = ProtocolReconcileReport["lag"][number];
+export type MutationResult<Value> = Readonly<{
+    facts: readonly Fact[];
+    head: ContractHead;
+    value: Value;
+    effects: readonly TopologyEffect[];
+    lags: readonly Lag[];
+    settlement: SettlementReport;
+}>;
+export type BindResult = Readonly<Omit<MutationResult<Keiyaku>, "value"> & {
+    keiyaku: Keiyaku;
+} & RegionObservation>;
+export type AmendResult = Readonly<MutationResult<void> & RegionObservation & {
+    documentDiff: string;
+}>;
+export type ReconcileReport = Readonly<ProtocolReconcileReport & {
+    settlement: SettlementReport;
+}>;
+export type { SettlementAction, SettlementLag, SettlementReport } from "../settlement/settle.js";
+export declare class KeiyakuRefused extends Error {
+    readonly refusal: KeiyakuRefusal;
+    constructor(refusal: KeiyakuRefusal);
+    get code(): KeiyakuRefusal["kind"];
+}
+export declare class KeiyakuRetry extends Error {
+    readonly reason: KeiyakuRetryReason;
+    constructor(reason: KeiyakuRetryReason);
+    get code(): KeiyakuRetryReason["kind"];
+}
+export type BindInput = Readonly<{
+    repo: Repo;
+    markdown: string;
+    task?: TaskId;
+    target?: string;
+    workspace?: "worktree" | "here";
+    actor?: ActorId;
+    after?: readonly ContractId[];
+    gates?: readonly Gate[];
+    hooks?: WorktreeHooks;
+}>;
+export type AmendInput = Readonly<{
+    markdown: string;
+    actor?: ActorId;
+    after?: readonly ContractId[];
+    gates?: readonly Gate[];
+    hooks?: WorktreeHooks;
+}>;
+export type ArcInput = Readonly<{
+    markdown: string;
+    actor?: ActorId;
+    hooks?: WorktreeHooks;
+}>;
+type HookOptions = Readonly<{
+    hooks?: WorktreeHooks;
+}>;
+type ActorOptions = Readonly<{
+    actor?: ActorId;
+}> & HookOptions;
+export type ContractListInput = Readonly<{
+    repo: Repo;
+}>;
+export type ContractObservationInput = Readonly<{
+    repo: Repo;
+    id: ContractId;
+}>;
+export type KeiyakuOfInput = Readonly<{
+    repo: Repo;
+    id: ContractId;
+}>;
+export type ReviewInput = ActorOptions & Readonly<{
+    verdict: AttestationVerdict;
+    summary?: string;
+}>;
+export type AbandonInput = ActorOptions & Readonly<{
+    note?: string;
+}>;
+export type DeliverInput = ActorOptions & Readonly<{
+    message?: string;
+}>;
+export type AuditInput = ActorOptions;
+declare class DeliveryHandle {
+    readonly snapshotId: SnapshotId;
+    readonly changeId: ChangeId;
+    readonly expectedPredecessor: SnapshotId;
+    private readonly readDiff;
+    readonly verification?: DeliverValue["verification"];
+    readonly placement?: DeliverValue["placement"];
+    readonly leak?: DeliverValue["leak"];
+    constructor(snapshotId: SnapshotId, changeId: ChangeId, expectedPredecessor: SnapshotId, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliverValue, "verification" | "placement" | "leak">>);
+    diff(): Promise<string | null>;
+}
+export type Delivery = DeliveryHandle;
+export declare const Delivery: Readonly<{
+    prototype: DeliveryHandle;
+    [Symbol.hasInstance](value: unknown): boolean;
+}>;
+export declare class KeiyakuHandle {
+    private readonly id;
+    private readonly scope;
+    constructor(id: ContractId, scope: RepositoryScope);
+    state(): Promise<ContractState>;
+    delivery(): Promise<Delivery | null>;
+    amend(input: AmendInput): Promise<AmendResult>;
+    deliver(input?: DeliverInput): Promise<MutationResult<Delivery>>;
+    review(input: ReviewInput): Promise<MutationResult<Review>>;
+    abandon(input?: AbandonInput): Promise<MutationResult<void>>;
+    arc(input: ArcInput): Promise<MutationResult<void>>;
+    audit(input?: AuditInput): Promise<MutationResult<AuditReport>>;
+    reconcile(input?: ReconcileInput): Promise<ReconcileReport>;
+    private deliveryHandle;
+}
+/** Internal package composition capability; not exported from the package root. */
+export declare function seatForKeiyaku(value: unknown): Readonly<{
+    id: ContractId;
+    scope: RepositoryScope;
+}>;
+export type Keiyaku = KeiyakuHandle;
+export declare function keiyakuOf(input: KeiyakuOfInput): Keiyaku;
+export declare function listKeiyaku(input: ContractListInput): Promise<ContractBoard>;
+export declare function observeKeiyaku(input: ContractObservationInput): Promise<ContractObservation>;
+export declare function bindKeiyaku(input: BindInput): Promise<BindResult>;
+/** Internal package composition read used by Kanshi; not a package-root export. */
+export declare function taskHoldersForRepo(repo: Repo): readonly TaskHolder[];

package/build/src/library/contract.js

@@ -0,0 +1,325 @@
+import { documentDiff } from "../markdown/diff.js";
+import { applyAmendDocument } from "../body/amend.js";
+import { decodeArcDocument } from "../body/arc.js";
+import { decodeContractDocument } from "../body/decode.js";
+import { actorOption, contractTerms, documentDerivation, normalizedGates, normalizedList, optionalNonblank, requireInput, requireMarkdown, } from "./input.js";
+import { observeRegion } from "./region.js";
+import { worktreeHooksOption, } from "./configuration.js";
+import { contractId, } from "../core/facts/types.js";
+export { AuthorityCorruptionError } from "../core/facts/errors.js";
+import { abandonOperation, amendOperation, arcOperation, auditOperation, bindOperation, contractObservationOperation, contractsOperation, deliveryDiffOperation, deliverOperation, deliveryOperation, readStateOperation, reconcileOperation, reviewOperation, stateOperation, } from "../protocol/operations.js";
+import { settle } from "../settlement/settle.js";
+import { claimTaskHolder, readTaskHolders, releaseTaskHolder } from "../settlement/holder.js";
+import { parseTaskId } from "../task/identity.js";
+import { reconcileInput, scopeForRepo } from "./repo.js";
+export { gatesFrom, SettingsError, worktreeHooksFrom } from "./configuration.js";
+export class KeiyakuRefused extends Error {
+    refusal;
+    constructor(refusal) {
+        super(`Keiyaku refused: ${refusal.kind}`);
+        this.refusal = refusal;
+        this.name = "KeiyakuRefused";
+    }
+    get code() {
+        return this.refusal.kind;
+    }
+}
+export class KeiyakuRetry extends Error {
+    reason;
+    constructor(reason) {
+        super(reason.kind === "publication-failed" ? reason.diagnostic : `Keiyaku retry required: ${reason.kind}`);
+        this.reason = reason;
+        this.name = "KeiyakuRetry";
+    }
+    get code() {
+        return this.reason.kind;
+    }
+}
+function requireAccepted(result) {
+    if (result.kind === "refused")
+        throw new KeiyakuRefused(result.refusal);
+    if (result.kind === "retry")
+        throw new KeiyakuRetry(result.reason);
+    return result;
+}
+function taskOption(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw new TypeError("task must be a TaskId");
+    try {
+        parseTaskId(value);
+    }
+    catch (error) {
+        throw new TypeError(error instanceof Error ? error.message : "task must be a TaskId");
+    }
+    return value;
+}
+async function mutationResult(scope, id, accepted, value, hooks) {
+    const reconciled = await reconcileOperation({ scope, contractId: id, hooks, retryHooks: false });
+    const settlement = await settle({ repository: scope, state: reconciled.state, effects: reconciled.report.effects });
+    return {
+        facts: accepted.facts,
+        head: accepted.head,
+        value: value(accepted.value),
+        effects: reconciled.report.effects,
+        lags: reconciled.report.lag,
+        settlement,
+    };
+}
+class DeliveryHandle {
+    snapshotId;
+    changeId;
+    expectedPredecessor;
+    readDiff;
+    constructor(snapshotId, changeId, expectedPredecessor, readDiff, outcomes = {}) {
+        this.snapshotId = snapshotId;
+        this.changeId = changeId;
+        this.expectedPredecessor = expectedPredecessor;
+        this.readDiff = readDiff;
+        Object.assign(this, outcomes);
+    }
+    diff() {
+        return this.readDiff();
+    }
+}
+function handleType(prototype, hasInstance) {
+    return Object.freeze({ prototype, [Symbol.hasInstance]: hasInstance });
+}
+export const Delivery = handleType(DeliveryHandle.prototype, (value) => value instanceof DeliveryHandle);
+export class KeiyakuHandle {
+    id;
+    scope;
+    constructor(id, scope) {
+        this.id = id;
+        this.scope = scope;
+        KEIYAKU_SEATS.set(this, { id, scope });
+    }
+    async state() {
+        return stateOperation({ scope: this.scope, contractId: this.id });
+    }
+    async delivery() {
+        const delivery = deliveryOperation({ scope: this.scope, 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 = 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);
+        const current = readStateOperation({ scope: this.scope, contractId: this.id });
+        let document;
+        let terms;
+        let verification;
+        if (current !== null) {
+            const before = current.terms.document.bytes;
+            const currentDocument = decodeContractDocument(before);
+            document = decodeContractDocument(applyAmendDocument(markdown, currentDocument));
+            terms = contractTerms(document, gates ?? current.terms.gates, prerequisites ?? current.terms.after);
+            verification = documentDerivation(document, terms.gates, this.id).verification;
+        }
+        const accepted = requireAccepted(amendOperation({
+            scope: this.scope,
+            contractId: this.id,
+            ...actor,
+            ...(current === null || terms === undefined || verification === undefined
+                ? {}
+                : { amendment: { source: current.terms, terms, verification } }),
+        }));
+        if (document === undefined || current === null) {
+            throw new Error("accepted amendment is missing its document derivation");
+        }
+        const before = current.terms.document.bytes;
+        const after = document.document.bytes;
+        return {
+            ...await mutationResult(this.scope, this.id, accepted, () => undefined, hooks),
+            documentDiff: documentDiff("before", "after", before, after),
+            ...observeRegion(this.scope, this.id, document.region),
+        };
+    }
+    async deliver(input) {
+        const values = input === undefined ? undefined : requireInput(input, "deliver input");
+        const hooks = worktreeHooksOption(values?.hooks);
+        const message = optionalNonblank(values?.message, "deliver message");
+        const actor = actorOption(values?.actor);
+        const state = readStateOperation({ scope: this.scope, contractId: this.id });
+        const derivation = state === null
+            ? undefined
+            : documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id);
+        const accepted = requireAccepted(await deliverOperation({
+            scope: this.scope,
+            contractId: this.id,
+            ...(derivation === undefined ? {} : { derivation }),
+            ...actor,
+            ...(message === undefined ? {} : { message }),
+        }));
+        return mutationResult(this.scope, this.id, accepted, (delivery) => this.deliveryHandle(delivery), hooks);
+    }
+    async review(input) {
+        const values = requireInput(input, "review input");
+        const hooks = worktreeHooksOption(values.hooks);
+        const verdict = values.verdict;
+        if (verdict !== "satisfied" && verdict !== "unsatisfied") {
+            throw new TypeError("verdict must be satisfied or unsatisfied");
+        }
+        const summary = optionalNonblank(values.summary, "review summary");
+        const accepted = requireAccepted(reviewOperation({
+            scope: this.scope,
+            contractId: this.id,
+            verdict,
+            ...(summary === undefined ? {} : { summary }),
+            ...actorOption(values.actor),
+        }));
+        return mutationResult(this.scope, this.id, accepted, (value) => value, hooks);
+    }
+    async abandon(input) {
+        const values = input === undefined ? undefined : requireInput(input, "abandon input");
+        const hooks = worktreeHooksOption(values?.hooks);
+        const note = optionalNonblank(values?.note, "abandon note");
+        const accepted = requireAccepted(abandonOperation({
+            scope: this.scope,
+            contractId: this.id,
+            ...actorOption(values?.actor),
+            ...(note === undefined ? {} : { note }),
+            decorateOffer: ({ repository, observation, contractId: owner }) => {
+                const companion = releaseTaskHolder(repository, observation.admission.snapshot, owner);
+                return companion === null ? [] : [companion];
+            },
+        }));
+        return mutationResult(this.scope, this.id, accepted, () => undefined, hooks);
+    }
+    async arc(input) {
+        const values = requireInput(input, "arc input");
+        const hooks = worktreeHooksOption(values.hooks);
+        const chapter = decodeArcDocument(requireMarkdown(values.markdown));
+        const accepted = requireAccepted(arcOperation({
+            scope: this.scope,
+            contractId: this.id,
+            ...actorOption(values.actor),
+            chapter,
+        }));
+        return mutationResult(this.scope, this.id, accepted, () => undefined, hooks);
+    }
+    async audit(input) {
+        const values = input === undefined ? undefined : requireInput(input, "audit input");
+        const hooks = worktreeHooksOption(values?.hooks);
+        const actor = actorOption(values?.actor);
+        const state = readStateOperation({ scope: this.scope, contractId: this.id });
+        const derivation = state === null
+            ? undefined
+            : documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id);
+        const accepted = requireAccepted(await auditOperation({
+            scope: this.scope,
+            contractId: this.id,
+            ...(derivation === undefined ? {} : { derivation }),
+            ...actor,
+        }));
+        return mutationResult(this.scope, this.id, accepted, (report) => report, hooks);
+    }
+    async reconcile(input) {
+        const options = reconcileInput(input);
+        const reconciled = await reconcileOperation({ scope: this.scope, contractId: this.id, ...options });
+        return {
+            ...reconciled.report,
+            settlement: await settle({ repository: this.scope, state: reconciled.state, effects: reconciled.report.effects }),
+        };
+    }
+    deliveryHandle(delivery) {
+        return new DeliveryHandle(delivery.snapshotId, delivery.changeId, delivery.expectedPredecessor, () => deliveryDiffOperation({
+            scope: this.scope,
+            expectedPredecessor: delivery.expectedPredecessor,
+            snapshotId: delivery.snapshotId,
+        }), delivery);
+    }
+}
+const KEIYAKU_SEATS = new WeakMap();
+/** Internal package composition capability; not exported from the package root. */
+export function seatForKeiyaku(value) {
+    if (!(value instanceof KeiyakuHandle))
+        throw new TypeError("contract must be a Keiyaku");
+    const seat = KEIYAKU_SEATS.get(value);
+    if (seat === undefined)
+        throw new TypeError("contract must be a Keiyaku");
+    return seat;
+}
+export function keiyakuOf(input) {
+    const values = requireInput(input, "Keiyaku.of input");
+    const scope = scopeForRepo(values.repo);
+    if (typeof values.id !== "string")
+        throw new TypeError("contract ID must be a string");
+    return new KeiyakuHandle(contractId(values.id), scope);
+}
+export async function listKeiyaku(input) {
+    const values = requireInput(input, "Keiyaku.list input");
+    for (const key of Object.keys(values))
+        if (key !== "repo")
+            throw new TypeError(`Keiyaku.list input has unknown field: ${key}`);
+    return contractsOperation({ scope: scopeForRepo(values.repo) });
+}
+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 contractObservationOperation({ scope, contractId: id });
+}
+export async function bindKeiyaku(input) {
+    const values = requireInput(input, "Keiyaku.bind input");
+    const hooks = worktreeHooksOption(values.hooks);
+    const scope = scopeForRepo(values.repo);
+    const markdown = requireMarkdown(values.markdown);
+    const task = taskOption(values.task);
+    const document = decodeContractDocument(markdown);
+    const workspace = values.workspace === undefined ? "worktree" : values.workspace;
+    if (workspace !== "worktree" && workspace !== "here")
+        throw new TypeError("workspace must be worktree or here");
+    const target = values.target;
+    if (target !== undefined && typeof target !== "string")
+        throw new TypeError("target must be a string");
+    const actor = actorOption(values.actor);
+    const terms = contractTerms(document, normalizedGates(values.gates), normalizedList(values.after, "after", contractId));
+    const admitted = bindOperation({
+        scope,
+        title: document.title,
+        terms,
+        verification: documentDerivation(document, terms.gates).verification,
+        workspace,
+        ...(target === undefined ? {} : { target }),
+        ...(task === undefined ? {} : {
+            decorateOffer: ({ contractId: owner }) => [claimTaskHolder(task, owner)],
+        }),
+        ...actor,
+    });
+    const accepted = requireAccepted(admitted);
+    const id = accepted.value.contractId;
+    const result = await mutationResult(scope, id, accepted, ({ contractId: contract }) => new KeiyakuHandle(contract, scope), hooks);
+    return {
+        facts: result.facts,
+        head: result.head,
+        keiyaku: result.value,
+        effects: result.effects,
+        lags: result.lags,
+        settlement: result.settlement,
+        ...observeRegion(scope, id, document.region),
+    };
+}
+/** Internal package composition read used by Kanshi; not a package-root export. */
+export function taskHoldersForRepo(repo) {
+    return readTaskHolders(scopeForRepo(repo));
+}

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

@@ -0,0 +1,13 @@
+import type { DecodedContractDocument } from "../body/types.js";
+import { type ActorId, type ContractId, type ContractTerms, type Gate } from "../core/facts/types.js";
+import type { DocumentDerivation } from "../protocol/operations.js";
+export declare function actorOption(actor: unknown): Readonly<{
+    actor?: ActorId;
+}>;
+export declare function requireMarkdown(value: unknown, label?: string): string;
+export declare function requireInput(value: unknown, label: string): Record<string, unknown>;
+export declare function optionalNonblank(value: unknown, label: string): string | undefined;
+export declare function normalizedList<T>(values: unknown, label: string, brand: (value: string) => T): readonly T[];
+export declare function normalizedGates(values: unknown): readonly Gate[];
+export declare function contractTerms(document: DecodedContractDocument, gates: readonly Gate[], after: readonly ContractId[]): ContractTerms;
+export declare function documentDerivation(document: DecodedContractDocument, gates: readonly Gate[], contractId?: ContractId): DocumentDerivation;

package/build/src/library/input.js

@@ -0,0 +1,82 @@
+import { verificationDefinition } from "../body/decode.js";
+import { actorId, gate, gateWord, } from "../core/facts/types.js";
+import { prepareVerificationDeclaration } from "../verification/declaration.js";
+export function actorOption(actor) {
+    if (actor === undefined)
+        return {};
+    if (typeof actor !== "string" || actor.trim().length === 0) {
+        throw new TypeError("actor must be a nonblank string");
+    }
+    return { actor: actorId(actor) };
+}
+export function requireMarkdown(value, label = "markdown") {
+    if (typeof value !== "string")
+        throw new TypeError(`${label} must be a string`);
+    return value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function requireInput(value, label) {
+    if (!isRecord(value))
+        throw new TypeError(`${label} must be an object`);
+    return value;
+}
+export function optionalNonblank(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError(`${label} must be a nonblank string`);
+    }
+    return value;
+}
+export function normalizedList(values, label, brand) {
+    if (values === undefined)
+        return [];
+    if (!Array.isArray(values))
+        throw new TypeError(`${label} must be an array`);
+    return values.map((value, index) => {
+        if (typeof value !== "string")
+            throw new TypeError(`${label}[${index}] must be a string`);
+        try {
+            return brand(value);
+        }
+        catch (error) {
+            throw new TypeError(error instanceof Error ? error.message : `${label}[${index}] is invalid`);
+        }
+    });
+}
+export function normalizedGates(values) {
+    if (values === undefined)
+        return [];
+    if (!Array.isArray(values))
+        throw new TypeError("gates must be an array");
+    const normalized = values.map((value, index) => {
+        if (!gateWord(value)) {
+            throw new TypeError(`gates[${index}] must match ^[a-z][a-z0-9-]{0,63}$`);
+        }
+        return gate(value);
+    });
+    if (new Set(normalized).size !== normalized.length)
+        throw new TypeError("gates must not contain duplicates");
+    return normalized;
+}
+export function contractTerms(document, gates, after) {
+    return {
+        document: document.document,
+        segments: document.segments,
+        gates,
+        after,
+    };
+}
+export function documentDerivation(document, gates, contractId) {
+    return {
+        document: document.document.key,
+        title: document.title,
+        verification: prepareVerificationDeclaration({
+            gates,
+            definition: verificationDefinition(document),
+            ...(contractId === undefined ? {} : { contractId }),
+        }),
+    };
+}

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

@@ -0,0 +1,28 @@
+import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku, type Keiyaku as KeiyakuType } from "./contract.js";
+import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
+export { AuthorityCorruptionError } from "../core/facts/errors.js";
+export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
+export { NoGitWorldError, Repo } from "./repo.js";
+export { gatesFrom, SettingsError, worktreeHooksFrom, } from "./configuration.js";
+export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, BindInput, BindResult, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TimelineEntry, TaskId, TopologyEffect, VerificationStop, } from "./contract.js";
+export type { ContractId, ContractState, ChangeId, SnapshotId, } from "../core/facts/types.js";
+export type { Gate, GatesFromInput, HookCommand, WorktreeHooks, WorktreeHooksFromInput, } from "./configuration.js";
+export type { RegionOverlap } from "./region.js";
+export type { ReconcileInput, RepoAtInput, RepoReconcileReport, } from "./repo.js";
+export type { SettlementAction, SettlementLag, SettlementReport, } from "../settlement/settle.js";
+export type { AliasStage, AkumaStatus, CallObservation, CallInput, CallResult, DispatchStage, ForkInput, ForkResult, IntegrationFailure, } from "./akuma-creation.js";
+export type { AliasBinding } from "../alias/index.js";
+export type { Dispatch, DispatchFailure } from "../dispatch/index.js";
+export type { AkumaAlias } from "../identity/selector.js";
+export type { AkuId } from "../akuma/identity.js";
+export type Keiyaku = KeiyakuType;
+export declare const Keiyaku: Readonly<{
+    prototype: KeiyakuHandle;
+    [Symbol.hasInstance]: (value: unknown) => boolean;
+    bind: typeof bindKeiyaku;
+    call: typeof callKeiyaku;
+    fork: typeof forkKeiyaku;
+    list: typeof listKeiyaku;
+    observe: typeof observeKeiyaku;
+    of: typeof keiyakuOf;
+}>;

package/build/src/library/keiyaku.js

@@ -0,0 +1,16 @@
+import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku, } from "./contract.js";
+import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
+export { AuthorityCorruptionError } from "../core/facts/errors.js";
+export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
+export { NoGitWorldError, Repo } from "./repo.js";
+export { gatesFrom, SettingsError, worktreeHooksFrom, } from "./configuration.js";
+export const Keiyaku = Object.freeze({
+    prototype: KeiyakuHandle.prototype,
+    [Symbol.hasInstance]: (value) => value instanceof KeiyakuHandle,
+    bind: bindKeiyaku,
+    call: callKeiyaku,
+    fork: forkKeiyaku,
+    list: listKeiyaku,
+    observe: observeKeiyaku,
+    of: keiyakuOf,
+});

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

@@ -0,0 +1,17 @@
+import type { ContractId } from "../core/facts/types.js";
+import { type RepositoryScope } from "../protocol/operations.js";
+export type RegionOverlap = Readonly<{
+    contract: ContractId;
+    patterns: readonly Readonly<{
+        mine: string;
+        theirs: string;
+    }>[];
+}>;
+export type RegionObservation = Readonly<{
+    overlaps: readonly RegionOverlap[];
+    overlapFailure?: never;
+} | {
+    overlapFailure: string;
+    overlaps?: never;
+}>;
+export declare function observeRegion(scope: RepositoryScope, self: ContractId, mine: readonly string[]): RegionObservation;

package/build/src/library/region.js

@@ -0,0 +1,30 @@
+import { decodeContractDocument } from "../body/decode.js";
+import { regionsOverlap } from "../body/region.js";
+import { documentsOperation } from "../protocol/operations.js";
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function observeRegion(scope, self, mine) {
+    try {
+        const overlaps = [];
+        for (const peer of documentsOperation({ scope })) {
+            if (peer.contract === self)
+                continue;
+            try {
+                const pairs = regionsOverlap(mine, decodeContractDocument(peer.documentBytes).region);
+                if (pairs.length > 0)
+                    overlaps.push({
+                        contract: peer.contract,
+                        patterns: pairs.map(([minePattern, theirsPattern]) => ({ mine: minePattern, theirs: theirsPattern })),
+                    });
+            }
+            catch (error) {
+                return { overlapFailure: `${peer.contract}: ${diagnostic(error)}` };
+            }
+        }
+        return { overlaps };
+    }
+    catch (error) {
+        return { overlapFailure: diagnostic(error) };
+    }
+}