@astrosheep/keiyaku 4.6.3 → 4.6.6

package/build/src/kanshi/read.js

@@ -1,5 +1,5 @@
 import { withoutReportedChanges } from "../akuma/projection.js";
-import { readAkumaRoster, readAkumaTimeline } from "../akuma/akuma.js";
+import { observeAkumaRoster, readAkumaTimeline } from "../akuma/akuma.js";
 import { readAliases } from "../alias/index.js";
 import { decodeContractDocument } from "../body/decode.js";
 import { assertRegionPattern } from "../body/region.js";
@@ -16,6 +16,7 @@ import { observeRecentTaskStatus, TaskAuthorityCorruptionError } from "../task/i
 import { observeTaskBoard } from "../task/operations.js";
 import { ROSTER_SNAPSHOT_ROWS, ROSTER_VISIBLE_ROWS } from "./roster.js";
 import { selectKanshi, selectRegion } from "./select.js";
+const WORLD_CONTRACT_ROWS = 10;
 function diagnostic(error) {
     let source;
     if (error instanceof Error)
@@ -128,12 +129,12 @@ async function readBranch(repo) {
         return null;
     }
 }
-async function readContracts(observation, include) {
+async function readContracts(observation, include, limit = WORLD_CONTRACT_ROWS) {
     try {
         return {
             kind: "present",
             value: include === undefined
-                ? await readContractCatalogue(observation, 10)
+                ? await readContractCatalogue(observation, limit)
                 : await readContractBoard(observation, include),
         };
     }
@@ -282,11 +283,12 @@ async function claimedAssociatedContracts(observation, dispatches) {
     }));
     return claimed;
 }
-async function joinAkuma(path, observeContract, isContractClaimed, dispatches, aliases) {
+async function joinAkuma(path, observeContract, isContractClaimed, dispatches, input) {
+    const { aliases, limit = ROSTER_VISIBLE_ROWS } = input;
     if (aliases.kind !== "present")
         return aliases;
     try {
-        const source = await readAkumaRoster(path, { limit: ROSTER_VISIBLE_ROWS });
+        const source = await observeAkumaRoster(path, limit);
         const aliasById = new Map();
         for (const binding of aliases.value)
             aliasById.set(binding.akuId, [...(aliasById.get(binding.akuId) ?? []), binding]);
@@ -355,7 +357,9 @@ async function observeWithoutRepo(world, region, observedAt, branch) {
     const observeContract = contractEndpointObserver(contracts);
     const tasks = world === null ? { kind: "absent" } : await readTasks(world, holders, observeContract);
     const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
-    const akuma = world === null ? { kind: "absent" } : await joinAkuma(world, observeContract, () => false, [], aliases);
+    const akuma = world === null
+        ? { kind: "absent" }
+        : await joinAkuma(world, observeContract, () => false, [], { aliases });
     return {
         report: {
             root: world,
@@ -394,7 +398,7 @@ async function observeRepo(input) {
                 ? { kind: "absent" }
                 : dispatches.kind === "failed"
                     ? dispatches
-                    : await joinAkuma(world, observeContract, (id) => claimed.has(id), dispatches.value, aliases);
+                    : await joinAkuma(world, observeContract, (id) => claimed.has(id), dispatches.value, { aliases });
             const assembled = {
                 root: world,
                 observedAt,
@@ -443,6 +447,67 @@ export async function observeKanshi(input) {
 export async function kanshi(input) {
     return (await observeKanshi(input)).report;
 }
+/** Category observations reuse owner rows without reading the Task board. */
+async function observeAkumaCategory(world, repo, limit, observedAt) {
+    const report = (akuma) => ({
+        category: "akuma",
+        root: world,
+        observedAt,
+        akuma,
+    });
+    if (world === null)
+        return report({ kind: "absent" });
+    const composed = async (observation) => {
+        const aliases = await readAliasBindings(world);
+        if (aliases.kind !== "present")
+            return report(aliases);
+        if (observation === undefined)
+            return report(await joinAkuma(world, () => "unavailable", () => false, [], { aliases, limit }));
+        const dispatches = await readDispatches(observation);
+        if (dispatches.kind === "failed")
+            return report(dispatches);
+        const claimed = await claimedAssociatedContracts(observation, dispatches.value);
+        return report(await joinAkuma(world, () => "unavailable", (id) => claimed.has(id), dispatches.value, { aliases, limit }));
+    };
+    if (repo === undefined)
+        return await composed();
+    try {
+        return await withGitDecodeChannel(repo, (channel) => withGitReadObservation(repo, channel, composed));
+    }
+    catch (error) {
+        return report({ kind: "failed", failure: { message: diagnostic(error) } });
+    }
+}
+async function observeContractCategory(world, repo, limit, observedAt) {
+    const report = (contracts) => ({
+        category: "contract",
+        root: world,
+        observedAt,
+        contracts,
+    });
+    try {
+        return await withGitDecodeChannel(repo, (channel) => withGitReadObservation(repo, channel, async (observation) => {
+            const [contracts, holders] = await Promise.all([
+                readContracts(observation, undefined, limit),
+                readHolders(observation),
+            ]);
+            return report(decorateContracts(contracts, holders));
+        }));
+    }
+    catch (error) {
+        return report({ kind: "failed", failure: { message: diagnostic(error) } });
+    }
+}
+export async function kanshiCategory(input) {
+    const observedAt = new Date().toISOString();
+    const { world, repo, category, limit = 10 } = input;
+    if (category === "contract") {
+        if (repo === undefined)
+            throw new TypeError("kanshi contract category requires a Repo");
+        return await observeContractCategory(world, scopeForRepo(repo), limit, observedAt);
+    }
+    return await observeAkumaCategory(world, repo === undefined ? undefined : scopeForRepo(repo), limit, observedAt);
+}
 async function attachSelectedIssue(observation, contracts, selected) {
     if (contracts.kind !== "present")
         return contracts;

package/build/src/kanshi/report.d.ts

@@ -100,4 +100,16 @@ export type KanshiReport = Readonly<{
     akuma: Section<AkumaKanshiWorld>;
     region?: Section<RegionRead>;
 }>;
+/** Internal category observation retains only the requested owner section. */
+export type KanshiCategoryReport = Readonly<{
+    category: "akuma";
+    root: WorldRoot | null;
+    observedAt: string;
+    akuma: Section<AkumaKanshiWorld>;
+}> | Readonly<{
+    category: "contract";
+    root: WorldRoot | null;
+    observedAt: string;
+    contracts: Section<ContractKanshiBoard>;
+}>;
 export type { CurrentPhysicalIssue };

package/build/src/library/akuma-creation.d.ts

@@ -15,8 +15,7 @@ import type { Settings } from "../settings.js";
 import { type WorldRoot } from "../world.js";
 import type { Keiyaku } from "./keiyaku.js";
 import { type Repo } from "./repo.js";
-export type { AkumaStatus } from "../akuma/akuma.js";
-export type IntegrationFailure = Readonly<{
+type IntegrationFailure = Readonly<{
     kind: "authority-corruption" | "infrastructure";
     diagnostic: string;
 }>;
@@ -30,7 +29,7 @@ export type DispatchStage = Readonly<{
     kind: "failed";
     failure: DispatchFailure | IntegrationFailure;
 }>;
-export type AliasStage = Readonly<{
+type AliasStage = Readonly<{
     kind: "none";
 }> | Readonly<{
     kind: "aliased";
@@ -47,7 +46,7 @@ export type CallWaitHead = Readonly<{
     dispatch: DispatchStage;
     alias: AliasStage;
 }>;
-export type CallWaitObserver = Readonly<{
+type CallWaitObserver = Readonly<{
     admitted?: (tell: TellResult, id: AkumaStatus["id"], head: CallWaitHead) => void | Promise<void>;
     observe?: AskObserver["observe"];
 }>;
@@ -117,3 +116,4 @@ export declare function callAkumas(input: CallInput & Readonly<{
 export declare function forkAkumas(input: ForkInput & Readonly<{
     path: WorldRoot;
 }>): Promise<ForkResult>;
+export {};

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

@@ -1,45 +1,11 @@
 import { decodeContractDocument } from "../body/decode.js";
 import { type ActorId, type ContractId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
-import { bindOperation, type BindTargetSelection } from "../protocol/bind.js";
+import { type BindTargetSelection } from "../protocol/bind.js";
 import { type IntentOutcome, type RepositoryScope } from "../protocol/operations.js";
 import type { ProtocolProgress } from "../protocol/progress.js";
 import type { TaskId } from "../task/identity.js";
-import type { VerificationDeclarationPreparation } from "../verification/declaration.js";
 import type { ForkSourceRefusal, OperationRefusals } from "./refusal.js";
-type BindAttemptInput = Readonly<{
-    scope: RepositoryScope;
-    channel: GitDecodeChannel;
-    title: string;
-    terms: Parameters<typeof bindOperation>[0]["terms"];
-    verification: VerificationDeclarationPreparation;
-    workspace: "worktree";
-    targetSelection?: BindTargetSelection;
-    coordinates?: Readonly<{
-        start: import("../core/facts/types.js").SnapshotId;
-    }>;
-    source?: Parameters<typeof bindOperation>[0]["source"];
-    task?: TaskId;
-    progress?: ProtocolProgress;
-    actor?: ActorId;
-}>;
-export declare function admitBindWithAppointment(input: BindAttemptInput): Promise<IntentOutcome<Readonly<{
-    contractId: ContractId;
-}>, {
-    kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
-    contractId: ContractId;
-} | {
-    kind: "verification-declaration-invalid";
-    contractId?: ContractId | undefined;
-} | {
-    kind: "fork-source-moved";
-    contractId: ContractId;
-} | {
-    kind: "unborn-head" | "target-missing" | "invalid-target";
-} | {
-    kind: "fork-source-missing" | "fork-source-unavailable";
-    contractId: ContractId;
-}>>;
 type ForkBindAdmission = Readonly<{
     kind: "document";
     document: ReturnType<typeof decodeContractDocument>;
@@ -62,34 +28,6 @@ export declare function admitForkBindWithAppointment(input: Readonly<{
     kind: "refused";
     refusal: ForkSourceRefusal;
 }> | ForkBindAdmission>;
-export declare function admitMarkdownBind(input: Readonly<{
-    scope: RepositoryScope;
-    channel: GitDecodeChannel;
-    title: string;
-    terms: Parameters<typeof bindOperation>[0]["terms"];
-    verification: VerificationDeclarationPreparation;
-    workspace: "worktree";
-    targetSelection?: BindTargetSelection;
-    task?: TaskId;
-    progress?: ProtocolProgress;
-    actor?: ActorId;
-}>): Promise<IntentOutcome<Readonly<{
-    contractId: ContractId;
-}>, {
-    kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
-    contractId: ContractId;
-} | {
-    kind: "verification-declaration-invalid";
-    contractId?: ContractId | undefined;
-} | {
-    kind: "fork-source-moved";
-    contractId: ContractId;
-} | {
-    kind: "unborn-head" | "target-missing" | "invalid-target";
-} | {
-    kind: "fork-source-missing" | "fork-source-unavailable";
-    contractId: ContractId;
-}>>;
 export declare function prepareMarkdownBind(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;

package/build/src/library/bind.js

@@ -7,7 +7,7 @@ import { mintIdentitySegment } from "../identity/mint.js";
 import { fitIdentityStemWords, normalizeIdentityStem } from "../identity/normalize.js";
 import { bindOperation } from "../protocol/bind.js";
 import { stateOperation } from "../protocol/operations.js";
-import { claimTaskHolder, claimTaskHolderWithFence } from "../settlement/holder.js";
+import { admitWithTaskHolderFence, claimTaskHolder } from "../settlement/holder.js";
 import { KeiyakuError } from "./outcome.js";
 import { contractTerms, documentDerivation } from "./input.js";
 const CONTRACT_ID_CODE_POINTS = 32;
@@ -48,9 +48,6 @@ async function attemptCandidates(input) {
         collision: (result) => result.kind === "refused" && result.refusal.kind === "contract-exists",
     });
 }
-export async function admitBindWithAppointment(input) {
-    return await attemptCandidates(input);
-}
 /**
  * A legally non-forkable source is an expected refusal; corrupt persisted authority for a source that
  * does exist is exceptional and names that source Contract.
@@ -119,12 +116,9 @@ export async function admitForkBindWithAppointment(input) {
     });
     return { kind: "document", admission, document };
 }
-export async function admitMarkdownBind(input) {
-    return await admitBindWithAppointment(input);
-}
 export async function prepareMarkdownBind(input) {
     const terms = contractTerms(input.document, input.gates, input.after);
-    const admitCandidate = () => admitMarkdownBind({
+    const admitCandidate = () => attemptCandidates({
         scope: input.scope,
         channel: input.channel,
         title: input.document.title,
@@ -136,6 +130,6 @@ export async function prepareMarkdownBind(input) {
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         ...(input.progress === undefined ? {} : { progress: input.progress }),
     });
-    const admission = input.task === undefined ? null : await claimTaskHolderWithFence(input.scope, input.task, admitCandidate);
+    const admission = input.task === undefined ? null : await admitWithTaskHolderFence(input.scope, input.task, admitCandidate);
     return { admission, result: admission === null ? await admitCandidate() : admission.result };
 }

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

@@ -12,7 +12,7 @@ import { captureLocalContractComposition, derivedGates, derivedHooks, gateNames,
 import { actorOption, normalizedList, requireInput, requireMarkdown, taskOption } from "./input.js";
 import { InvocationAccumulator } from "./invocation.js";
 import { project, validated } from "./outcome.js";
-import { completeReconcile } from "./reconcile.js";
+import { reconcileAffectedContracts } from "./reconcile.js";
 import { observeRegion } from "./region.js";
 import { scopeForRepo } from "./repo.js";
 function bindInput(input, composition) {
@@ -122,7 +122,7 @@ function bindValue(keiyaku, region, warnings, workspace, appointmentLag) {
 // eslint-disable-next-line max-params -- Keep this local operation's custody, admission, and policy witnesses explicit.
 async function bindComplete(accumulator, id, scope, channel, leading, hooks, value) {
     retainAdmission(accumulator, id, leading, false);
-    await reconcileAll(accumulator, id, scope, channel, hooks);
+    await reconcileAffectedContracts(accumulator, id, scope, channel, hooks);
     try {
         const appointment = await readManagedWorktreeAppointment(scope, id);
         if (appointment.kind === "appointed")
@@ -139,34 +139,6 @@ async function bindComplete(accumulator, id, scope, channel, leading, hooks, val
     accumulator.extendConclusions(id, conclusions(built));
     return built;
 }
-async function reconcileAll(accumulator, id, scope, channel, hooks) {
-    for (const contract of [...new Set([id, ...accumulator.snapshot().affected])]) {
-        try {
-            accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "started" });
-            const report = await (async () => {
-                try {
-                    return await completeReconcile({
-                        scope,
-                        channel,
-                        contractId: contract,
-                        hooks,
-                        retryHooks: false,
-                        progress: accumulator,
-                    });
-                }
-                finally {
-                    accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "finished" });
-                }
-            })();
-            void report;
-        }
-        catch (error) {
-            if (!isOperationalStop(error, scope.signal))
-                throw error;
-            accumulator.recordStop(executionStop(contract, "reconciliation", error, scope.signal));
-        }
-    }
-}
 // eslint-disable-next-line max-params -- Keep this local operation's custody, admission, and policy witnesses explicit.
 async function markdownBind(prepared, document, hooks, scope, channel, accumulator, handle, omittedMarkdownTarget) {
     const { task, target, actor, gates, after } = prepared;

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

@@ -27,5 +27,4 @@ export declare class ContractExecution {
     /** One accumulator before the first admission-capable await, one projector after teardown. */
     private local;
     private conclude;
-    private reconcileContracts;
 }

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

@@ -25,7 +25,7 @@ import { deliveryForContract } from "./delivery.js";
 import { actorOption, contractTerms, documentDerivation, normalizedList, optionalBoolean, optionalNonblank, optionalSignal, requireInput, requireMarkdown, } from "./input.js";
 import { InvocationAccumulator } from "./invocation.js";
 import { KeiyakuError, errorCategory, project, validated, } from "./outcome.js";
-import { completeReconcile } from "./reconcile.js";
+import { reconcileAffectedContracts } from "./reconcile.js";
 import { observeChangedRegion } from "./region.js";
 export class ContractExecution {
     seat;
@@ -157,6 +157,7 @@ export class ContractExecution {
                 if (outcome.kind !== "accepted")
                     return expected(this.id, outcome);
                 leadingValue = outcome.value;
+                accumulator.extendConclusions(this.id, { leading: outcome.value.leading });
                 stage = "verification";
                 await advanceAndContinue(accumulator, scope, localChannel, this.id, this.composition, outcome, values.signal, "verification");
             }
@@ -168,12 +169,13 @@ export class ContractExecution {
             const retained = accumulator.conclusions(this.id) ?? {};
             const value = { ...base, ...leadingValue, ...retained };
             accumulator.recordConclusions(this.id, value);
-            await this.reconcileContracts(accumulator, scope, localChannel, hooks);
+            await reconcileAffectedContracts(accumulator, this.id, scope, localChannel, hooks);
             return acceptedOutcome("deliver", this.id, accumulator, deliveryForContract(this.scope, value));
         }, values.signal, observer);
     }
     async review(input, options) {
-        const values = validated(() => requireInput(input, "review input", ["verdict", "summary", "signal"]));
+        const values = validated(() => requireInput(input, "review input", ["verdict", "summary", "actor", "signal"]));
+        const actor = validated(() => actorOption(values.actor));
         const verdict = values.verdict;
         if (verdict !== "satisfied" && verdict !== "unsatisfied")
             throw new KeiyakuError("invalid-input", "verdict must be satisfied or unsatisfied", {
@@ -195,6 +197,7 @@ export class ContractExecution {
                     contractId: this.id,
                     verdict,
                     ...(summary === undefined ? {} : { summary }),
+                    ...actor,
                 },
             });
         const hooks = derivedHooks(this.composition);
@@ -209,6 +212,7 @@ export class ContractExecution {
                     contractId: this.id,
                     progress: accumulator,
                     ...(this.composition.actor === undefined ? {} : { actor: this.composition.actor }),
+                    ...actor,
                     ...(signal === undefined ? {} : { signal }),
                     verdict,
                     ...(summary === undefined ? {} : { summary }),
@@ -229,7 +233,7 @@ export class ContractExecution {
             }
             const retained = { ...value, ...accumulator.conclusions(this.id) };
             accumulator.extendConclusions(this.id, retained);
-            await this.reconcileContracts(accumulator, scope, localChannel, hooks);
+            await reconcileAffectedContracts(accumulator, this.id, scope, localChannel, hooks);
             return acceptedOutcome("review", this.id, accumulator, retained);
         }, signal, observer);
     }
@@ -379,38 +383,9 @@ export class ContractExecution {
         retainAdmission(accumulator, this.id, input.leading, input.verificationResidueRecorded);
         const value = input.value(input.leading.value);
         accumulator.extendConclusions(this.id, conclusions(value));
-        await this.reconcileContracts(accumulator, input.scope, input.channel, input.hooks);
+        await reconcileAffectedContracts(accumulator, this.id, input.scope, input.channel, input.hooks);
         return value;
     }
-    async reconcileContracts(accumulator, scope, channel, hooks) {
-        for (const contract of [...new Set([this.id, ...accumulator.snapshot().affected])]) {
-            try {
-                scope.signal?.throwIfAborted();
-                accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "started" });
-                const report = await (async () => {
-                    try {
-                        return await completeReconcile({
-                            scope,
-                            channel,
-                            contractId: contract,
-                            hooks,
-                            retryHooks: false,
-                            progress: accumulator,
-                        });
-                    }
-                    finally {
-                        accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "finished" });
-                    }
-                })();
-                void report;
-            }
-            catch (error) {
-                if (!isOperationalStop(error, scope.signal))
-                    throw error;
-                accumulator.recordStop(executionStop(contract, "reconciliation", error, scope.signal));
-            }
-        }
-    }
 }
 function changedAmendTerms(before, after) {
     return {

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

@@ -55,17 +55,20 @@ declare const reviewRequestSchema: z.ZodPipe<z.ZodObject<{
         unsatisfied: "unsatisfied";
     }>;
     summary: z.ZodOptional<z.ZodString>;
+    actor: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodTransform<{
     repoRoot: string;
     contractId: import("../core/facts/types.js").ContractId;
     verdict: "satisfied" | "unsatisfied";
     summary?: string | undefined;
+    actor?: string | undefined;
     action: "contract.review";
 }, {
     repoRoot: string;
     contractId: import("../core/facts/types.js").ContractId;
     verdict: "satisfied" | "unsatisfied";
     summary?: string | undefined;
+    actor?: string | undefined;
 }>>;
 export type ContractRequest = z.infer<typeof auditRequestSchema> | z.infer<typeof deliverRequestSchema> | z.infer<typeof reviewRequestSchema>;
 type DeliverRequest = Extract<ContractRequest, {
@@ -174,6 +177,7 @@ declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
                 path: z.ZodString;
             }, z.core.$strict>;
             identity: z.ZodObject<{
+                note: z.ZodOptional<z.ZodString>;
                 tenderSnapshot: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
                 integration: z.ZodObject<{
                     predecessor: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
@@ -376,7 +380,7 @@ declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
     contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
     reviewFactId: z.ZodString;
 }, z.core.$strict>]>;
-export type ContractService = z.infer<typeof contractServiceSchema>;
+type ContractService = z.infer<typeof contractServiceSchema>;
 type ContractReference = ContractService | z.infer<typeof materializedHandoffReferenceSchema>;
 export type ContractRequestPort = Readonly<{
     audit(input: AuditRequest & Readonly<{

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

@@ -4,7 +4,7 @@ import { AkumaBodyRequestError, requestBodyCommand } from "../akuma/request-rend
 import { eraseRequestCommand, } from "../akuma/request-wire.js";
 import { auditReportSchema } from "../protocol/audit.js";
 import { materializedConflictSchema } from "../protocol/deliver.js";
-import { decodeExecutionObservation, observeExecution, } from "../protocol/execution-observation.js";
+import { observationSchema, observeExecution } from "../protocol/execution-observation.js";
 import { contractIdSchema } from "../protocol/operations.js";
 import { deliveryValueSchema } from "./delivery.js";
 import { InvocationAccumulator } from "./invocation.js";
@@ -27,7 +27,11 @@ const deliverRequestSchema = contractRequestBaseSchema
 })
     .transform((request) => ({ action: "contract.deliver", ...request }));
 const reviewRequestSchema = contractRequestBaseSchema
-    .extend({ verdict: z.enum(["satisfied", "unsatisfied"]), summary: nonblankStringSchema.optional() })
+    .extend({
+    verdict: z.enum(["satisfied", "unsatisfied"]),
+    summary: nonblankStringSchema.optional(),
+    actor: z.string().optional(),
+})
     .transform((request) => ({ action: "contract.review", ...request }));
 const auditServiceSchema = z
     .object({
@@ -250,7 +254,7 @@ export async function requestForwardedContractLive(input) {
         value: input.request,
         onProgress: (value) => {
             try {
-                observeExecution(input.observe, decodeExecutionObservation(value));
+                observeExecution(input.observe, observationSchema.parse(value));
             }
             catch {
                 observeExecution(input.observe, { kind: "progress-dropped", count: 1 });

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

@@ -72,7 +72,7 @@ export type KeiyakuSelectInput = Readonly<{
     repo: Repo;
     id: ContractId;
 }>;
-export type ReviewInput = Readonly<{
+export type ReviewInput = ActorOptions & Readonly<{
     verdict: AttestationData["verdict"];
     summary?: string;
     signal?: AbortSignal;