@registrystack/client 0.38.0 → 0.40.0

package/breg/index.d.ts

@@ -7,6 +7,13 @@ export declare class BaseRegistryClient {
   ready(): Promise<CompleteOutcome>
   openapi(accessProfile?: string | undefined | null): Promise<RawOutcome>
   registryMetadata(accessProfile?: string | undefined | null): Promise<RawOutcome>
+  statisticsLive(dataset: string, from?: string | undefined | null, to?: string | undefined | null, accessProfile?: string | undefined | null, format?: string | undefined | null): Promise<RawOutcome>
+  statisticsReleases(dataset: string, top?: number | undefined | null, skipToken?: string | undefined | null, accessProfile?: string | undefined | null): Promise<RawOutcome>
+  statisticsLatestRelease(dataset: string, period: string, selection: string, accessProfile?: string | undefined | null, format?: string | undefined | null): Promise<RawOutcome>
+  statisticsReleaseVersion(dataset: string, period: string, version: number, accessProfile?: string | undefined | null, format?: string | undefined | null): Promise<RawOutcome>
+  statisticsReleaseSeries(dataset: string, from: string, to: string, selection: string, accessProfile?: string | undefined | null, format?: string | undefined | null): Promise<RawOutcome>
+  statisticsPublish(dataset: string, period: string, status: string, accessProfile: string, idempotencyKey: string): Promise<RawOutcome>
+  statisticsWithdraw(dataset: string, period: string, version: number, reason: string, accessProfile: string, idempotencyKey: string): Promise<RawOutcome>
   registryContract(accessProfile?: string | undefined | null): Promise<BRegMetadata>
   entitySchema(entityIdentifier: string, accessProfile?: string | undefined | null): Promise<RawOutcome>
   /** Retrieve one bounded first page of record revisions as inert JSON. */
@@ -30,8 +37,29 @@ export declare class BaseRegistryClient {
   lookupRecord(entityRoute: string, selector: string, values?: any | undefined | null, options?: any | undefined | null): Promise<CompleteOutcome>
   /** Fetch opaque target conditions for one metadata-selected action. */
   actionTargetConditions(binding: BRegImmediateActionBinding, inputs: any): Promise<BRegActionTargetConditions>
-  /** Invoke one metadata-selected immediate action without automatic retry. */
+  /**
+   * Invoke one metadata-selected immediate action. An invocation whose
+   * outcome is unknown is resent identically under the same key, at most
+   * `maxMutationRetries` times.
+   */
   invokeAction(binding: BRegImmediateActionBinding, inputs: any, idempotencyKey: string, conditions?: BRegActionTargetConditions | undefined | null): Promise<CompleteOutcome>
+  /**
+   * Prepare inert invocation evidence before any token acquisition or I/O.
+   * Persist `toBytes` before invoking so a lost response can be recovered.
+   */
+  prepareAction(binding: BRegImmediateActionBinding, inputs: any, idempotencyKey: string, conditions?: BRegActionTargetConditions | undefined | null): BRegPreparedAction
+  /**
+   * Revalidate saved invocation evidence against freshly selected authority
+   * and the caller's original inputs and key. The saved target conditions
+   * are reused exactly; this never fetches conditions or sends a request.
+   */
+  recoverAction(binding: BRegImmediateActionBinding, prepared: BRegPreparedAction, inputs: any, idempotencyKey: string): BRegRecoveredAction
+  /**
+   * Explicitly send a recovered invocation under its original key. An
+   * invocation whose outcome is unknown is resent identically under that
+   * key, at most `maxMutationRetries` times.
+   */
+  executeRecoveredAction(binding: BRegImmediateActionBinding, recovered: BRegRecoveredAction): Promise<CompleteOutcome>
   createRecord(binding: BRegCreateBinding, data: any, idempotencyKey: string, formatValue?: string | undefined | null): Promise<CompleteOutcome>
   /** Prepare inert Create evidence before any token acquisition or I/O. */
   prepareCreate(binding: BRegCreateBinding, data: any, idempotencyKey: string, formatValue?: string | undefined | null): BRegPreparedCreate
@@ -40,7 +68,11 @@ export declare class BaseRegistryClient {
   /** Explicitly send a recovered Create request with fresh authority. */
   executeRecoveredCreate(binding: BRegCreateBinding, recovered: BRegRecoveredCreate): Promise<CompleteOutcome>
   patchRecord(binding: BRegPatchBinding, recordIdentifier: string, etag: string, operations: any, idempotencyKey: string, formatValue?: string | undefined | null): Promise<CompleteOutcome>
-  /** Execute one metadata-selected atomic batch without automatic retry. */
+  /**
+   * Execute one metadata-selected atomic batch. A batch whose outcome is
+   * unknown is resent identically under the same key, at most
+   * `maxMutationRetries` times.
+   */
   batchRecords(binding: BRegBatchBinding, request: any, idempotencyKey: string): Promise<CompleteOutcome>
   /**
    * Announce one whole input and open a durable ingestion run for it. The
@@ -109,6 +141,12 @@ export declare class BaseRegistryClient {
   actionTargetConditionsJson(binding: BRegImmediateActionBinding, inputsJson: string): Promise<BRegActionTargetConditions>
   /** Invoke an action from exact JSON and preserve exact receipt values. */
   invokeActionJson(binding: BRegImmediateActionBinding, inputsJson: string, idempotencyKey: string, conditions?: BRegActionTargetConditions | undefined | null): Promise<JsonOutcome>
+  /** Prepare inert invocation evidence from exact action-input JSON. */
+  prepareActionJson(binding: BRegImmediateActionBinding, inputsJson: string, idempotencyKey: string, conditions?: BRegActionTargetConditions | undefined | null): BRegPreparedAction
+  /** Revalidate saved invocation evidence against exact original input JSON. */
+  recoverActionJson(binding: BRegImmediateActionBinding, prepared: BRegPreparedAction, inputsJson: string, idempotencyKey: string): BRegRecoveredAction
+  /** Explicitly send a recovered invocation and preserve exact receipt values. */
+  executeRecoveredActionJson(binding: BRegImmediateActionBinding, recovered: BRegRecoveredAction): Promise<JsonOutcome>
   createRecordJson(binding: BRegCreateBinding, dataJson: string, idempotencyKey: string, formatValue?: string | undefined | null): Promise<JsonOutcome>
   /** Prepare inert Create evidence from exact JSON text. */
   prepareCreateJson(binding: BRegCreateBinding, dataJson: string, idempotencyKey: string, formatValue?: string | undefined | null): BRegPreparedCreate
@@ -224,6 +262,8 @@ export declare class BRegMetadata {
   get immediateActions(): any
   /** Original caller-filtered action metadata as exact JSON text. */
   get actionsJson(): string | null
+  /** Validated caller-filtered statistical dataset descriptions, without entity authority. */
+  get statisticalDatasets(): any | null
   /** Descriptive change-request capability for one entity, when advertised. */
   changeRequestCapability(entityIdentifier: string): any | null
   get registryIdentifier(): string
@@ -244,6 +284,19 @@ export type Metadata = BRegMetadata
 export declare class BRegPatchBinding {}
 export type PatchBinding = BRegPatchBinding
 
+/**
+ * Inert original immediate-action invocation evidence. The bytes carry the
+ * inputs, saved target conditions, and idempotency key, but no token or
+ * executable metadata authority.
+ */
+export declare class BRegPreparedAction {
+  /** Restore bounded inert evidence previously returned by `toBytes`. */
+  static fromBytes(bytes: Buffer): BRegPreparedAction
+  /** Copy the exact evidence bytes for owner-protected persistence. */
+  toBytes(): Buffer
+}
+export type PreparedAction = BRegPreparedAction
+
 /**
  * Inert original Create request evidence. The bytes carry values and an
  * idempotency key, but no token or executable metadata authority.
@@ -268,6 +321,14 @@ export declare class BRegPreparedLifecycle {
 }
 export type PreparedLifecycle = BRegPreparedLifecycle
 
+/**
+ * A recovered immediate-action invocation and key. This remains inert until
+ * `executeRecoveredAction` is explicitly called with freshly selected
+ * authority.
+ */
+export declare class BRegRecoveredAction {}
+export type RecoveredAction = BRegRecoveredAction
+
 /**
  * A recovered Create request, key, and representation. This remains inert
  * until `executeRecoveredCreate` is explicitly called with fresh authority.
@@ -369,6 +430,7 @@ export interface RawOutcome {
   mediaType: string
   traceId: string
   etag?: string
+  reprDigest?: string
 }
 
 /** Authenticated BReg webhook metadata and exact body. */

package/casework/client.d.ts

@@ -13,15 +13,23 @@ export interface CaseworkClientConfig {
   maxResponseBytes?: SafeInteger | null
   userAgent?: string | null
   trustedRootCertificates?: string | null
+  /**
+   * How many times an idempotency-keyed mutation whose outcome is unknown is
+   * resent, identically and under the same key, before its error is
+   * returned: a whole number from 0 to 2, default 2; 0 sends it once. Reads,
+   * unkeyed operations, and review request create and cancel are never
+   * resent. Any other value is a `configuration` error.
+   */
+  maxMutationRetries?: SafeInteger | null
 }
 
-export type InboxView = 'mine' | 'my_teams' | 'team_holdings' | 'overdue' | 'completed_by_me'
+export type InboxView = 'mine' | 'my-teams' | 'team-holdings' | 'overdue' | 'completed-by-me'
 export type OccurrenceKind = 'review' | 'application'
-export type OccurrenceState = 'open' | 'claimed' | 'waiting_applicant' | 'waiting_application' | 'synchronizing' | 'completed' | 'superseded' | 'cancelled'
+export type OccurrenceState = 'open' | 'claimed' | 'waiting-applicant' | 'waiting-application' | 'synchronizing' | 'completed' | 'superseded' | 'cancelled'
 export type OperationName = string
 export type AttemptState = 'pending' | 'uncertain' | 'completed' | 'refused'
-export type PageStatus = 'complete' | 'budget_exhausted' | 'source_unavailable'
-export type HistoryKind = 'observed' | 'opened' | 'claimed' | 'assigned' | 'delegated' | 'caseload_moved' | 'clock_reminder' | 'clock_step_applied' | 'clock_recomputed' | 'released' | 'draft_saved' | 'attempt_reserved' | 'attempt_uncertain' | 'action_completed' | 'attempt_settled' | 'superseded' | 'completed'
+export type PageStatus = 'complete' | 'budget-exhausted' | 'source-unavailable'
+export type HistoryKind = 'observed' | 'opened' | 'claimed' | 'assigned' | 'delegated' | 'caseload-moved' | 'clock-reminder' | 'clock-step-applied' | 'clock-recomputed' | 'released' | 'draft-saved' | 'attempt-reserved' | 'attempt-uncertain' | 'action-completed' | 'attempt-settled' | 'superseded' | 'completed'
 
 export interface IssuerPrincipal { issuer: string; subject: string }
 export type TaskGrantBounds = { type: 'evidence'; requirement: string } | { type: 'breg'; permissions: ReadonlyArray<TaskPermission> } | { type: 'scheduling'; permissions: ReadonlyArray<SchedulingTaskPermission> }
@@ -94,14 +102,14 @@ export interface WorkItem {
 }
 export interface Page<T> { items: ReadonlyArray<T>; nextCursor?: string; status: PageStatus }
 export interface WorkItemPage extends Page<WorkItem> { servedQueues: ReadonlyArray<string> }
-export type DirectoryTargetPurpose = 'assignment' | 'absence_person' | 'absence_cover'
+export type DirectoryTargetPurpose = 'assignment' | 'absence-person' | 'absence-cover'
 export type DirectoryTargetsQuery = {
   cursor?: string
   limit?: SafeInteger
 } & (
   | { purpose: 'assignment'; queue: string; personIssuer?: never; personSubject?: never }
-  | { purpose: 'absence_person'; queue?: never; personIssuer?: never; personSubject?: never }
-  | { purpose: 'absence_cover'; queue?: never; personIssuer: string; personSubject: string }
+  | { purpose: 'absence-person'; queue?: never; personIssuer?: never; personSubject?: never }
+  | { purpose: 'absence-cover'; queue?: never; personIssuer: string; personSubject: string }
 )
 export type DirectoryTargetPage = Page<DirectoryMember>
 export type ListWorkItemsQuery = {
@@ -167,11 +175,11 @@ export interface HistoryEntryBase {
   profileId: string
 }
 export interface AttemptReservedHistoryEntry extends HistoryEntryBase {
-  kind: 'attempt_reserved'
+  kind: 'attempt-reserved'
   detail: JsonObject & { attemptId: string; bindingReference: string; operation: OperationName }
 }
 /**
- * An attempt_uncertain detail takes one of three shapes: recovery left the
+ * An attempt-uncertain detail takes one of three shapes: recovery left the
  * attempt uncertain, the source definitively refused it, or an operator marked
  * an expired pending attempt uncertain. reason is the original decision reason.
  */
@@ -186,19 +194,19 @@ export type AttemptUncertainHistoryDetail = JsonObject & {
   | { operatorReason: string; decidedBy: string; originalActor: IssuerPrincipal; originalProfileId: string; definitivelyRefused?: never }
 )
 export interface AttemptUncertainHistoryEntry extends HistoryEntryBase {
-  kind: 'attempt_uncertain'
+  kind: 'attempt-uncertain'
   detail: AttemptUncertainHistoryDetail
 }
 export interface ActionCompletedHistoryEntry extends HistoryEntryBase {
-  kind: 'action_completed'
+  kind: 'action-completed'
   detail: JsonObject & { attemptId: string; bindingReference: string; sourceRevision: string; sourceReceipt: SourceReceipt }
 }
 export interface AttemptSettledHistoryEntry extends HistoryEntryBase {
-  kind: 'attempt_settled'
-  detail: JsonObject & { attemptId: string; bindingReference: string; operation: OperationName; outcome: 'applied' | 'not_applied'; reason: string; decidedBy: string }
+  kind: 'attempt-settled'
+  detail: JsonObject & { attemptId: string; bindingReference: string; operation: OperationName; outcome: 'applied' | 'not-applied'; reason: string; decidedBy: string }
 }
 export interface OtherHistoryEntry extends HistoryEntryBase {
-  kind: Exclude<HistoryKind, 'attempt_reserved' | 'attempt_uncertain' | 'action_completed' | 'attempt_settled'>
+  kind: Exclude<HistoryKind, 'attempt-reserved' | 'attempt-uncertain' | 'action-completed' | 'attempt-settled'>
   detail: JsonValue
 }
 export type HistoryEntry = AttemptReservedHistoryEntry | AttemptUncertainHistoryEntry | ActionCompletedHistoryEntry | AttemptSettledHistoryEntry | OtherHistoryEntry
@@ -220,9 +228,9 @@ export interface CalendarPolicy { id: string; timezone: string; workingWeekdays:
 export interface ClockReminder { id: string; workingDaysBefore: SafeInteger }
 export interface ClockStep { id: string; because: string; at: 'due'; action: { reassign: { queue: string } } }
 export type ClockPolicy = {
-  scope: 'subject'; id: string; anchor: 'firstSubmittedAt'; completeOn: 'reviewCompleted'; after: { elapsed: string }; pauseWhile: ReadonlyArray<'awaitingApplicant'>
+  type: 'subject'; id: string; anchor: 'first-submitted-at'; completeOn: 'review-completed'; after: { elapsed: string }; pauseWhile: ReadonlyArray<'awaiting-applicant'>
 } | {
-  scope: 'activity'; id: string; anchor: 'stageEnteredAt'; calendar: string; after: { workingDays: SafeInteger }; dueTime: string;
+  type: 'activity'; id: string; anchor: 'stage-entered-at'; calendar: string; after: { workingDays: SafeInteger }; dueTime: string;
   atRisk?: { workingDaysBefore: SafeInteger }; reminders?: ReadonlyArray<ClockReminder>; steps?: ReadonlyArray<ClockStep>
 }
 export interface SourcePolicy {
@@ -252,14 +260,14 @@ export interface AbsenceInput { person: IssuerPrincipal; from: string; until: st
 export interface AbsenceRecord extends AbsenceInput { absenceId: string; revision: SafeInteger }
 export interface AbsencesQuery { cursor?: string; limit?: SafeInteger }
 export interface AbsenceList { directoryRevision: SafeInteger; items: ReadonlyArray<AbsenceRecord>; nextCursor?: string }
-export interface AssignmentContext { owner?: IssuerPrincipal; assignedBy?: IssuerPrincipal; absenceIds: ReadonlyArray<string>; staffingDiagnostic?: 'no_cover_available' }
+export interface AssignmentContext { owner?: IssuerPrincipal; assignedBy?: IssuerPrincipal; absenceIds: ReadonlyArray<string>; staffingDiagnostic?: 'no-cover-available' }
 export interface AssignmentRequest { assignee: IssuerPrincipal; reason?: string }
 export interface DelegateRequest { delegate: IssuerPrincipal; reason?: string }
 export interface CaseloadMoveRequest { from: IssuerPrincipal; to: IssuerPrincipal; queueId?: string; reason: string }
 export interface CaseloadItemSelection { itemId: string; expectedRevision: SafeInteger }
 export interface CaseloadApplyRequest { movement: CaseloadMoveRequest; items: ReadonlyArray<CaseloadItemSelection> }
 export interface CaseloadPreviewQuery { cursor?: string; limit?: SafeInteger }
-export interface CaseloadItemResult { itemId: string; result: 'moved' | 'not_visible' | 'not_eligible' | 'attempt_in_progress' | 'conflict'; revision?: SafeInteger }
+export interface CaseloadItemResult { itemId: string; result: 'moved' | 'not-visible' | 'not-eligible' | 'attempt-in-progress' | 'conflict'; revision?: SafeInteger }
 export interface BootstrapDirectoryRequest {
   teamId: string
   staff: ReadonlyArray<IssuerPrincipal>
@@ -316,10 +324,23 @@ export type KnownCaseworkProblemCode =
   | 'work-item.source-unavailable'
   | 'work-item.superseded'
 export type CaseworkProblemCode = KnownCaseworkProblemCode | (string & {})
-export type CaseworkProtocolFailure = 'header_bounds' | 'trace_context' | 'media_type' | 'body' | 'problem' | 'status' | 'protocol'
+export type CaseworkProtocolFailure = 'header-bounds' | 'trace-context' | 'media-type' | 'body' | 'problem' | 'status' | 'protocol'
 
 export class CaseworkClientError extends Error {
-  readonly kind: 'configuration' | 'invalid_request' | 'transport' | 'problem' | 'protocol'
+  readonly kind: 'configuration' | 'invalid-request' | 'transport' | 'problem' | 'protocol'
+  /**
+   * Whether the request may have taken effect although this error was
+   * raised: a timeout or broken exchange after sending, an unusable answer,
+   * or a 5xx. When true, recover a keyed request by sending it again under
+   * the same idempotency key; a new key could apply it twice. False for a
+   * configuration or request defect, a connection never established, and
+   * every 4xx refusal. It is false for `410 idempotency.expired` too, but
+   * there an earlier attempt under the key committed and only its stored
+   * response was erased by retention: reconcile the original operation, by
+   * reading the item, review request, or directory, before choosing a new
+   * key.
+   */
+  readonly outcomeUnknown: boolean
   readonly code?: CaseworkProblemCode
   readonly detail?: string
   readonly status?: SafeInteger
@@ -327,13 +348,13 @@ export class CaseworkClientError extends Error {
   readonly originalAttemptId?: string
   readonly validation?: {
     readonly path: string
-    readonly reason: 'kind_not_allowed' | 'reference_invalid' | 'object_required' | 'maximum_bytes_exceeded' | 'maximum_depth_exceeded' | 'schema_mismatch' | 'outcome_not_declared' | 'reason_required' | 'text_invalid' | 'result_not_declared' | 'result_required' | 'field_not_declared' | 'constraint_invalid' | 'constraint_violated'
+    readonly reason: 'kind-not-allowed' | 'reference-invalid' | 'object-required' | 'maximum-bytes-exceeded' | 'maximum-depth-exceeded' | 'schema-mismatch' | 'outcome-not-declared' | 'reason-required' | 'text-invalid' | 'result-not-declared' | 'result-required' | 'field-not-declared' | 'constraint-invalid' | 'constraint-violated'
   }
   readonly transportKind?: string
   readonly protocolFailure?: CaseworkProtocolFailure
 }
 
-export type ClockRuntimeState = 'running' | 'paused' | 'completed' | 'cancelled' | 'verification_pending' | 'source_facts_missing'
+export type ClockRuntimeState = 'running' | 'paused' | 'completed' | 'cancelled' | 'verification-pending' | 'source-facts-missing'
 export type ClockNextEffect =
   | { kind: 'reminder'; id: string; at: string }
   | { kind: 'reassign'; id: string; at: string; because: string; queueId: string }
@@ -382,7 +403,7 @@ export interface ReviewRequestAccepted {
   policy: ReviewPolicyBinding
   submissionDigest: ContentDigest
 }
-export type ReviewRequestLifecycle = 'reviewing' | 'approved' | 'rejected' | 'changes_requested' | 'answered' | 'cancelled' | 'superseded'
+export type ReviewRequestLifecycle = 'reviewing' | 'approved' | 'rejected' | 'changes-requested' | 'answered' | 'cancelled' | 'superseded'
 export interface ReviewRequestView extends ReviewRequestAccepted {
   requesterReference: string
   lifecycle: ReviewRequestLifecycle
@@ -390,7 +411,7 @@ export interface ReviewRequestView extends ReviewRequestAccepted {
   createdAt: string
   updatedAt: string
 }
-export type ReviewResultStatus = 'approved' | 'rejected' | 'changes_requested' | 'answered' | 'cancelled' | 'superseded'
+export type ReviewResultStatus = 'approved' | 'rejected' | 'changes-requested' | 'answered' | 'cancelled' | 'superseded'
 export interface ReviewResult extends ReviewRequestAccepted {
   resultId: Uuid
   status: ReviewResultStatus
@@ -407,11 +428,30 @@ export interface ReviewResultFeedPage { items: ReadonlyArray<ReviewResultFeedEnt
 export interface ReviewCancelRequest { subject: ReviewSubjectBinding; reason: string }
 export type ReviewCancelResponse =
   | { outcome: 'cancelled'; result: ReviewResult }
-  | { outcome: 'already_terminal'; result: ReviewResult }
+  | { outcome: 'already-terminal'; result: ReviewResult }
 export interface ReviewPageQuery { cursor?: Uuid; limit?: SafeInteger }
-export interface ReviewTaskQuery extends ReviewPageQuery { queue?: string }
+export type ReviewTaskOwnership = 'assigned-to-me' | 'unclaimed'
+export interface ReviewTaskQuery extends ReviewPageQuery { queue?: string; ownership?: ReviewTaskOwnership }
+export interface SupervisoryReviewTaskQuery extends ReviewPageQuery { queue?: string; requestId?: Uuid }
+export interface OwnReviewDecisionQuery extends ReviewPageQuery { queue?: string }
 export interface WorkItemHistoryQuery { cursor?: string; limit?: SafeInteger }
 export type ReviewerTaskState = 'open' | { held: { holder: IssuerPrincipal } } | 'decided'
+export type ReviewDecisionType = 'approve' | 'reject' | 'changes-requested' | 'answer'
+export interface ReviewDecisionReceipt {
+  policy: ReviewPolicyBinding
+  decision: ReviewDecisionType
+  outcome?: string
+  outcomeLabel?: string
+  decidedAt: string
+}
+export interface OwnReviewDecision {
+  taskId: Uuid
+  requestId: Uuid
+  queue: string
+  requesterReference: string
+  decisionReceipt: ReviewDecisionReceipt
+}
+export interface OwnReviewDecisionPage { items: ReadonlyArray<OwnReviewDecision>; nextCursor?: Uuid; status: PageStatus }
 export interface ReviewerTask {
   taskId: Uuid
   requestId: Uuid
@@ -422,9 +462,20 @@ export interface ReviewerTask {
   eligibleProfiles: ReadonlyArray<string>
   state: ReviewerTaskState
   decidedByCaller?: boolean
+  decisionReceipt?: ReviewDecisionReceipt
 }
 export interface ReviewTaskPage { items: ReadonlyArray<ReviewerTask>; nextCursor?: Uuid; status: PageStatus }
-export type ReviewSourceBindingStatus = 'current' | 'binding_changed'
+export type SupervisoryReviewTaskState = 'open' | 'held' | 'decided'
+export interface SupervisoryReviewTask {
+  taskId: Uuid
+  requestId: Uuid
+  queue: string
+  revision: SafeInteger
+  state: SupervisoryReviewTaskState
+  accountabilityEventId?: Uuid
+}
+export interface SupervisoryReviewTaskPage { items: ReadonlyArray<SupervisoryReviewTask>; nextCursor?: Uuid; status: PageStatus }
+export type ReviewSourceBindingStatus = 'current' | 'binding-changed'
 export interface ReviewSourceProjection { binding: SourceBinding; displayReference?: string; display: Readonly<Record<string, JsonValue>> }
 export type ReviewTaskContextData =
   | { strategy: 'submitted'; snapshot: Readonly<Record<string, JsonValue>> }
@@ -447,7 +498,7 @@ export interface ReviewClockOccurrence {
   clockId: string
   requestId: Uuid
   correlation: ReviewClockCorrelation
-  state: 'running' | 'paused' | 'completed' | 'cancelled' | 'source_facts_missing'
+  state: 'running' | 'paused' | 'completed' | 'cancelled' | 'source-facts-missing'
   policyDigest: ContentDigest
   anchorAt: string
   dueAt?: string
@@ -458,7 +509,7 @@ export interface ReviewTaskDraftInput { body: JsonValue }
 export interface ReviewTaskDraft { taskId: Uuid; author: IssuerPrincipal; body: JsonValue; revision: SafeInteger; updatedAt: string }
 export type ReviewerDecision =
   | { type: 'approve' }
-  | { type: 'reject' | 'changes_requested' | 'answer'; outcome: string; reason?: string | null; result?: JsonObject | null }
+  | { type: 'reject' | 'changes-requested' | 'answer'; outcome: string; reason?: string | null; result?: JsonObject | null }
 export interface ReviewTaskDecisionRequest { decision: ReviewerDecision }
 export type ReviewHistoryAudience = 'reviewers' | 'requester'
 export interface ReviewNoteRequest { audience: ReviewHistoryAudience; note: string }
@@ -468,6 +519,7 @@ export interface ReviewAccountabilityRecord {
   eventId: Uuid; requestId: Uuid; taskId: Uuid; actorRef: string; actor: IssuerPrincipal
   profileId: string; decision: string; privateReason?: string; resultDigest?: string
   occurredAt: string; retainedUntil: string
+  decisionReceipt?: ReviewDecisionReceipt
 }
 export interface ReviewStagePolicy { id: string; queue: string; decidingProfiles: ReadonlyArray<string>; requiredApprovals: SafeInteger; excludeInitiator?: boolean; excludePreviousStageReviewers?: boolean }
 export interface ReviewRetentionPolicy { terminalDays: SafeInteger; accountabilityDays: SafeInteger }
@@ -480,7 +532,7 @@ export interface ReviewKindPolicySnapshot {
   retention: ReviewRetentionPolicy
   displaySchema: JsonValue
   resultSchema?: JsonValue
-  outcomes?: ReadonlyArray<{ id: string; label: string; settlement: 'rejected' | 'changes_requested' | 'answered'; reasonRequired: boolean; resultRequired?: boolean }>
+  outcomes?: ReadonlyArray<{ id: string; label: string; settlement: 'rejected' | 'changes-requested' | 'answered'; reasonRequired: boolean; resultRequired?: boolean }>
 }
 
 export class CaseworkClient {
@@ -494,6 +546,8 @@ export class CaseworkClient {
   reviewKinds(token: string, profile: string): Promise<CaseworkOutcome<ReadonlyArray<ReviewKindPolicySnapshot>>>
   reviewKind(token: string, profile: string, kindId: string): Promise<CaseworkOutcome<ReviewKindPolicySnapshot>>
   reviewTasks(token: string, profile: string, query?: ReviewTaskQuery | null, sourceProfile?: string | null): Promise<CaseworkOutcome<ReviewTaskPage>>
+  supervisoryReviewTasks(token: string, profile: string, query?: SupervisoryReviewTaskQuery | null, sourceProfile?: string | null): Promise<CaseworkOutcome<SupervisoryReviewTaskPage>>
+  ownReviewDecisions(token: string, profile: string, query?: OwnReviewDecisionQuery | null, sourceProfile?: string | null): Promise<CaseworkOutcome<OwnReviewDecisionPage>>
   reviewTask(token: string, profile: string, taskId: Uuid, sourceProfile?: string | null): Promise<CaseworkOutcome<ReviewerTask>>
   reviewTaskContext(token: string, profile: string, taskId: Uuid, sourceProfile?: string | null): Promise<CaseworkOutcome<ReviewTaskContext>>
   previewReviewTaskTemplates(token: string, profile: string, sourceProfile: string, taskId: Uuid): Promise<CaseworkOutcome<TaskTemplatePreviews>>

package/casework/client.js

@@ -12,6 +12,7 @@ class CaseworkClientError extends Error {
     super(envelope.message);
     this.name = 'CaseworkClientError';
     this.kind = envelope.kind;
+    this.outcomeUnknown = envelope.outcomeUnknown === true;
     for (const field of ['code', 'detail', 'status', 'traceId', 'originalAttemptId', 'validation', 'transportKind', 'protocolFailure']) {
       if (envelope[field] !== undefined && envelope[field] !== null) this[field] = envelope[field];
     }
@@ -39,38 +40,38 @@ function normalized(error, fallbackKind) {
   return error;
 }
 
-function cloneJson(value, budget, depth) {
-  if (depth > MAX_JSON_DEPTH || ++budget.nodes > MAX_JSON_NODES) throw normalized({}, 'invalid_request');
+function cloneJson(value, budget, depth, kind) {
+  if (depth > MAX_JSON_DEPTH || ++budget.nodes > MAX_JSON_NODES) throw normalized({}, kind);
   if (value === null || typeof value === 'boolean') return value;
   if (typeof value === 'string') {
     budget.bytes += Buffer.byteLength(value, 'utf8');
-    if (budget.bytes > MAX_JSON_STRING_BYTES) throw normalized({}, 'invalid_request');
+    if (budget.bytes > MAX_JSON_STRING_BYTES) throw normalized({}, kind);
     return value;
   }
   if (typeof value === 'number') {
     if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
-      throw normalized({}, 'invalid_request');
+      throw normalized({}, kind);
     }
     return value;
   }
   if (value === undefined || typeof value !== 'object' || isProxy(value)) {
-    throw normalized({}, 'invalid_request');
+    throw normalized({}, kind);
   }
   const array = Array.isArray(value);
   const prototype = Object.getPrototypeOf(value);
   if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) {
-    throw normalized({}, 'invalid_request');
+    throw normalized({}, kind);
   }
-  if (budget.active.has(value)) throw normalized({}, 'invalid_request');
+  if (budget.active.has(value)) throw normalized({}, kind);
   budget.active.add(value);
   try {
-    if (array) return value.map((member) => cloneJson(member, budget, depth + 1));
+    if (array) return value.map((member) => cloneJson(member, budget, depth + 1, kind));
     const result = Object.create(null);
     for (const key of Reflect.ownKeys(value)) {
-      if (typeof key !== 'string') throw normalized({}, 'invalid_request');
+      if (typeof key !== 'string') throw normalized({}, kind);
       const descriptor = Object.getOwnPropertyDescriptor(value, key);
-      if (!descriptor || !Object.hasOwn(descriptor, 'value')) throw normalized({}, 'invalid_request');
-      if (descriptor.enumerable) result[key] = cloneJson(descriptor.value, budget, depth + 1);
+      if (!descriptor || !Object.hasOwn(descriptor, 'value')) throw normalized({}, kind);
+      if (descriptor.enumerable) result[key] = cloneJson(descriptor.value, budget, depth + 1, kind);
     }
     return result;
   } finally {
@@ -78,8 +79,10 @@ function cloneJson(value, budget, depth) {
   }
 }
 
-function sanitize(value) {
-  return cloneJson(value, { nodes: 0, bytes: 0, active: new WeakSet() }, 0);
+// A refusal is reported as `kind`: `configuration` for the constructor's
+// settings, `invalid-request` for a method's arguments.
+function sanitize(value, kind) {
+  return cloneJson(value, { nodes: 0, bytes: 0, active: new WeakSet() }, 0, kind);
 }
 
 const NativeCaseworkClient = native.CaseworkClient;
@@ -87,7 +90,7 @@ const NativeCaseworkClient = native.CaseworkClient;
 class CaseworkClient {
   constructor(config) {
     try {
-      this.native = new NativeCaseworkClient(sanitize(config));
+      this.native = new NativeCaseworkClient(sanitize(config, 'configuration'));
     } catch (error) {
       throw normalized(error, 'configuration');
     }
@@ -97,7 +100,7 @@ class CaseworkClient {
     try {
       return this.native.taskAssertionEndpoint(grantId);
     } catch (error) {
-      throw normalized(error, 'invalid_request');
+      throw normalized(error, 'invalid-request');
     }
   }
 }
@@ -112,6 +115,8 @@ for (const [method, jsonIndexes] of [
   ['reviewKinds', []],
   ['reviewKind', []],
   ['reviewTasks', [2]],
+  ['ownReviewDecisions', [2]],
+  ['supervisoryReviewTasks', [2]],
   ['reviewTask', []],
   ['reviewTaskContext', []],
   ['previewReviewTaskTemplates', []],
@@ -170,11 +175,11 @@ for (const [method, jsonIndexes] of [
   CaseworkClient.prototype[method] = function (...args) {
     try {
       for (const index of jsonIndexes) {
-        if (args[index] !== undefined && args[index] !== null) args[index] = sanitize(args[index]);
+        if (args[index] !== undefined && args[index] !== null) args[index] = sanitize(args[index], 'invalid-request');
       }
       return this.native[method](...args).catch((error) => { throw normalized(error); });
     } catch (error) {
-      throw normalized(error, 'invalid_request');
+      throw normalized(error, 'invalid-request');
     }
   };
 }

package/casework/index.d.ts

@@ -13,6 +13,8 @@ export declare class CaseworkClient {
   reviewKind(token: string, profile: string, kindId: string): Promise<CaseworkOutcome>
   reviewTasks(token: string, profile: string, query?: any | undefined | null, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
   reviewTask(token: string, profile: string, taskId: string, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  ownReviewDecisions(token: string, profile: string, query?: any | undefined | null, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  supervisoryReviewTasks(token: string, profile: string, query?: any | undefined | null, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
   reviewTaskContext(token: string, profile: string, taskId: string, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
   previewReviewTaskTemplates(token: string, profile: string, sourceProfile: string, taskId: string): Promise<CaseworkOutcome>
   listReviewTaskGrants(token: string, profile: string, sourceProfile: string, taskId: string): Promise<CaseworkOutcome>
@@ -76,6 +78,11 @@ export interface CaseworkClientConfig {
   maxResponseBytes?: number
   userAgent?: string
   trustedRootCertificates?: string
+  /**
+   * How many times a keyed mutation whose outcome is unknown is resent under
+   * the same idempotency key: 0 to 2, default 2, and 0 disables the resend.
+   */
+  maxMutationRetries?: number
 }
 
 export interface CaseworkOutcome {

package/discovery/client.d.ts

@@ -1,4 +1,4 @@
-export type ServiceKind = 'evidence' | 'relay';
+export type ServiceKind = 'evidence';
 
 export interface DiscoveryClientOptions {
   baseUrl: string;
@@ -32,8 +32,6 @@ export interface ServiceFilters {
   jurisdiction?: string[];
   conformsTo?: string[];
   evidenceType?: string[];
-  semanticClass?: string[];
-  operationFamily?: string[];
 }
 
 export interface EvidenceServiceQuery {
@@ -43,17 +41,6 @@ export interface EvidenceServiceQuery {
   conformsTo?: string[];
 }
 
-interface RelayServiceQueryOptions {
-  jurisdiction?: string;
-  serviceIds?: string[];
-  conformsTo?: string[];
-}
-
-export type RelayServiceQuery = RelayServiceQueryOptions & (
-  | { semanticClassId: string; operationFamilyId?: string }
-  | { semanticClassId?: string; operationFamilyId: string }
-);
-
 export interface ServiceRecord {
   recordId: string;
   bindingId: string;
@@ -83,10 +70,7 @@ export interface ServiceSearchResponse {
   items: ServiceRecord[];
 }
 
-export type MatchedCapability =
-  | { kind: 'evidence-type'; id: string }
-  | { kind: 'semantic-class'; id: string }
-  | { kind: 'operation-family'; id: string };
+export type MatchedCapability = { kind: 'evidence-type'; id: string };
 
 export interface SelectionRequest {
   recordId: string;
@@ -110,15 +94,6 @@ export interface EvidenceSelectionRequest {
   resolution?: EvidenceResolutionContext;
 }
 
-export type RelayCapabilityMatch =
-  | { semanticClassId: string; operationFamilyId?: string }
-  | { semanticClassId?: string; operationFamilyId: string };
-
-export interface RelaySelectionRequest {
-  recordId: string;
-  capabilityMatch: RelayCapabilityMatch;
-}
-
 export interface CommonServiceSelection extends Omit<ServiceRecord, 'title' | 'description'> {
   matchedCapability: MatchedCapability;
   catalogRevision: string;
@@ -131,26 +106,18 @@ export interface EvidenceServiceSelection extends CommonServiceSelection {
   evidenceResolution?: EvidenceResolutionContext;
 }
 
-export interface RelayServiceSelection extends CommonServiceSelection {
-  serviceKind: 'relay';
-  matchedCapability:
-    | { kind: 'semantic-class'; id: string }
-    | { kind: 'operation-family'; id: string };
-  relayCapabilityMatch: RelayCapabilityMatch;
-}
-
 export type ServiceSelection = CommonServiceSelection;
 
 export type DiscoveryClientErrorKind =
   | 'configuration'
   | 'query'
-  | 'no_matching_service'
-  | 'ambiguous_selection'
-  | 'no_matching_alternative'
-  | 'ambiguous_alternative'
-  | 'capability_mismatch'
-  | 'local_acceptance_refused'
-  | 'selection_changed'
+  | 'no-matching-service'
+  | 'ambiguous-selection'
+  | 'no-matching-alternative'
+  | 'ambiguous-alternative'
+  | 'capability-mismatch'
+  | 'local-acceptance-refused'
+  | 'selection-changed'
   | 'transport'
   | 'problem'
   | 'protocol'
@@ -168,7 +135,6 @@ export class DiscoveryClient {
   resolveEvidenceTypes(request: EvidenceTypeResolveRequest): Promise<EvidenceTypeResolveResponse>;
   searchServices(filters?: ServiceFilters): Promise<ServiceSearchResponse>;
   searchEvidenceServices(query: EvidenceServiceQuery): Promise<ServiceSearchResponse>;
-  searchRelayServices(query: RelayServiceQuery): Promise<ServiceSearchResponse>;
   selectExact(response: ServiceSearchResponse, request: SelectionRequest): CommonServiceSelection;
   selectEvidenceAlternative(
     response: EvidenceTypeResolveResponse,
@@ -178,10 +144,6 @@ export class DiscoveryClient {
     response: ServiceSearchResponse,
     request: EvidenceSelectionRequest,
   ): EvidenceServiceSelection;
-  selectRelayService(
-    response: ServiceSearchResponse,
-    request: RelaySelectionRequest,
-  ): RelayServiceSelection;
 }
 
 export function selectExact(
@@ -199,11 +161,6 @@ export function selectEvidenceService(
   request: EvidenceSelectionRequest,
 ): EvidenceServiceSelection;
 
-export function selectRelayService(
-  response: ServiceSearchResponse,
-  request: RelaySelectionRequest,
-): RelayServiceSelection;
-
 /**
  * Validate closed shape and capability binding only.
  *