@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/src/core/facts/fold.js

@@ -0,0 +1,97 @@
+import { samePrerequisites } from "./eligibility.js";
+import { gatesSatisfied } from "./gate.js";
+import { AuthorityCorruptionError } from "./errors.js";
+function foldError(message) {
+    throw new AuthorityCorruptionError(`invalid journal fold: ${message}`);
+}
+function cloneTerms(terms) {
+    return {
+        document: { ...terms.document },
+        segments: [...terms.segments],
+        gates: [...terms.gates],
+        after: [...terms.after],
+    };
+}
+function cloneCoordinates(coordinates) {
+    return { ...coordinates };
+}
+function stateFromBind(id, head, bind, attestations) {
+    if (bind.contract !== id)
+        foldError(`entry belongs to ${bind.contract}, not ${id}`);
+    return {
+        id,
+        head,
+        coordinates: cloneCoordinates(bind.data.coordinates),
+        terms: cloneTerms(bind.data.terms),
+        bound: null,
+        delivery: null,
+        attestations,
+        terminal: null,
+    };
+}
+function requireActive(state, entry) {
+    if (state.terminal !== null)
+        foldError(`terminal contract cannot accept ${entry.kind}`);
+}
+function foldArc(state, entry) {
+    const expectedSequence = (state.currentArc?.data.seq ?? 0) + 1;
+    if (entry.data.seq !== expectedSequence) {
+        foldError(`arc sequence must be ${expectedSequence}`);
+    }
+    return { ...state, currentArc: entry };
+}
+function foldEntry(state, entry, attestations) {
+    if (entry.contract !== state.id)
+        foldError(`entry belongs to ${entry.contract}, not ${state.id}`);
+    requireActive(state, entry);
+    switch (entry.kind) {
+        case "bind":
+            foldError("bind may appear only once");
+        case "amend": {
+            if (state.bound !== null && !samePrerequisites(state.terms.after, entry.data.after)) {
+                foldError("cannot change after once prerequisites are consumed");
+            }
+            return { ...state, terms: cloneTerms(entry.data) };
+        }
+        case "bound":
+            if (state.bound !== null)
+                foldError("bound may appear only once");
+            return { ...state, bound: entry };
+        case "deliver":
+            if (state.bound === null)
+                foldError("deliver requires bound");
+            return { ...state, delivery: entry };
+        case "attestation":
+            attestations.push(entry);
+            return { ...state, attestations };
+        case "claimed":
+            if (state.delivery === null)
+                foldError("claimed requires a deliver");
+            if (entry.data.delivery !== state.delivery.entry)
+                foldError("claimed must name the current deliver");
+            if (!gatesSatisfied(state))
+                foldError("claimed gates are not satisfied");
+            return { ...state, terminal: entry };
+        case "arc":
+            return foldArc(state, entry);
+        case "abandoned":
+            return { ...state, terminal: entry };
+    }
+}
+export function foldJournal(id, entries, head = null) {
+    const first = entries[0];
+    if (first === undefined || first.kind !== "bind")
+        foldError("journal must begin with bind");
+    const seen = new Set();
+    const attestations = [];
+    seen.add(first.entry);
+    let state = stateFromBind(id, head, first, attestations);
+    for (let index = 1; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (seen.has(entry.entry))
+            foldError(`duplicate entry ${entry.entry}`);
+        seen.add(entry.entry);
+        state = foldEntry(state, entry, attestations);
+    }
+    return state;
+}

package/build/src/core/facts/gate.d.ts

@@ -0,0 +1,24 @@
+import type { AttestationEntry, ContractState, Gate } from "./types.js";
+export type GateCurrent = Readonly<{
+    kind: "attested";
+    verdict: "satisfied" | "unsatisfied";
+    summary?: string;
+}> | Readonly<{
+    kind: "stale";
+    priorVerdict: "satisfied" | "unsatisfied";
+}> | Readonly<{
+    kind: "missing";
+}>;
+export type GateReport = Readonly<{
+    gate: Gate;
+    current: GateCurrent;
+}>;
+export type GateReports = Readonly<{
+    reports: readonly GateReport[];
+    satisfied: boolean;
+}>;
+/** Resolve the latest testimony for each requested gate and current subject. */
+export declare function latestCurrentAttestations(state: ContractState, requested: ReadonlySet<Gate>): ReadonlyMap<Gate, AttestationEntry>;
+export declare function gatesSatisfied(state: ContractState): boolean;
+/** Project every declared gate without allowing consumers to reimplement currency. */
+export declare function gateReports(state: ContractState): GateReports;

package/build/src/core/facts/gate.js

@@ -0,0 +1,52 @@
+import { currentSubjectPredicate } from "../subject.js";
+/** Resolve the latest testimony for each requested gate and current subject. */
+export function latestCurrentAttestations(state, requested) {
+    const attestations = new Map();
+    const subjectIsCurrent = currentSubjectPredicate(state);
+    for (let index = state.attestations.length - 1; index >= 0; index -= 1) {
+        const attestation = state.attestations[index];
+        const { gate, subject } = attestation.data;
+        if (!requested.has(gate) || attestations.has(gate) || !subjectIsCurrent(subject))
+            continue;
+        attestations.set(gate, attestation);
+        if (attestations.size === requested.size)
+            break;
+    }
+    return attestations;
+}
+export function gatesSatisfied(state) {
+    return gateReports(state).satisfied;
+}
+/** Project every declared gate without allowing consumers to reimplement currency. */
+export function gateReports(state) {
+    const declared = state.terms.gates;
+    const requested = new Set(declared);
+    const current = latestCurrentAttestations(state, requested);
+    const prior = new Map();
+    for (let index = state.attestations.length - 1; index >= 0; index -= 1) {
+        const entry = state.attestations[index];
+        if (!prior.has(entry.data.gate) && requested.has(entry.data.gate))
+            prior.set(entry.data.gate, entry);
+    }
+    const reports = declared.map((gate) => {
+        const attestation = current.get(gate);
+        if (attestation !== undefined) {
+            return {
+                gate,
+                current: {
+                    kind: "attested",
+                    verdict: attestation.data.verdict,
+                    ...(attestation.data.summary === undefined ? {} : { summary: attestation.data.summary }),
+                },
+            };
+        }
+        const previous = prior.get(gate);
+        return previous === undefined
+            ? { gate, current: { kind: "missing" } }
+            : { gate, current: { kind: "stale", priorVerdict: previous.data.verdict } };
+    });
+    return {
+        reports,
+        satisfied: reports.every((report) => report.current.kind === "attested" && report.current.verdict === "satisfied"),
+    };
+}

package/build/src/core/facts/observation.d.ts

@@ -0,0 +1,15 @@
+import type { ContractId, ContractState, DocumentKey } from "./types.js";
+/** The complete state projection consumed by one pure pact decision. */
+export type ContractsObservation = ReadonlyMap<ContractId, ContractState | null>;
+export type PrerequisiteStatus = "unknown" | "pending" | "claimed";
+/** Read one requested identity; a missing key violates the observation contract. */
+export declare function contractState(observation: ContractsObservation, contract: ContractId): ContractState | null;
+/** Project prerequisite existence and terminal satisfaction from one observation. */
+export declare function prerequisiteStatus(prerequisites: readonly ContractId[], observation: ContractsObservation): PrerequisiteStatus;
+export type ActiveContractRefusal = Readonly<{
+    kind: "contract-missing" | "terminal";
+    contractId: ContractId;
+}>;
+/** The single lifecycle guard shared by every operation on an existing contract. */
+export declare function activeContract(observation: ContractsObservation, contract: ContractId): ContractState | ActiveContractRefusal;
+export declare function documentIsCurrent(state: ContractState, document: DocumentKey): boolean;

package/build/src/core/facts/observation.js

@@ -0,0 +1,35 @@
+/** Read one requested identity; a missing key violates the observation contract. */
+export function contractState(observation, contract) {
+    const state = observation.get(contract);
+    if (state === undefined) {
+        throw new Error(`missing contract decision observation: ${contract}`);
+    }
+    if (state !== null && state.id !== contract) {
+        throw new Error(`contract state identity disagrees with decision map: ${contract}`);
+    }
+    return state;
+}
+/** Project prerequisite existence and terminal satisfaction from one observation. */
+export function prerequisiteStatus(prerequisites, observation) {
+    let pending = false;
+    for (const dependency of prerequisites) {
+        const state = contractState(observation, dependency);
+        if (state === null)
+            return "unknown";
+        if (state.terminal?.kind !== "claimed")
+            pending = true;
+    }
+    return pending ? "pending" : "claimed";
+}
+/** The single lifecycle guard shared by every operation on an existing contract. */
+export function activeContract(observation, contract) {
+    const state = contractState(observation, contract);
+    if (state === null)
+        return { kind: "contract-missing", contractId: contract };
+    if (state.terminal)
+        return { kind: "terminal", contractId: contract };
+    return state;
+}
+export function documentIsCurrent(state, document) {
+    return state.terms.document.key === document;
+}

package/build/src/core/facts/offer.d.ts

@@ -0,0 +1,21 @@
+import type { ContractHead, ContractId, JournalEntry, SnapshotId } from "./types.js";
+export type ContractJournalAppend = Readonly<{
+    readonly contractId: ContractId;
+    readonly expectedHead: ContractHead | null;
+    readonly entries: readonly JournalEntry[];
+}>;
+/** A target operation is optional because claim can be journal-only. */
+export type RefOperation = Readonly<{
+    readonly target: string;
+    readonly newOid: SnapshotId;
+    readonly expectedOid: SnapshotId;
+}>;
+export type TreeUpdate = Readonly<{
+    readonly path: string;
+    readonly bytes: Uint8Array;
+}>;
+export type Offer = Readonly<{
+    readonly facts: readonly ContractJournalAppend[];
+    readonly target?: RefOperation;
+    readonly companions?: readonly TreeUpdate[];
+}>;

package/build/src/core/facts/types.d.ts

@@ -0,0 +1,137 @@
+declare const contractIdBrand: unique symbol;
+declare const entryUlidBrand: unique symbol;
+declare const contractHeadBrand: unique symbol;
+declare const snapshotIdBrand: unique symbol;
+declare const changeIdBrand: unique symbol;
+declare const documentKeyBrand: unique symbol;
+declare const documentSegmentKeyBrand: unique symbol;
+declare const gateBrand: unique symbol;
+declare const dependencyKeySetBrand: unique symbol;
+declare const actorIdBrand: unique symbol;
+export type ContractId = string & {
+    readonly [contractIdBrand]: "ContractId";
+};
+export type EntryUlid = string & {
+    readonly [entryUlidBrand]: "EntryUlid";
+};
+export type ContractHead = string & {
+    readonly [contractHeadBrand]: "ContractHead";
+};
+export type SnapshotId = string & {
+    readonly [snapshotIdBrand]: "SnapshotId";
+};
+export type ChangeId = string & {
+    readonly [changeIdBrand]: "ChangeId";
+};
+export type DocumentKey = string & {
+    readonly [documentKeyBrand]: "DocumentKey";
+};
+export type DocumentSegmentKey = string & {
+    readonly [documentSegmentKeyBrand]: "DocumentSegmentKey";
+};
+export type Gate = string & {
+    readonly [gateBrand]: "Gate";
+};
+export type DependencyKeySet = string & {
+    readonly [dependencyKeySetBrand]: "DependencyKeySet";
+};
+export type ActorId = string & {
+    readonly [actorIdBrand]: "ActorId";
+};
+export declare function contractId(value: string): ContractId;
+export declare function contractIdFromSegment(segment: string): ContractId;
+export declare function contractSegment(value: ContractId): string;
+export declare function entryUlid(value: string): EntryUlid;
+export declare function contractHead(value: string): ContractHead;
+/** Validate an opaque persisted snapshot value; only Git may mint one. */
+export declare function snapshotId(value: string): SnapshotId;
+/** Validate an opaque persisted change value; only Git may mint one. */
+export declare function changeId(value: string): ChangeId;
+/** Validate optional opaque testimony without imposing a registry. */
+export declare function actorId(value: string): ActorId;
+export declare function documentKey(value: string): DocumentKey;
+export declare function documentSegmentKey(value: string): DocumentSegmentKey;
+export declare function gateWord(value: unknown): value is string;
+export declare function gate(value: string): Gate;
+export type ContractCoordinates = Readonly<{
+    start: SnapshotId;
+    target?: string;
+    workspace: "worktree" | "here";
+}>;
+export type ContractTerms = Readonly<{
+    document: Readonly<{
+        bytes: string;
+        key: DocumentKey;
+    }>;
+    segments: readonly DocumentSegmentKey[];
+    gates: readonly Gate[];
+    after: readonly ContractId[];
+}>;
+export type BindData = Readonly<{
+    coordinates: ContractCoordinates;
+    terms: ContractTerms;
+}>;
+export type AmendData = ContractTerms;
+export type BoundData = Readonly<Record<string, never>>;
+export type DeliverData = Readonly<{
+    tenderSnapshot: SnapshotId;
+    integration: Readonly<{
+        predecessor: SnapshotId;
+        snapshot: SnapshotId;
+        changeId: ChangeId;
+    }>;
+    method: "squash";
+    policy: Readonly<{
+        requireBranchesToBeUpToDate: boolean;
+    }>;
+}>;
+export type AttestationData = Readonly<{
+    gate: Gate;
+    subject: DependencyKeySet;
+    verdict: "satisfied" | "unsatisfied";
+    summary?: string;
+}>;
+export type ClaimedData = Readonly<{
+    delivery: EntryUlid;
+}>;
+export type ArcData = Readonly<{
+    seq: number;
+    title: string;
+    objective: string;
+    brief: string;
+}>;
+export type AbandonedData = Readonly<{
+    note?: string;
+}>;
+type JournalEnvelope<Kind extends string, Data> = Readonly<{
+    v: 1;
+    kind: Kind;
+    contract: ContractId;
+    entry: EntryUlid;
+    at: string;
+    actor?: ActorId;
+    data: Data;
+}>;
+export type BindEntry = JournalEnvelope<"bind", BindData>;
+type AmendEntry = JournalEnvelope<"amend", AmendData>;
+type BoundEntry = JournalEnvelope<"bound", BoundData>;
+type DeliverEntry = JournalEnvelope<"deliver", DeliverData>;
+export type AttestationEntry = JournalEnvelope<"attestation", AttestationData>;
+type ClaimedEntry = JournalEnvelope<"claimed", ClaimedData>;
+export type ArcEntry = JournalEnvelope<"arc", ArcData>;
+type AbandonedEntry = JournalEnvelope<"abandoned", AbandonedData>;
+export type JournalEntry = BindEntry | AmendEntry | BoundEntry | DeliverEntry | AttestationEntry | ClaimedEntry | ArcEntry | AbandonedEntry;
+export type FactKind = JournalEntry["kind"];
+type ContractTerminal = ClaimedEntry | AbandonedEntry;
+export type ContractState = Readonly<{
+    id: ContractId;
+    head: ContractHead | null;
+    coordinates: ContractCoordinates;
+    terms: ContractTerms;
+    bound: BoundEntry | null;
+    delivery: DeliverEntry | null;
+    attestations: readonly AttestationEntry[];
+    currentArc?: ArcEntry;
+    terminal: ContractTerminal | null;
+}>;
+export {};

package/build/src/core/facts/types.js

@@ -0,0 +1,66 @@
+import { identityCoordinate, identitySegments } from "../../identity/coordinates.js";
+const ULID = /^[0-9ABCDEFGHJKMNPQRSTVWXYZ]{26}$/;
+function requireText(value, label) {
+    if (value.length === 0 || /\s/.test(value))
+        throw new Error(`${label} must be nonempty and contain no whitespace`);
+    return value;
+}
+function requireOpaqueId(value, label) {
+    if (value.trim().length === 0)
+        throw new Error(`${label} must be nonblank`);
+    return value;
+}
+export function contractId(value) {
+    requireText(value, "contract ID");
+    let segments;
+    try {
+        segments = identitySegments({ family: "kei", value });
+    }
+    catch {
+        throw new Error("contract ID must be kei/<contract-segment>");
+    }
+    if (segments.length !== 1)
+        throw new Error("contract ID must be kei/<contract-segment>");
+    return value;
+}
+export function contractIdFromSegment(segment) {
+    return contractId(identityCoordinate({ family: "kei", segments: [segment] }));
+}
+export function contractSegment(value) {
+    return identitySegments({ family: "kei", value: contractId(value) })[0];
+}
+export function entryUlid(value) {
+    if (!ULID.test(value))
+        throw new Error("entry ULID must be a canonical 26-character uppercase ULID");
+    return value;
+}
+export function contractHead(value) {
+    return requireOpaqueId(value, "contract head");
+}
+/** Validate an opaque persisted snapshot value; only Git may mint one. */
+export function snapshotId(value) {
+    return requireOpaqueId(value, "snapshot ID");
+}
+/** Validate an opaque persisted change value; only Git may mint one. */
+export function changeId(value) {
+    return requireOpaqueId(value, "change ID");
+}
+/** Validate optional opaque testimony without imposing a registry. */
+export function actorId(value) {
+    return requireOpaqueId(value, "actor");
+}
+export function documentKey(value) {
+    return requireOpaqueId(value, "document key");
+}
+export function documentSegmentKey(value) {
+    return requireOpaqueId(value, "document segment key");
+}
+export function gateWord(value) {
+    return typeof value === "string" && /^[a-z][a-z0-9-]{0,63}$/u.test(value);
+}
+export function gate(value) {
+    if (!gateWord(value)) {
+        throw new Error("gate must match ^[a-z][a-z0-9-]{0,63}$");
+    }
+    return value;
+}

package/build/src/core/subject.d.ts

@@ -0,0 +1,21 @@
+import { type ChangeId, type ContractState, type DependencyKeySet, type DocumentKey, type DocumentSegmentKey, type SnapshotId } from "./facts/types.js";
+type DependencyKey = Readonly<{
+    readonly kind: "document";
+    readonly value: DocumentKey;
+} | {
+    readonly kind: "segment";
+    readonly value: DocumentSegmentKey;
+} | {
+    readonly kind: "snapshot";
+    readonly value: SnapshotId;
+} | {
+    readonly kind: "change";
+    readonly value: ChangeId;
+}>;
+/** Mint the opaque persisted representation of an ordered producer-selected key set. */
+export declare function dependencyKeySet(keys: readonly DependencyKey[]): DependencyKeySet;
+/** Parse and canonicalize the opaque dependency-key-set fact value. */
+export declare function parseDependencyKeySet(value: string): DependencyKeySet;
+/** Build one memoized currentness test for a folded contract snapshot. */
+export declare function currentSubjectPredicate(state: ContractState): (subject: DependencyKeySet) => boolean;
+export {};

package/build/src/core/subject.js

@@ -0,0 +1,89 @@
+import { changeId, documentKey, documentSegmentKey, snapshotId, } from "./facts/types.js";
+import { AuthorityCorruptionError } from "./facts/errors.js";
+function keyTuple(key) {
+    return [key.kind, key.value];
+}
+function encodeKey(key) {
+    return JSON.stringify(keyTuple(key));
+}
+function parseKey(value, index) {
+    if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "string" || typeof value[1] !== "string") {
+        throw new AuthorityCorruptionError(`dependency key [${index}] must be a [kind, value] pair`);
+    }
+    try {
+        switch (value[0]) {
+            case "document": return { kind: "document", value: documentKey(value[1]) };
+            case "segment": return { kind: "segment", value: documentSegmentKey(value[1]) };
+            case "snapshot": return { kind: "snapshot", value: snapshotId(value[1]) };
+            case "change": return { kind: "change", value: changeId(value[1]) };
+            default: throw new AuthorityCorruptionError(`unknown dependency key kind '${value[0]}'`);
+        }
+    }
+    catch (error) {
+        throw error instanceof AuthorityCorruptionError
+            ? error
+            : new AuthorityCorruptionError(error instanceof Error ? error.message : `invalid dependency key [${index}]`);
+    }
+}
+function canonicalEncodedKeys(keys) {
+    const encoded = keys.map(encodeKey).sort();
+    for (let index = 1; index < encoded.length; index += 1) {
+        if (encoded[index] === encoded[index - 1])
+            throw new AuthorityCorruptionError("dependency key set cannot contain duplicates");
+    }
+    return encoded;
+}
+function canonicalKeys(keys) {
+    return `[${canonicalEncodedKeys(keys).join(",")}]`;
+}
+/** Mint the opaque persisted representation of an ordered producer-selected key set. */
+export function dependencyKeySet(keys) {
+    return canonicalKeys(keys);
+}
+function decodeDependencyKeySet(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new AuthorityCorruptionError("dependency key set must be nonblank");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (error) {
+        throw new AuthorityCorruptionError("dependency key set must be canonical JSON", { cause: error });
+    }
+    if (!Array.isArray(parsed))
+        throw new AuthorityCorruptionError("dependency key set must be an array");
+    const keys = parsed.map(parseKey);
+    const encodedKeys = canonicalEncodedKeys(keys);
+    const canonical = `[${encodedKeys.join(",")}]`;
+    if (canonical !== value)
+        throw new AuthorityCorruptionError("dependency key set must be canonical JSON");
+    return { canonical: canonical, encodedKeys };
+}
+/** Parse and canonicalize the opaque dependency-key-set fact value. */
+export function parseDependencyKeySet(value) {
+    return decodeDependencyKeySet(value).canonical;
+}
+function currentKeys(state) {
+    return new Set([
+        encodeKey({ kind: "document", value: state.terms.document.key }),
+        ...state.terms.segments.map((value) => encodeKey({ kind: "segment", value })),
+        ...(state.delivery === null ? [] : [
+            encodeKey({ kind: "snapshot", value: state.delivery.data.integration.snapshot }),
+            encodeKey({ kind: "change", value: state.delivery.data.integration.changeId }),
+        ]),
+    ]);
+}
+/** Build one memoized currentness test for a folded contract snapshot. */
+export function currentSubjectPredicate(state) {
+    const available = currentKeys(state);
+    const current = new Map();
+    return (subject) => {
+        const known = current.get(subject);
+        if (known !== undefined)
+            return known;
+        const value = decodeDependencyKeySet(subject).encodedKeys.every((key) => available.has(key));
+        current.set(subject, value);
+        return value;
+    };
+}

package/build/src/core/verbs/abandon.d.ts

@@ -0,0 +1,13 @@
+import type { DecideInput, OfferDecision } from "../decide.js";
+import type { ActorId, ContractId } from "../facts/types.js";
+export type AbandonInput = Readonly<{
+    contractId: ContractId;
+    actor?: ActorId;
+    at: string;
+    note?: string;
+}>;
+export type AbandonRefusal = Readonly<{
+    kind: "contract-missing" | "terminal";
+    contractId: ContractId;
+}>;
+export declare function decideAbandon({ input, attempt, observation }: DecideInput<AbandonInput>): OfferDecision<AbandonRefusal>;

package/build/src/core/verbs/abandon.js

@@ -0,0 +1,17 @@
+import { activeContract } from "../facts/observation.js";
+export function decideAbandon({ input, attempt, observation }) {
+    const id = input.contractId;
+    const current = activeContract(observation, id);
+    if ("kind" in current)
+        return { kind: "refused", refusal: current };
+    const abandoned = {
+        v: 1,
+        kind: "abandoned",
+        contract: id,
+        entry: attempt.entryUlids[0],
+        at: input.at,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        data: input.note === undefined ? {} : { note: input.note },
+    };
+    return { kind: "offer", offer: { facts: [{ contractId: id, expectedHead: current.head, entries: [abandoned] }] } };
+}

package/build/src/core/verbs/amend.d.ts

@@ -0,0 +1,14 @@
+import type { DecideInput, OfferDecision, Preparation } from "../decide.js";
+import type { ActorId, AmendData, ContractId, ContractTerms } from "../facts/types.js";
+export type AmendInput<Failure = never> = Readonly<{
+    contractId: ContractId;
+    actor?: ActorId;
+    at: string;
+    source?: ContractTerms;
+    preparation?: Preparation<AmendData, Failure>;
+}>;
+export type AmendRefusal = Readonly<{
+    kind: "contract-missing" | "terminal" | "terms-moved" | "prerequisites-already-consumed" | "unknown-prerequisite" | "cyclic-prerequisite";
+    contractId: ContractId;
+}>;
+export declare function decideAmend<Failure>({ input, attempt, observation }: DecideInput<AmendInput<Failure>>): OfferDecision<AmendRefusal | Failure>;

package/build/src/core/verbs/amend.js

@@ -0,0 +1,52 @@
+import { prerequisitesReach, samePrerequisites } from "../facts/eligibility.js";
+import { activeContract, prerequisiteStatus } from "../facts/observation.js";
+function prerequisitesConsumed(current, next, observation) {
+    if (samePrerequisites(current.terms.after, next.after))
+        return false;
+    const status = prerequisiteStatus(current.terms.after, observation);
+    if (status === "unknown")
+        throw new Error("current prerequisite is absent from the decision observation");
+    return current.bound !== null || status === "claimed";
+}
+export function decideAmend({ input, attempt, observation }) {
+    const id = input.contractId;
+    const current = activeContract(observation, id);
+    if ("kind" in current)
+        return { kind: "refused", refusal: current };
+    if (input.preparation === undefined || input.source === undefined) {
+        throw new Error("existing contract requires an amend preparation and source terms");
+    }
+    const source = input.source;
+    const termsCurrent = source.document.key === current.terms.document.key
+        && source.segments.length === current.terms.segments.length
+        && source.segments.every((value, index) => value === current.terms.segments[index])
+        && source.gates.length === current.terms.gates.length
+        && source.gates.every((value, index) => value === current.terms.gates[index])
+        && samePrerequisites(source.after, current.terms.after);
+    if (!termsCurrent) {
+        return { kind: "refused", refusal: { kind: "terms-moved", contractId: id } };
+    }
+    if (input.preparation.kind === "refused")
+        return { kind: "refused", refusal: input.preparation.refusal };
+    const { data } = input.preparation;
+    if (prerequisitesConsumed(current, data, observation)) {
+        return { kind: "refused", refusal: { kind: "prerequisites-already-consumed", contractId: id } };
+    }
+    const prerequisites = prerequisiteStatus(data.after, observation);
+    if (prerequisites === "unknown") {
+        return { kind: "refused", refusal: { kind: "unknown-prerequisite", contractId: id } };
+    }
+    if (prerequisitesReach(id, data.after, observation)) {
+        return { kind: "refused", refusal: { kind: "cyclic-prerequisite", contractId: id } };
+    }
+    const entry = {
+        v: 1,
+        kind: "amend",
+        contract: id,
+        entry: attempt.entryUlids[0],
+        at: input.at,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        data,
+    };
+    return { kind: "offer", offer: { facts: [{ contractId: id, expectedHead: current.head, entries: [entry] }] } };
+}