@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/library/mutation.js

@@ -1,248 +0,0 @@
-import { ExecutionProgress, executionStop } from "../protocol/progress.js";
-import { executionCleanupSchema, executionStopSchema, mutationOperationSchema, receiptFromProgress, withExecutionReceipt, } from "./execution-result.js";
-import { decodeJournalEntry } from "../core/facts/codec.js";
-import { contractHead, snapshotId, } from "../core/facts/types.js";
-import { decodeSettlementLag } from "../settlement/result-codec.js";
-import { completeReconcile, decodeReconciliationLag, reconcileLagScope, } from "./reconcile.js";
-import { decodeAuditReport } from "../protocol/audit.js";
-import { decodeMaterializedConflict } from "../protocol/deliver.js";
-import { decodeReviewValue } from "../protocol/review.js";
-import { decodeContinuationReport } from "./continuation.js";
-import { deliveryValueSchema } from "./delivery.js";
-import { ownerSchema } from "./result-codec.js";
-import { z } from "zod";
-function pendingSurface(surface, required) {
-    return { surface, required };
-}
-export function decodeMutationPendingSurface(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        throw new Error("malformed pending surface");
-    const object = value;
-    if (Object.keys(object).some((key) => key !== "surface" && key !== "required"))
-        throw new Error("malformed pending surface");
-    if (object.surface !== "verification" &&
-        object.surface !== "placement" &&
-        object.surface !== "continuation" &&
-        object.surface !== "reconciliation" &&
-        object.surface !== "settlement" &&
-        object.surface !== "cleanup" &&
-        object.surface !== "execution")
-        throw new Error("malformed pending surface");
-    if (typeof object.required !== "boolean")
-        throw new Error("malformed pending surface");
-    return { surface: object.surface, required: object.required };
-}
-export const mutationPendingSurfaceSchema = ownerSchema(decodeMutationPendingSurface, "expected pending surface");
-function decodeMutationLag(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        throw new Error("malformed mutation lag");
-    const { affects, ...withoutScope } = value;
-    const lag = decodeReconciliationLag(withoutScope);
-    const expected = reconcileLagScope(lag);
-    if (affects !== expected)
-        throw new Error("malformed mutation lag");
-    return { ...lag, affects: expected };
-}
-export function decodeReview(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        throw new Error("malformed review");
-    const { continuation, ...protocol } = value;
-    const review = decodeReviewValue(protocol);
-    return continuation === undefined ? review : { ...review, continuation: decodeContinuationReport(continuation) };
-}
-export const auditReportSchema = ownerSchema(decodeAuditReport, "expected audit report");
-const reviewSchema = ownerSchema(decodeReview, "expected review");
-const materializedConflictSchema = ownerSchema(decodeMaterializedConflict, "expected materialized conflict");
-export const mutationResultSchema = (operation, value) => ownerSchema((input) => {
-    if (input === null || typeof input !== "object" || Array.isArray(input))
-        throw new Error("malformed mutation result");
-    const object = input;
-    if (object.kind !== "accepted" || object.operation !== operation)
-        throw new Error("malformed mutation result");
-    if (typeof object.head !== "string")
-        throw new Error("malformed mutation result");
-    const parsedValue = value.safeParse(object.value);
-    if (!parsedValue.success)
-        throw new Error("malformed mutation result");
-    if (!Array.isArray(object.facts) ||
-        !Array.isArray(object.lags) ||
-        !Array.isArray(object.settlementLags) ||
-        !Array.isArray(object.cleanup) ||
-        !Array.isArray(object.executionStops) ||
-        !Array.isArray(object.pending))
-        throw new Error("malformed mutation result");
-    const allowed = new Set([
-        "kind",
-        "operation",
-        "facts",
-        "head",
-        "value",
-        "lags",
-        "settlementLags",
-        "pending",
-        "recoverySnapshot",
-        "cleanup",
-        "executionStops",
-    ]);
-    for (const key of Object.keys(object))
-        if (!allowed.has(key))
-            throw new Error("malformed mutation result");
-    return {
-        kind: "accepted",
-        operation,
-        cleanup: object.cleanup.map((item) => executionCleanupSchema.parse(item)),
-        executionStops: object.executionStops.map((item) => executionStopSchema.parse(item)),
-        facts: object.facts.map(decodeJournalEntry),
-        head: contractHead(object.head),
-        value: parsedValue.data,
-        lags: object.lags.map(decodeMutationLag),
-        settlementLags: object.settlementLags.map(decodeSettlementLag),
-        pending: object.pending.map(decodeMutationPendingSurface),
-        ...(object.recoverySnapshot === undefined
-            ? {}
-            : { recoverySnapshot: snapshotId(String(object.recoverySnapshot)) }),
-    };
-}, "expected mutation result");
-export const deliveryResultSchema = z.union([
-    mutationResultSchema("deliver", deliveryValueSchema),
-    materializedConflictSchema,
-]);
-export const reviewResultSchema = mutationResultSchema("review", reviewSchema);
-export const auditResultSchema = mutationResultSchema("audit", auditReportSchema);
-export function noValuePending(_value) {
-    return [];
-}
-export function auditPending(value) {
-    return value.verification.kind === "stopped" ? [pendingSurface("verification", true)] : [];
-}
-export function completionPending(value) {
-    if (value === undefined)
-        return [];
-    const pending = [];
-    if (value.verification !== undefined)
-        pending.push(pendingSurface("verification", true));
-    if (value.placement !== undefined)
-        pending.push(pendingSurface("placement", true));
-    if (value.continuation !== undefined && value.continuation.stopped.length > 0) {
-        pending.push(pendingSurface("continuation", true));
-    }
-    return pending;
-}
-export function obligationPending(input) {
-    const pending = [];
-    for (const lag of input.lags) {
-        const affects = "affects" in lag ? lag.affects : reconcileLagScope(lag);
-        if (affects !== "none" && !pending.some(({ surface }) => surface === affects)) {
-            pending.push(pendingSurface(affects, true));
-        }
-    }
-    if (input.settlementLags.length > 0)
-        pending.push(pendingSurface("settlement", true));
-    if (input.cleanup.length > 0) {
-        pending.push(pendingSurface("cleanup", false));
-    }
-    for (const stop of input.executionStops) {
-        const surface = stop.stage === "admission" ? "execution" : stop.stage === "reintegration" ? "placement" : stop.stage;
-        pending.push(pendingSurface(surface, true));
-    }
-    return pending;
-}
-export function collectAcceptedPending(valuePending, obligations) {
-    const result = new Map();
-    for (const pending of [...valuePending, ...obligationPending(obligations)])
-        result.set(pending.surface, pending.required || result.get(pending.surface) === true);
-    return [...result].map(([surface, required]) => ({ surface, required }));
-}
-function phasePendingFromValue(operation, value) {
-    if (operation === "audit")
-        return auditPending(value);
-    if (operation === "review" || operation === "deliver")
-        return completionPending(value);
-    return [];
-}
-/** Purely projects the leading mutation's finality without changing its details. */
-export function projectMutationFinality(input) {
-    if (input.kind !== "accepted" || !mutationOperationSchema.safeParse(input.operation).success)
-        return { kind: "not-admitted" };
-    const pending = collectAcceptedPending(phasePendingFromValue(input.operation, input.value), input);
-    return pending.length === 0 ? { kind: "complete" } : { kind: "accepted-pending", pending };
-}
-export function completionInput(input) {
-    return input;
-}
-function rememberLeading(input, progress) {
-    const { accepted, contractId } = input;
-    // An accepted audit may be observational and deliberately contain no new fact.
-    progress.recordPublication(contractId, accepted.head, accepted.facts);
-    progress.recordResidue(contractId, accepted);
-    if (input.progress === undefined)
-        progress.recordVerification(contractId, undefined, accepted);
-}
-async function reconcileExecution(input, progress) {
-    const contracts = [...new Set([input.contractId, ...progress.snapshot().affected])];
-    const reports = [];
-    for (const contractId of contracts) {
-        try {
-            input.scope.signal?.throwIfAborted();
-            progress.observe({ kind: "stage", contractId, stage: "reconciliation", state: "started" });
-            const report = await (async () => {
-                try {
-                    return await completeReconcile({
-                        scope: input.scope,
-                        channel: input.channel,
-                        contractId,
-                        hooks: input.hooks,
-                        retryHooks: false,
-                    });
-                }
-                finally {
-                    progress.observe({ kind: "stage", contractId, stage: "reconciliation", state: "finished" });
-                }
-            })();
-            reports.push(report);
-            progress.recordResidue(contractId, report.settlement);
-        }
-        catch (error) {
-            progress.recordStop(executionStop(contractId, "reconciliation", error, input.scope.signal));
-        }
-    }
-    return reports;
-}
-export async function completeMutation(input) {
-    const progress = input.progress ?? new ExecutionProgress();
-    rememberLeading(input, progress);
-    try {
-        const reports = await reconcileExecution(input, progress);
-        const snapshot = progress.snapshot();
-        const effects = [...snapshot.physical.effects, ...reports.flatMap((report) => report.effects)];
-        const recoverySnapshot = effects.findLast((effect) => effect.kind === "recovery-snapshot")?.snapshot;
-        const publicValue = input.value(input.accepted.value);
-        const lags = [...snapshot.physical.lag, ...reports.flatMap((report) => report.lag)].map((lag) => ({
-            ...lag,
-            affects: reconcileLagScope(lag),
-        }));
-        const settlementLags = reports.flatMap((report) => report.settlement.lags);
-        const obligations = { lags, settlementLags, cleanup: snapshot.cleanup, executionStops: snapshot.stops };
-        return {
-            kind: "accepted",
-            operation: input.operation,
-            facts: snapshot.facts,
-            head: progress.head(input.contractId) ?? input.accepted.head,
-            value: publicValue,
-            ...obligations,
-            pending: collectAcceptedPending(phasePendingFromValue(input.operation, publicValue), obligations),
-            ...(recoverySnapshot === undefined ? {} : { recoverySnapshot }),
-        };
-    }
-    catch (error) {
-        const receipt = receiptFromProgress(input.operation, input.contractId, progress);
-        throw receipt === undefined ? error : withExecutionReceipt(error, receipt);
-    }
-}
-export async function completeHolderMutation(input) {
-    const accepted = input.requireAccepted(input.admission.result);
-    // Fence teardown after confirmed admission is custodial residue. Settlement in
-    // completeMutation already reports any still-owed holder publication; do not
-    // invent a second owed-holder lag from fence close alone.
-    return await completeMutation({ ...input.completion, accepted });
-}

package/build/src/library/result-codec.d.ts

@@ -1,2 +0,0 @@
-import { z } from "zod";
-export declare function ownerSchema<Value>(decode: (value: unknown) => Value, message: string): z.ZodType<Value>;

package/build/src/library/result-codec.js

@@ -1,12 +0,0 @@
-import { z } from "zod";
-export function ownerSchema(decode, message) {
-    return z.unknown().transform((value, context) => {
-        try {
-            return decode(value);
-        }
-        catch {
-            context.addIssue({ code: "custom", message });
-            return z.NEVER;
-        }
-    });
-}

package/build/src/protocol/result-codec.d.ts

@@ -1,23 +0,0 @@
-import type { AuditReport } from "./audit.js";
-import type { CandidateCompletion, CompletionEvidence } from "./completion.js";
-import type { DeliverLeading, IntegrationConflictMaterialized } from "./deliver.js";
-import type { CurrentVerifiedAttestation, VerificationCleanupFailure, VerificationRuntimeStop } from "./intent.js";
-import type { DeliverConflictRefusal, DeliveryPreparationRefusal, IntentRefusal, MergeStatePresentRefusal, PlacementStop, VerificationStop } from "./operations.js";
-import type { ReviewValue } from "./review.js";
-import type { ProtocolTerminal } from "./run.js";
-export declare function decodeProtocolTerminal(value: unknown): ProtocolTerminal;
-export declare function decodeMergeStatePresentRefusal(value: unknown): MergeStatePresentRefusal;
-export declare function decodeDeliverConflictRefusal(value: unknown): DeliverConflictRefusal;
-export declare function decodeDeliveryPreparationRefusal(value: unknown): DeliveryPreparationRefusal;
-export declare function decodeIntentRefusal(value: unknown): IntentRefusal;
-export declare function decodeVerificationRuntimeStop(value: unknown): VerificationRuntimeStop;
-export declare function decodeVerificationStop(value: unknown): VerificationStop;
-export declare function decodeVerificationReuse(value: unknown): CurrentVerifiedAttestation;
-export declare function decodePlacementStop(value: unknown): PlacementStop;
-export declare function decodeVerificationCleanupFailure(value: unknown): VerificationCleanupFailure;
-export declare function decodeCandidateCompletion(value: unknown): CandidateCompletion;
-export declare function decodeCompletionEvidence(value: unknown): CompletionEvidence;
-export declare function decodeDeliverLeading(value: unknown): DeliverLeading;
-export declare function decodeMaterializedConflict(value: unknown): IntegrationConflictMaterialized;
-export declare function decodeAuditReport(value: unknown): AuditReport;
-export declare function decodeReviewValue(value: unknown): ReviewValue;