@registrystack/client 0.39.0 → 0.41.0

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> }
@@ -29,15 +37,21 @@ export interface TaskPermission { collection: string; operations: ReadonlyArray<
 export interface SchedulingTaskPermission { service: string; location: string; actions: ReadonlyArray<string> }
 export interface EvidenceRequesterContext { requesterTags: ReadonlyArray<string>; audience: string }
 export interface TaskApprovalRequest { templateId: string; templateVersion: string }
+/** Deferred authority keeps its approved deadline; execution credentials stay short-lived. */
+export type TaskAuthorizationMode = 'immediate' | 'deferred'
 export interface TaskTemplatePreview {
   id: string; version: string; label: string; agent: IssuerPrincipal; client: string; resource: string; scopes: ReadonlyArray<string>; purpose: string
   evidenceContext?: EvidenceRequesterContext; bounds: TaskGrantBounds; subjects: { readonly [key: string]: Exclude<JsonScalar, null> }; lifetimeSeconds: SafeInteger
+  /** Omitted for the existing immediate mode. */
+  authorizationMode?: TaskAuthorizationMode
 }
 export interface TaskTemplatePreviews { itemRevision: SafeInteger; templates: ReadonlyArray<TaskTemplatePreview> }
 /** Grant metadata deliberately excludes stored subject values. */
 export interface TaskGrantView {
   id: string; templateId: string; templateVersion: string; agent: IssuerPrincipal; client: string; resource: string; scopes: ReadonlyArray<string>; purpose: string
   evidenceContext?: EvidenceRequesterContext; bounds: TaskGrantBounds; expiresAt: SafeInteger; invalidated: boolean
+  /** Omitted for the existing immediate mode. */
+  authorizationMode?: TaskAuthorizationMode
 }
 export interface TaskGrantList { grants: ReadonlyArray<TaskGrantView> }
 export interface TaskGrantRevocation { id: string; invalidated: boolean }
@@ -94,14 +108,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 +181,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 +200,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 +234,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 +266,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 +330,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 +354,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 +409,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 +417,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 +434,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 +468,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 +504,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 +515,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 +525,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 +538,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 +552,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

@@ -111,13 +111,13 @@ 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'

package/discovery/client.js

@@ -55,7 +55,7 @@ function inputError(kind) {
 
 function localAcceptanceError() {
   return new DiscoveryClientError({
-    kind: 'local_acceptance_refused',
+    kind: 'local-acceptance-refused',
     message: 'the relying application refused the advertised service',
   });
 }

package/evidence/client.d.ts

@@ -351,7 +351,7 @@ export interface EvidenceRequestBatchSpec {
  *   is `protocol`
  * - `code`: `denied`, `protocol` (optional), `verification`, and any `token`
  *   failure whose `tokenKind` is `refused`
- * - `traceId`: `denied`, `not_available`, `protocol` (all optional)
+ * - `traceId`: `denied`, `not-available`, `protocol` (all optional)
  * - `retryAfterSeconds`: `denied`, `protocol` (both optional)
  * - `transportKind`: `transport`, and any `token` failure whose `tokenKind`
  *   is `transport`

package/evidence/index.d.ts

@@ -154,11 +154,8 @@ export declare class EvidenceClient {
 export declare class PreparedEvidenceRequest {
   /** The nonce this request carries. Retain it with the transaction record. */
   get requestNonce(): string
-  /**
-   * The closed verification policy, with the subject set as `prepare` left
-   * it.
-   */
-  get policyDocument(): any
+  /** The complete enveloped policy, with the subject set as `prepare` left it. */
+  get policyDocument(): { apiVersion: 'id.registrystack.org/formats/evidence/verification-policy/v1'; kind: 'EvidenceVerificationPolicy'; [field: string]: unknown }
   /**
    * `"acceptFirstUse"` or `{ pinned: [{ role, binding }, ...] }`, exactly as
    * this request was prepared.
@@ -178,7 +175,7 @@ export declare class PreparedEvidenceRequestBatch {
   /** Independently generated item nonces in request order. */
   get requestNonces(): Array<string>
   /** Independently closed policy documents in request order. */
-  get policyDocuments(): Array<any>
+  get policyDocuments(): Array<{ apiVersion: 'id.registrystack.org/formats/evidence/verification-policy/v1'; kind: 'EvidenceVerificationPolicy'; [field: string]: unknown }>
   /** Subject-verification stances in request order. */
   get subjectExpectations(): Array<any>
   /** Number of positional requests in this batch. */

package/index.d.ts

@@ -3,5 +3,6 @@ import * as evidence from './evidence/client'
 import * as breg from './breg/client'
 import * as casework from './casework/client'
 import * as messaging from './messaging/client'
+import * as scheduling from './scheduling/client'
 
-export { discovery, evidence, breg, casework, messaging }
+export { discovery, evidence, breg, casework, messaging, scheduling }

package/index.js

@@ -2,9 +2,10 @@
 
 // One assignment per namespace, never a `module.exports` object literal: Node
 // scans this file for these statements to synthesise the named exports an ESM
-// consumer imports, and `require()` sees the same five properties either way.
+// consumer imports, and `require()` sees the same six properties either way.
 exports.discovery = require('./discovery/client');
 exports.evidence = require('./evidence/client');
 exports.breg = require('./breg/client');
 exports.casework = require('./casework/client');
 exports.messaging = require('./messaging/client');
+exports.scheduling = require('./scheduling/client');

package/messaging/client.d.ts

@@ -14,6 +14,13 @@ export interface MessagingClientConfig {
   maxResponseBytes?: SafeInteger | null
   userAgent?: string | null
   trustedRootCertificates?: string | null
+  /**
+   * How many times a submission whose outcome is unknown is resent,
+   * identically and under the same idempotency key, before its error is
+   * returned: a whole number from 0 to 2, default 2; 0 sends it once. Any
+   * other value is a `configuration` error.
+   */
+  maxMutationRetries?: SafeInteger | null
 }
 
 export type Channel = 'email' | 'sms'
@@ -102,6 +109,7 @@ export type MessagingProblemCode =
   | 'profile.not-authorized'
   | 'quota.exceeded'
   | 'rate-limit.exceeded'
+  | 'receipt.unresolved'
   | 'request.body-too-large'
   | 'request.invalid'
   | 'request.method-not-allowed'
@@ -113,10 +121,21 @@ export type MessagingProblemCode =
   | 'template.locale-unavailable'
   | 'template.not-found'
   | 'template.render-refused'
-export type MessagingProtocolFailure = 'header_bounds' | 'trace_context' | 'media_type' | 'body' | 'problem' | 'status' | 'protocol'
+export type MessagingProtocolFailure = 'header-bounds' | 'trace-context' | 'media-type' | 'body' | 'problem' | 'status' | 'protocol'
 
 export class MessagingClientError 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 submission under the key was accepted and its message
+   * may have been sent: reconcile that submission before choosing a new key.
+   */
+  readonly outcomeUnknown: boolean
   readonly code?: MessagingProblemCode
   readonly title?: string
   readonly detail?: string
@@ -124,8 +143,9 @@ export class MessagingClientError extends Error {
   readonly traceId?: string
   /**
    * Whole seconds a 429 limit refusal asked the caller to wait, from
-   * `Retry-After`, at most one day. Absent on every other failure; the
-   * client never waits or retries itself.
+   * `Retry-After`, at most one day. Absent on every other failure. The
+   * client never waits on a 429 or retries it; the wait is the caller's to
+   * honor.
    */
   readonly retryAfterSeconds?: SafeInteger
   readonly transportKind?: string
@@ -137,6 +157,8 @@ export class MessagingClient {
   health(): Promise<MessagingOutcome<null>>
   ready(): Promise<MessagingOutcome<null>>
   submit(token: string, idempotencyKey: string, request: SubmitMessageRequest): Promise<MessagingOutcome<MessageReceipt>>
+  /** Observe the original success using the same body/key and current token; never resend or mutate. */
+  messageReceipt(token: string, idempotencyKey: string, request: SubmitMessageRequest): Promise<MessagingOutcome<MessageReceipt>>
   message(token: string, messageId: MessageId): Promise<MessagingOutcome<MessageView>>
   cancel(token: string, messageId: MessageId): Promise<MessagingOutcome<MessageView>>
   preview(token: string, templateId: string, version: string, request: TemplatePreviewRequest): Promise<MessagingOutcome<TemplatePreview>>