@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,488 +0,0 @@
-import { changeId, contractId, entryUlid, snapshotId } from "../core/facts/types.js";
-import { decodeDeliverData } from "../core/facts/codec.js";
-import { decodeAbandonRefusal } from "../core/verbs/abandon.js";
-import { decodeAmendRefusal } from "../core/verbs/amend.js";
-import { decodeArcRefusal } from "../core/verbs/arc.js";
-import { decodeAttestationRefusal } from "../core/verbs/attestation.js";
-import { decodeBindRefusal } from "../core/verbs/bind.js";
-import { decodeDeliverRefusal } from "../core/verbs/deliver.js";
-import { decodePlacementRefusal } from "../core/verbs/placement.js";
-import { decodeAuditTargetAnswer, decodeCheckoutNotFollowableRefusal, decodeDirtyWorkspaceRefusal, decodeHookFailure, decodeIntegrationPreparationRefusal, decodePublicationFailed, decodeUnmergedPathsRefusal, decodeWorktreeMissingRefusal, decodeWorktreeWorkspace, decodeWorkspaceDirtyDelta, } from "../git/result-codec.js";
-import { decodeVerificationDeclarationRefusal } from "../verification/declaration.js";
-import { decodeForkSourceMovedRefusal, decodeTargetInputRefusal } from "./bind.js";
-function fail() {
-    throw new Error("malformed protocol result");
-}
-function record(value, required, optional = []) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        fail();
-    const object = value;
-    const allowed = new Set([...required, ...optional]);
-    for (const key of Object.keys(object))
-        if (!allowed.has(key))
-            fail();
-    for (const key of required)
-        if (!(key in object))
-            fail();
-    return object;
-}
-function nonblank(value) {
-    if (typeof value !== "string" || value.trim() === "")
-        fail();
-    return value;
-}
-function nonempty(value) {
-    if (typeof value !== "string" || value.length === 0)
-        fail();
-    return value;
-}
-function integer(value) {
-    if (typeof value !== "number" || !Number.isInteger(value))
-        fail();
-    return value;
-}
-function boolean(value) {
-    if (typeof value !== "boolean")
-        fail();
-    return value;
-}
-function strings(value) {
-    if (!Array.isArray(value))
-        fail();
-    return value.map(nonblank);
-}
-function decodeContractId(value) {
-    try {
-        return contractId(nonblank(value));
-    }
-    catch {
-        fail();
-    }
-}
-function decodeSnapshotId(value) {
-    try {
-        return snapshotId(nonblank(value));
-    }
-    catch {
-        fail();
-    }
-}
-function decodeEntryUlid(value) {
-    try {
-        return entryUlid(nonblank(value));
-    }
-    catch {
-        fail();
-    }
-}
-function first(value, decoders) {
-    for (const decode of decoders) {
-        try {
-            return decode(value);
-        }
-        catch {
-            continue;
-        }
-    }
-    fail();
-}
-export function decodeProtocolTerminal(value) {
-    const object = record(value, ["kind"], ["diagnostic"]);
-    if (object.kind === "exhausted" || object.kind === "collision") {
-        if ("diagnostic" in object)
-            fail();
-        return { kind: object.kind };
-    }
-    return decodePublicationFailed(value);
-}
-export function decodeMergeStatePresentRefusal(value) {
-    const object = record(value, ["kind", "contractId", "workspace"]);
-    if (object.kind !== "merge-state-present")
-        fail();
-    return {
-        kind: "merge-state-present",
-        contractId: decodeContractId(object.contractId),
-        workspace: decodeWorktreeWorkspace(object.workspace),
-    };
-}
-export function decodeDeliverConflictRefusal(value) {
-    const object = record(value, ["kind", "contractId", "reason", "targetHead", "conflictPaths", "recovery"]);
-    if (object.kind !== "integration-failed" || object.reason !== "conflict")
-        fail();
-    const recovery = record(object.recovery, ["materialize", "deliver", "staging"]);
-    if (recovery.materialize !== "deliver --materialize-conflict --include-dirty")
-        fail();
-    if (recovery.deliver !== "deliver --include-dirty")
-        fail();
-    if (recovery.staging !== "not-required")
-        fail();
-    return {
-        kind: "integration-failed",
-        contractId: decodeContractId(object.contractId),
-        reason: "conflict",
-        targetHead: decodeSnapshotId(object.targetHead),
-        conflictPaths: strings(object.conflictPaths),
-        recovery: {
-            materialize: "deliver --materialize-conflict --include-dirty",
-            deliver: "deliver --include-dirty",
-            staging: "not-required",
-        },
-    };
-}
-function decodeTargetMissingRefusal(value) {
-    const object = record(value, ["kind", "contractId"]);
-    if (object.kind !== "target-missing")
-        fail();
-    return { kind: "target-missing", contractId: decodeContractId(object.contractId) };
-}
-export function decodeDeliveryPreparationRefusal(value) {
-    return first(value, [
-        decodeTargetMissingRefusal,
-        decodeWorktreeMissingRefusal,
-        decodeDirtyWorkspaceRefusal,
-        decodeUnmergedPathsRefusal,
-        decodeIntegrationPreparationRefusal,
-        decodeMergeStatePresentRefusal,
-        decodeCheckoutNotFollowableRefusal,
-    ]);
-}
-export function decodeIntentRefusal(value) {
-    return first(value, [
-        decodeAbandonRefusal,
-        decodeAmendRefusal,
-        decodeArcRefusal,
-        decodeBindRefusal,
-        decodeForkSourceMovedRefusal,
-        decodeDeliverRefusal,
-        decodeDeliveryPreparationRefusal,
-        decodeDeliverConflictRefusal,
-        decodePlacementRefusal,
-        decodeAttestationRefusal,
-        decodeTargetInputRefusal,
-        decodeVerificationDeclarationRefusal,
-    ]);
-}
-function decodeCapturedVerificationOutput(object) {
-    return {
-        ...("stdout" in object ? { stdout: nonempty(object.stdout) } : {}),
-        ...("stderr" in object ? { stderr: nonempty(object.stderr) } : {}),
-        ...("truncated" in object ? (object.truncated === true ? { truncated: true } : fail()) : {}),
-    };
-}
-export function decodeVerificationRuntimeStop(value) {
-    const object = record(value, ["failure"], ["diagnostic", "name", "detail", "stdout", "stderr", "truncated"]);
-    const output = decodeCapturedVerificationOutput(object);
-    if (object.failure === "unknown-exit" || object.failure === "cancelled") {
-        if ("diagnostic" in object || "name" in object || "detail" in object)
-            fail();
-        return { failure: object.failure, ...output };
-    }
-    if (object.failure === "candidate-unavailable" || object.failure === "spawn-error") {
-        if ("name" in object || "detail" in object)
-            fail();
-        return { failure: object.failure, diagnostic: nonblank(object.diagnostic), ...output };
-    }
-    if (object.failure !== "environment-failure")
-        fail();
-    if ("name" in object || "detail" in object) {
-        if ("diagnostic" in object)
-            fail();
-        return {
-            failure: "environment-failure",
-            name: nonblank(object.name),
-            detail: decodeHookFailure(object.detail),
-            ...output,
-        };
-    }
-    return { failure: "environment-failure", diagnostic: nonblank(object.diagnostic), ...output };
-}
-function decodeVerificationStepRefusal(value) {
-    const object = record(value, ["refusal"]);
-    return {
-        refusal: first(object.refusal, [decodeAttestationRefusal, decodeVerificationDeclarationRefusal]),
-    };
-}
-function decodeVerificationStepRetry(value) {
-    const object = record(value, ["retry"]);
-    return { retry: decodeProtocolTerminal(object.retry) };
-}
-export function decodeVerificationStop(value) {
-    return first(value, [decodeVerificationStepRefusal, decodeVerificationStepRetry, decodeVerificationRuntimeStop]);
-}
-export function decodeVerificationReuse(value) {
-    const object = record(value, ["entry", "verdict"], ["summary"]);
-    if (object.verdict !== "satisfied" && object.verdict !== "unsatisfied")
-        fail();
-    return {
-        entry: decodeEntryUlid(object.entry),
-        verdict: object.verdict,
-        ...(object.summary === undefined ? {} : { summary: typeof object.summary === "string" ? object.summary : fail() }),
-    };
-}
-function decodePlacementStepRefusal(value) {
-    return first(value, [
-        decodePlacementRefusal,
-        decodeCheckoutNotFollowableRefusal,
-        decodeIntegrationPreparationRefusal,
-        decodeTargetMissingRefusal,
-    ]);
-}
-function decodePlacementRefusalStop(value) {
-    const object = record(value, ["refusal"]);
-    return { refusal: decodePlacementStepRefusal(object.refusal) };
-}
-function decodePlacementRetryStop(value) {
-    const object = record(value, ["retry"]);
-    return { retry: decodeProtocolTerminal(object.retry) };
-}
-function decodeTargetPlacementFailedStop(value) {
-    const object = record(value, ["failure", "diagnostic"]);
-    if (object.failure !== "target-placement-failed")
-        fail();
-    return { failure: "target-placement-failed", diagnostic: nonblank(object.diagnostic) };
-}
-function decodeTargetMovedWithAttemptsStop(value) {
-    const object = record(value, [
-        "failure",
-        "contractId",
-        "target",
-        "integratedAt",
-        "observed",
-        "attempts",
-        "observedTreeEqualsCandidate",
-    ]);
-    if (object.failure !== "target-moved")
-        fail();
-    return {
-        failure: "target-moved",
-        contractId: decodeContractId(object.contractId),
-        target: nonblank(object.target),
-        integratedAt: decodeSnapshotId(object.integratedAt),
-        observed: object.observed === null ? null : decodeSnapshotId(object.observed),
-        attempts: integer(object.attempts),
-        observedTreeEqualsCandidate: boolean(object.observedTreeEqualsCandidate),
-    };
-}
-function decodeTargetMovedExpectedStop(value) {
-    const object = record(value, [
-        "failure",
-        "contractId",
-        "target",
-        "expected",
-        "observed",
-        "observedTreeEqualsCandidate",
-    ]);
-    if (object.failure !== "target-moved")
-        fail();
-    return {
-        failure: "target-moved",
-        contractId: decodeContractId(object.contractId),
-        target: nonblank(object.target),
-        expected: decodeSnapshotId(object.expected),
-        observed: object.observed === null ? null : decodeSnapshotId(object.observed),
-        observedTreeEqualsCandidate: boolean(object.observedTreeEqualsCandidate),
-    };
-}
-export function decodePlacementStop(value) {
-    return first(value, [
-        decodePlacementRefusalStop,
-        decodePlacementRetryStop,
-        decodeTargetPlacementFailedStop,
-        decodeTargetMovedWithAttemptsStop,
-        decodeTargetMovedExpectedStop,
-    ]);
-}
-export function decodeVerificationCleanupFailure(value) {
-    const object = record(value, ["phase", "name", "detail"]);
-    if (object.phase !== "destroy")
-        fail();
-    return { phase: "destroy", name: nonblank(object.name), detail: decodeHookFailure(object.detail) };
-}
-export function decodeCandidateCompletion(value) {
-    const object = record(value, ["integration"], ["predecessor", "target", "verification"]);
-    const completion = {
-        integration: decodeSnapshotId(object.integration),
-        ...(object.predecessor === undefined ? {} : { predecessor: decodeSnapshotId(object.predecessor) }),
-        ...(object.target === undefined ? {} : { target: nonblank(object.target) }),
-        ...(object.verification === undefined
-            ? {}
-            : {
-                verification: (() => {
-                    const verification = record(object.verification, ["mode", "verdict"]);
-                    if (verification.mode !== "ran" && verification.mode !== "reused")
-                        fail();
-                    if (verification.verdict !== "satisfied" && verification.verdict !== "unsatisfied")
-                        fail();
-                    return { mode: verification.mode, verdict: verification.verdict };
-                })(),
-            }),
-    };
-    return completion;
-}
-export function decodeCompletionEvidence(value) {
-    const object = record(value, [], ["completion", "verification", "verificationReuse", "verificationSummary", "placement"]);
-    return {
-        ...(object.completion === undefined ? {} : { completion: decodeCandidateCompletion(object.completion) }),
-        ...(object.verification === undefined ? {} : { verification: decodeVerificationStop(object.verification) }),
-        ...(object.verificationReuse === undefined
-            ? {}
-            : { verificationReuse: decodeVerificationReuse(object.verificationReuse) }),
-        ...(object.verificationSummary === undefined ? {} : { verificationSummary: nonblank(object.verificationSummary) }),
-        ...(object.placement === undefined ? {} : { placement: decodePlacementStop(object.placement) }),
-    };
-}
-export function decodeDeliverLeading(value) {
-    const object = record(value, ["kind", "fact"]);
-    if (object.kind !== "already-admitted")
-        fail();
-    return { kind: "already-admitted", fact: decodeEntryUlid(object.fact) };
-}
-export function decodeMaterializedConflict(value) {
-    const object = record(value, ["kind", "targetHead", "conflictPaths", "workspace", "handoffBase", "recovery"]);
-    if (object.kind !== "integration-conflict-materialized")
-        fail();
-    const recovery = record(object.recovery, ["materialize", "deliver", "staging"]);
-    if (recovery.materialize !== "deliver --materialize-conflict --include-dirty")
-        fail();
-    if (recovery.deliver !== "deliver --include-dirty")
-        fail();
-    if (recovery.staging !== "not-required")
-        fail();
-    return {
-        kind: "integration-conflict-materialized",
-        targetHead: decodeSnapshotId(object.targetHead),
-        conflictPaths: strings(object.conflictPaths),
-        workspace: decodeWorktreeWorkspace(object.workspace),
-        handoffBase: decodeSnapshotId(object.handoffBase),
-        recovery: {
-            materialize: "deliver --materialize-conflict --include-dirty",
-            deliver: "deliver --include-dirty",
-            staging: "not-required",
-        },
-    };
-}
-function decodeAuditReadyCandidate(value) {
-    const object = record(value, ["kind", "workspace", "identity", "scope"], ["diff"]);
-    if (object.kind !== "ready")
-        fail();
-    const scope = record(object.scope, ["filesChanged", "insertions", "deletions"], ["paths"]);
-    return {
-        kind: "ready",
-        workspace: decodeWorktreeWorkspace(object.workspace),
-        identity: decodeDeliverData(object.identity),
-        scope: {
-            filesChanged: integer(scope.filesChanged),
-            insertions: integer(scope.insertions),
-            deletions: integer(scope.deletions),
-            ...(scope.paths === undefined
-                ? {}
-                : {
-                    paths: Array.isArray(scope.paths)
-                        ? scope.paths.map((path) => (typeof path === "string" ? path : fail()))
-                        : fail(),
-                }),
-        },
-        ...(object.diff === undefined ? {} : { diff: typeof object.diff === "string" ? object.diff : fail() }),
-    };
-}
-function decodeAuditBlockedCandidate(value) {
-    const object = record(value, ["kind", "refusal"]);
-    if (object.kind !== "blocked")
-        fail();
-    return { kind: "blocked", refusal: decodeDeliveryPreparationRefusal(object.refusal) };
-}
-function decodeAuditVerification(value) {
-    return first(value, [
-        (input) => {
-            const object = record(input, ["kind"]);
-            if (object.kind !== "not-run")
-                fail();
-            return { kind: "not-run" };
-        },
-        (input) => {
-            const object = record(input, ["kind", "stop"]);
-            if (object.kind !== "stopped")
-                fail();
-            return { kind: "stopped", stop: decodeVerificationStop(object.stop) };
-        },
-        (input) => {
-            const object = record(input, ["kind", "passed", "total"], ["summary"]);
-            if (object.kind !== "satisfied" && object.kind !== "unsatisfied")
-                fail();
-            return {
-                kind: object.kind,
-                passed: typeof object.passed === "number" ? object.passed : fail(),
-                total: typeof object.total === "number" ? object.total : fail(),
-                ...(object.summary === undefined
-                    ? {}
-                    : { summary: typeof object.summary === "string" ? object.summary : fail() }),
-            };
-        },
-    ]);
-}
-function decodeNotObservedAuditTarget(value) {
-    const object = record(value, ["kind"]);
-    if (object.kind !== "not-observed")
-        fail();
-    return { kind: "not-observed" };
-}
-function decodeAuditTarget(value) {
-    return first(value, [decodeNotObservedAuditTarget, decodeAuditTargetAnswer]);
-}
-function decodeAuditDelivery(value) {
-    const delivery = record(value, ["changeId", "relation", "verification"]);
-    if (delivery.relation !== "identical" && delivery.relation !== "differs")
-        fail();
-    const valueVerification = record(delivery.verification, ["kind"], ["fact", "verdict"]);
-    const verification = valueVerification.kind === "undeclared" || valueVerification.kind === "unrecorded"
-        ? Object.keys(valueVerification).length === 1
-            ? { kind: valueVerification.kind }
-            : fail()
-        : valueVerification.kind === "recorded" &&
-            (valueVerification.verdict === "satisfied" || valueVerification.verdict === "unsatisfied")
-            ? {
-                kind: "recorded",
-                verdict: valueVerification.verdict,
-                fact: decodeEntryUlid(valueVerification.fact),
-            }
-            : fail();
-    try {
-        return { changeId: changeId(nonblank(delivery.changeId)), relation: delivery.relation, verification };
-    }
-    catch {
-        fail();
-    }
-}
-export function decodeAuditReport(value) {
-    const object = record(value, ["candidate", "verification", "target"], ["delivery"]);
-    return {
-        candidate: first(object.candidate, [decodeAuditBlockedCandidate, decodeAuditReadyCandidate]),
-        verification: decodeAuditVerification(object.verification),
-        target: decodeAuditTarget(object.target),
-        ...(object.delivery === undefined ? {} : { delivery: decodeAuditDelivery(object.delivery) }),
-    };
-}
-function decodeReviewWorkspaceEvidence(value) {
-    const object = record(value, ["staged", "unstaged", "untracked", "shortStat", "unmergedPaths"]);
-    const workspace = decodeWorkspaceDirtyDelta({
-        staged: object.staged,
-        unstaged: object.unstaged,
-        untracked: object.untracked,
-        shortStat: object.shortStat,
-    });
-    return { ...workspace, unmergedPaths: strings(object.unmergedPaths) };
-}
-export function decodeReviewValue(value) {
-    const object = record(value, [], ["completion", "verification", "verificationReuse", "verificationSummary", "placement", "workspace"]);
-    const evidence = decodeCompletionEvidence({
-        ...(object.completion === undefined ? {} : { completion: object.completion }),
-        ...(object.verification === undefined ? {} : { verification: object.verification }),
-        ...(object.verificationReuse === undefined ? {} : { verificationReuse: object.verificationReuse }),
-        ...(object.verificationSummary === undefined ? {} : { verificationSummary: object.verificationSummary }),
-        ...(object.placement === undefined ? {} : { placement: object.placement }),
-    });
-    return {
-        ...evidence,
-        ...(object.workspace === undefined ? {} : { workspace: decodeReviewWorkspaceEvidence(object.workspace) }),
-    };
-}

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

@@ -1,2 +0,0 @@
-import type { SettlementLag } from "./settle.js";
-export declare function decodeSettlementLag(value: unknown): SettlementLag;

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

@@ -1,56 +0,0 @@
-import { contractId } from "../core/facts/types.js";
-import { canonicalTaskId } from "../task/identity.js";
-function fail() {
-    throw new Error("malformed settlement lag");
-}
-function object(value, required, optional = []) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        fail();
-    const record = value;
-    const allowed = new Set([...required, ...optional]);
-    for (const key of Object.keys(record))
-        if (!allowed.has(key))
-            fail();
-    for (const key of required)
-        if (!(key in record))
-            fail();
-    return record;
-}
-function nonblank(value) {
-    if (typeof value !== "string" || value.trim() === "")
-        fail();
-    return value;
-}
-export function decodeSettlementLag(value) {
-    const record = object(value, ["kind", "surface", "contractId", "diagnostic"], ["taskId", "path"]);
-    if (record.kind !== "settlement-failed")
-        fail();
-    if (record.surface !== "task-holder" && record.surface !== "task")
-        fail();
-    let id;
-    try {
-        id = contractId(nonblank(record.contractId));
-    }
-    catch {
-        fail();
-    }
-    const lag = {
-        kind: "settlement-failed",
-        surface: record.surface,
-        contractId: id,
-        diagnostic: nonblank(record.diagnostic),
-    };
-    if (record.taskId !== undefined) {
-        try {
-            return {
-                ...lag,
-                taskId: canonicalTaskId(nonblank(record.taskId)),
-                ...(record.path === undefined ? {} : { path: nonblank(record.path) }),
-            };
-        }
-        catch {
-            fail();
-        }
-    }
-    return record.path === undefined ? lag : { ...lag, path: nonblank(record.path) };
-}

package/build/src/task/public.d.ts

@@ -1,2 +0,0 @@
-export { TASK_RELATION_PREDICATE_FIELDS, TaskAuthorityCorruptionError, Tasks } from "./index.js";
-export type * from "./index.js";

package/build/src/task/public.js

@@ -1 +0,0 @@
-export { TASK_RELATION_PREDICATE_FIELDS, TaskAuthorityCorruptionError, Tasks } from "./index.js";