@registrystack/client 0.32.0 → 0.34.0

package/README.md

@@ -34,7 +34,8 @@ const work = new casework.CaseworkClient({
 - `evidence`: Evidence Gateway, request and verify signed minimum-disclosure
   assertions.
 - `relay`: Registry Relay, scoped read-only APIs over existing sources.
-- `breg`: Base Registry Engine, records, contracts, writes, and lifecycle.
+- `breg`: Base Registry Engine, records, contracts, writes, lifecycle, and typed
+  applied-request result navigation.
 - `casework`: Registry Casework, staff inbox, claims, drafts, decisions,
   recovery, history, holdings, and directory bootstrap.
 

package/breg/client.d.ts

@@ -216,33 +216,54 @@ export interface RegistryRecord {
   readonly [member: string]: JsonValue | undefined
 }
 
-export type BRegRequestReviewStage = JsonObject & {
-  readonly id: string
-  readonly approvals: SafeInteger
-  readonly excludeSubmitter: boolean
-  readonly excludePreviousReviewers?: boolean
-}
-export type BRegRequestReviewState = JsonObject & {
-  readonly stages: ReadonlyArray<BRegRequestReviewStage>
-  readonly submittedAt: string
-  readonly pendingStage: string | null
-  readonly stageEnteredAt: string | null
-}
-export type BRegRequestReviewTiming = JsonObject & {
-  readonly firstSubmittedAt: string
-  readonly pausedMilliseconds: SafeInteger
-  readonly pauseStartedAt: string | null
-  readonly completedAt: string | null
-}
-export type BRegRequestDecision = JsonObject & {
-  readonly stageId: string
-  readonly kind: 'approve' | 'reject' | 'request_revision'
-  readonly decidedAt: string
-  readonly reasonPresent: boolean
-  readonly reason?: string
-  readonly actorReference?: string
-}
-export type BRegRequestState = 'draft' | 'submitted' | 'approved' | 'needs_changes' | 'rejected' | 'canceled' | 'applied'
+export type BRegRequestResultReferenceData = JsonObject & {
+  readonly targetEntityId: string
+  readonly targetRecordId: string
+  /** Revision written by the application, not a current ETag or precondition. */
+  readonly targetRevision: SafeInteger
+}
+export type BRegRequestState = 'draft' | 'submitted' | 'cancelled' | 'applied'
+export type BRegRequestReviewRequirement =
+  | Readonly<{ mode: 'none' }>
+  | Readonly<{ authority: string; policyId: string }>
+export type BRegExternalReviewStatus = Readonly<{
+  submission: Readonly<{
+    state: 'pending' | 'accepted' | 'uncertain' | 'cancelling' | 'cancelled' | 'failed'
+    authority: string
+    requestId?: string
+    submissionDigest?: string
+    /** Fixed recovery deadline for the durable submission. */
+    recoveryDeadline?: string
+    policy?: Readonly<{ id: string; version: string; digest: string }>
+  }>
+  result: Readonly<{
+    state: 'pending' | 'approved' | 'rejected' | 'changesRequested' | 'answered' | 'cancelled' | 'superseded'
+    resultId?: string
+    completedAt?: string
+    availableUntil?: string
+  }>
+  delivery: Readonly<{
+    state: 'polling' | 'received' | 'reconciled' | 'unmatched' | 'exhausted'
+    eventId?: string
+    receivedAt?: string
+  }>
+  application: Readonly<{
+    mode: 'manual' | 'automatic'
+    state: 'awaitingReview' | 'ready' | 'queued' | 'applying' | 'applied' | 'blocked' | 'expired'
+    executor?: string
+    applicationId?: string
+    /** Durable automatic-application attempts, from 0 through 1000. */
+    attempts?: SafeInteger
+    /** Present only while an automatic application is queued or applying. */
+    nextAttemptAt?: string
+    /** Present when the applied receipt was recovered from already-applied source state. */
+    receiptRecovered?: true
+  }>
+  recovery: Readonly<{
+    state: 'none' | 'operatorAttention'
+    code?: string
+  }>
+}>
 export type BRegRetainedRequestProposal = JsonObject & {
   readonly requestEntityId: string
   readonly requestId: string
@@ -253,9 +274,9 @@ export type BRegRetainedRequestProposal = JsonObject & {
   readonly detailErased: boolean
   readonly applicationId: string | null
   readonly resultLinkCount: SafeInteger
-  readonly resultLinks: ReadonlyArray<JsonObject>
+  readonly resultLinks: ReadonlyArray<BRegRequestResultReferenceData>
   readonly effectDigest?: string
-  readonly decisions?: ReadonlyArray<BRegRequestDecision>
+  readonly proposal?: Readonly<{ review: BRegRequestReviewRequirement }>
 }
 export type BRegRetainedRequestHistory = JsonObject & {
   readonly proposals: ReadonlyArray<BRegRetainedRequestProposal>
@@ -265,17 +286,15 @@ export type BRegRequestMetadata = JsonObject & {
   readonly bregState: BRegRequestState
   readonly proposalVersion: SafeInteger
   readonly effectDigest?: string | null
-  readonly proposal?: JsonObject | null
+  readonly proposal?: Readonly<{ review: BRegRequestReviewRequirement }> | null
   readonly editable: boolean
   readonly detailErased?: true
   readonly actions?: ReadonlyArray<JsonObject>
   readonly application?: JsonObject | null
-  readonly history?: BRegRetainedRequestHistory
-  readonly review?: BRegRequestReviewState
-  readonly reviewTiming?: BRegRequestReviewTiming
+  readonly history?: BRegRetainedRequestHistory | null
+  readonly review?: BRegExternalReviewStatus
   readonly submitterReference?: string
   readonly applierReference?: string
-  readonly decisions?: ReadonlyArray<BRegRequestDecision>
 }
 
 export interface RecordMetadata {
@@ -343,17 +362,6 @@ export interface RemovePatchOperation {
   field: string
 }
 
-export interface LifecycleReviewTarget {
-  entityIdentifier: string
-  recordIdentifier: string
-  operation: 'create' | 'patch'
-  baseRevision?: SafeInteger
-  before?: Readonly<Record<string, JsonValue>>
-  after: Readonly<Record<string, JsonValue>>
-}
-
-export interface LifecycleReview { targets: ReadonlyArray<LifecycleReviewTarget> }
-
 export type LifecycleReceipt = JsonObject & {
   readonly id: string
   readonly revision: SafeInteger
@@ -592,6 +600,165 @@ export interface BRegBatchReceipt {
   }>
 }
 
+export type BRegIngestionOperation = 'create' | 'patch'
+export type BRegIngestionRunStatus = 'open' | 'complete' | 'cancelled' | 'blocked'
+export type BRegIngestionAttemptOutcome =
+  | 'committed'
+  | 'replayed'
+  | 'invalidItem'
+  | 'refused'
+  | 'bindingChanged'
+  | 'chunkMismatch'
+  | 'runNotOpen'
+  | 'unavailable'
+
+/** The whole-input announcement that opens one durable ingestion run. */
+export interface BRegIngestionRunInput {
+  operation: BRegIngestionOperation
+  profileId: string
+  packageRevision: string
+  schemaFingerprint: string
+  /** Lowercase SHA-256 of the complete raw source input. */
+  inputDigest: string
+  inputLength: SafeInteger
+  itemCount: SafeInteger
+  chunkCount: SafeInteger
+  /** The only accepted value is `greedy-canonical-http-batch-v1`. */
+  chunkAlgorithmVersion: string
+}
+
+export interface BRegIngestionRunListInput {
+  accessProfile?: string | null
+  limit?: SafeInteger | null
+  after?: string | null
+  status?: BRegIngestionRunStatus | null
+  inputDigest?: string | null
+}
+
+export interface BRegIngestionAttempt {
+  readonly outcome: BRegIngestionAttemptOutcome
+  readonly chunkIndex: SafeInteger | null
+}
+
+/** Value-free durable state of one ingestion run: no source rows, no record values. */
+export interface BRegIngestionRun {
+  readonly runId: string
+  readonly status: BRegIngestionRunStatus
+  readonly blockedReason: string | null
+  readonly entityId: string
+  readonly operation: BRegIngestionOperation
+  readonly profileId: string
+  readonly packageRevision: string
+  readonly schemaFingerprint: string
+  readonly inputDigest: string
+  readonly inputLength: SafeInteger
+  readonly itemCount: SafeInteger
+  readonly chunkCount: SafeInteger
+  readonly chunkAlgorithmVersion: string
+  readonly maximumItems: SafeInteger
+  readonly maximumBytes: SafeInteger
+  readonly nextChunkIndex: SafeInteger
+  readonly committedItems: SafeInteger
+  readonly committedPrefixDigest: string
+  readonly lastAttempt: BRegIngestionAttempt | null
+  readonly createdAt: string
+  readonly updatedAt: string
+  readonly complete: boolean
+}
+
+export interface BRegIngestionRunPage {
+  readonly runs: ReadonlyArray<BRegIngestionRun>
+  readonly hasMore: boolean
+  readonly nextAfter: string | null
+}
+
+export interface BRegIngestionReceiptBatch {
+  readonly snapshot: string
+  readonly results: ReadonlyArray<JsonObject>
+}
+
+export interface BRegIngestionChunkReceipt {
+  readonly chunkIndex: SafeInteger
+  readonly digest: string
+  readonly replayed: boolean
+  readonly erased: boolean
+  readonly batch: BRegIngestionReceiptBatch
+}
+
+export interface BRegIngestionChunkSubmission {
+  readonly run: BRegIngestionRun
+  readonly receipt: BRegIngestionChunkReceipt
+}
+
+/**
+ * One bounded, digest-bound chunk of an ingestion run. The chunk digest is
+ * derived in Rust from the exact canonical batch body the items hash to.
+ */
+export declare class BRegIngestionChunk {
+  private constructor()
+  private readonly __opaque: void
+  readonly chunkIndex: SafeInteger
+  readonly itemCount: SafeInteger
+  readonly digest: string
+  readonly prefixDigest: string
+}
+
+/**
+ * Accumulate the raw source bytes of one ingestion input and derive the
+ * rolling prefix digest the run binds: the lowercase SHA-256 of everything
+ * absorbed through the end of the current chunk. The digest of an empty
+ * accumulation is `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`.
+ */
+export declare class BRegIngestionPrefixDigest {
+  constructor()
+  update(data: Buffer): void
+  digest(): string
+}
+
+/**
+ * Encode one ingestion chunk submission: derive its digest in Rust and bind
+ * the announced prefix digest into the exact wire body. `items` are the same
+ * batch items the entity's atomic batch route executes.
+ */
+export declare function encodeIngestionChunk(
+  chunkIndex: SafeInteger,
+  items: ReadonlyArray<BRegBatchItem>,
+  prefixDigest: string,
+): BRegIngestionChunk
+
+/**
+ * Where a change-request target or value comes from, present only when the
+ * caller may read it: a request-entity field, or the record another effect
+ * of the same request creates.
+ */
+export type BRegChangeRequestBinding =
+  | { readonly fromField: string; readonly fromEffect?: never }
+  | { readonly fromEffect: string; readonly fromField?: never }
+  | { readonly fromField?: never; readonly fromEffect?: never }
+
+export type BRegChangeRequestTarget = { readonly entity: string } & BRegChangeRequestBinding
+
+/**
+ * One declared change-request effect on an entity the caller may read. Only
+ * target fields the caller may read are named; the value is descriptive and
+ * cannot create target-write authority.
+ */
+export interface BRegChangeRequestEffect {
+  readonly id: string
+  readonly operation: 'create' | 'patch'
+  readonly target: BRegChangeRequestTarget
+  readonly set: ReadonlyArray<{ readonly field: string } & BRegChangeRequestBinding>
+  readonly clear: ReadonlyArray<string>
+}
+
+/** One declared planner write, filtered to fields the caller may read. */
+export interface BRegChangeRequestPlannerWrite {
+  /** A planner write targets a stored record, never another effect. */
+  readonly target: { readonly entity: string; readonly fromField?: string; readonly fromEffect?: never }
+  readonly operation: 'create' | 'patch'
+  readonly fields: ReadonlyArray<string>
+}
+
 export interface BRegChangeRequestCapability {
   readonly planner: {
     readonly kind: 'declarative' | 'rhai'
@@ -611,18 +778,16 @@ export interface BRegChangeRequestCapability {
     } | null
     readonly possibleWriteCount: SafeInteger | null
     readonly possibleWriteOperations: ReadonlyArray<string>
+    readonly writes: ReadonlyArray<BRegChangeRequestPlannerWrite>
+  }
+  readonly effects: ReadonlyArray<BRegChangeRequestEffect>
+  readonly review: BRegRequestReviewRequirement
+  readonly onApproved: {
+    readonly mode: 'manual' | 'automatic'
+    readonly executor: string | null
   }
-  readonly reviewMode: 'none' | 'staged'
-  readonly stages: ReadonlyArray<{
-    readonly id: string
-    readonly approvals: SafeInteger
-    readonly excludeSubmitter: boolean
-    readonly excludePreviousReviewers: boolean
-  }> | null
   readonly application: {
-    readonly mode: 'manual' | 'automatic' | 'planner'
-    readonly allowedDispositions: ReadonlyArray<'apply' | 'queue'>
-    readonly queueReasons: ReadonlyArray<{ readonly code: string; readonly label: string }>
+    readonly preconditions: JsonValue | null
   }
 }
 
@@ -715,18 +880,54 @@ export declare class BRegLifecycleAuthority {
   private readonly __opaque: void
 }
 
+/** Inert caller-visible target provenance. It grants no read authority. */
+export declare class BRegRequestResultReference {
+  private constructor()
+  private readonly __opaque: void
+  readonly targetEntityIdentifier: string
+  readonly targetRecordIdentifier: string
+  /** Revision written by the application, not a current ETag or precondition. */
+  readonly targetRevision: SafeInteger
+  toString(): string
+}
+
+/** One exact retained proposal from an explicitly loaded history page. */
+export declare class BRegRetainedRequestProposalView {
+  private constructor()
+  private readonly __opaque: void
+  readonly requestEntityIdentifier: string
+  readonly requestIdentifier: string
+  readonly proposalVersion: SafeInteger
+  readonly bregState: BRegRequestState
+  readonly current: boolean
+  readonly detailErased: boolean
+  readonly applicationIdentifier: string | null
+  /** Caller-visible count, never an undisclosed application total. */
+  readonly resultLinkCount: SafeInteger
+  readonly resultReferences: ReadonlyArray<BRegRequestResultReference>
+  toString(): string
+}
+
+/** One page only. Call getRecord with its cursor to load another page. */
+export declare class BRegRetainedRequestHistoryPage {
+  private constructor()
+  private readonly __opaque: void
+  readonly proposals: ReadonlyArray<BRegRetainedRequestProposalView>
+  readonly nextAfterProposalVersion: SafeInteger | null
+  findProposal(requestEntityIdentifier: string, requestIdentifier: string, proposalVersion: SafeInteger): BRegRetainedRequestProposalView | null
+  findApplication(requestEntityIdentifier: string, requestIdentifier: string, proposalVersion: SafeInteger, applicationIdentifier: string): BRegRetainedRequestProposalView | null
+  toString(): string
+}
+
 /** Opaque executable action promoted from a metadata authority and one record. */
 export declare class BRegLifecycleAction {
   withReason(reason: string): BRegLifecycleAction
   private constructor()
   private readonly __opaque: void
   readonly operation: string
-  readonly stage: string | null
   readonly href: string
   readonly bodyJson: string
-  readonly reviewJson: string | null
   readonly body: JsonObject
-  readonly review: LifecycleReview | null
 }
 
 /** Inert bounded Create evidence. Persist these bytes with owner-only access. */
@@ -839,9 +1040,17 @@ export declare class BaseRegistryClient {
   patchRecord(binding: BRegPatchBinding, recordIdentifier: string, etag: string, operations: ReadonlyArray<PatchOperation | RemovePatchOperation>, idempotencyKey: string, format?: RecordFormat | null): Promise<CompleteOutcome<RecordEnvelope>>
   batchRecords(binding: BRegBatchBinding, request: BRegBatchInput, idempotencyKey: string): Promise<CompleteOutcome<BRegBatchReceipt>>
   batchRecordsJson(binding: BRegBatchBinding, requestJson: string, idempotencyKey: string): Promise<JsonOutcome>
+  createIngestionRun(entityRoute: string, request: BRegIngestionRunInput): Promise<CompleteOutcome<BRegIngestionRun>>
+  listIngestionRuns(entityRoute: string, query?: BRegIngestionRunListInput | null): Promise<CompleteOutcome<BRegIngestionRunPage>>
+  readIngestionRun(entityRoute: string, runId: string, accessProfile?: string | null): Promise<CompleteOutcome<BRegIngestionRun>>
+  submitIngestionChunk(entityRoute: string, runId: string, chunk: BRegIngestionChunk, profileId: string): Promise<CompleteOutcome<BRegIngestionChunkSubmission>>
+  cancelIngestionRun(entityRoute: string, runId: string, accessProfile?: string | null): Promise<CompleteOutcome<BRegIngestionRun>>
+  ingestionChunkReceipt(entityRoute: string, runId: string, chunkIndex: SafeInteger, profileId: string): Promise<CompleteOutcome<BRegIngestionChunkReceipt>>
   tombstoneRecord(binding: BRegTombstoneBinding, recordIdentifier: string, etag: string, idempotencyKey: string, format?: RecordFormat | null): Promise<CompleteOutcome<RecordEnvelope>>
   tombstoneRecordJson(binding: BRegTombstoneBinding, recordIdentifier: string, etag: string, idempotencyKey: string, format?: RecordFormat | null): Promise<JsonOutcome>
   lifecycleActions(authority: BRegLifecycleAuthority, record: RecordEnvelope, format?: RecordFormat | null): ReadonlyArray<BRegLifecycleAction>
+  /** Pure typed projection of one already loaded page. Performs no I/O. */
+  requestHistory(record: RecordEnvelope, format?: RecordFormat | null): BRegRetainedRequestHistoryPage | null
   prepareLifecycleAction(authority: BRegLifecycleAuthority, record: RecordEnvelope, action: BRegLifecycleAction, idempotencyKey: string, format?: RecordFormat | null): BRegPreparedLifecycle
   prepareLifecycleActionJson(authority: BRegLifecycleAuthority, recordJson: string, action: BRegLifecycleAction, idempotencyKey: string, format?: RecordFormat | null): BRegPreparedLifecycle
   recoverLifecycleAction(authority: BRegLifecycleAuthority, prepared: BRegPreparedLifecycle): BRegRecoveredLifecycle

package/breg/client.js

@@ -222,6 +222,8 @@ for (const [method, jsonIndexes, requiredIndexes] of [
   ['actionTargetConditionsJson'], ['invokeActionJson'], ['batchRecordsJson'], ['tombstoneRecordJson'],
   ['executeRecoveredCreateJson'], ['executeRecoveredLifecycleActionJson'],
   ['uploadAttachmentJson'], ['deleteAttachmentJson'],
+  ['createIngestionRun', [1], [1]], ['listIngestionRuns', [1]],
+  ['readIngestionRun'], ['submitIngestionChunk'], ['cancelIngestionRun'],
 ]) wrapAsync(method, jsonIndexes, requiredIndexes);
 
 for (const [method, jsonIndexes, requiredIndexes] of [
@@ -302,6 +304,32 @@ native.BaseRegistryClient.prototype.lifecycleActions = function (...args) {
   }
 };
 
+const requestHistory = native.BaseRegistryClient.prototype.requestHistory;
+native.BaseRegistryClient.prototype.requestHistory = function (...args) {
+  try {
+    const sanitized = sanitizeArguments(args, new Set([0]), new Set([0]));
+    return requestHistory.apply(this, sanitized);
+  } catch (error) {
+    throw normalize(error, 'invalid_request');
+  }
+};
+
+for (const name of ['findProposal', 'findApplication']) {
+  const original = native.RetainedRequestHistoryPage.prototype[name];
+  native.RetainedRequestHistoryPage.prototype[name] = function (...args) {
+    try {
+      const proposalVersion = args[2];
+      if (!Number.isSafeInteger(proposalVersion)
+        || proposalVersion < 1 || proposalVersion > 0xffff_ffff) {
+        throw inputError('invalid_request');
+      }
+      return original.apply(this, args);
+    } catch (error) {
+      throw normalize(error, 'invalid_request');
+    }
+  };
+}
+
 const valueIn = native.BRegAttachmentSlot.prototype.valueIn;
 native.BRegAttachmentSlot.prototype.valueIn = function (...args) {
   try {
@@ -336,6 +364,42 @@ for (const name of [
   };
 }
 
+function encodeIngestionChunk(chunkIndex, items, prefixDigest) {
+  try {
+    if (!Number.isSafeInteger(chunkIndex)) throw inputError('invalid_request');
+    const sanitized = sanitizeArguments(
+      [chunkIndex, items, prefixDigest], new Set([1]), new Set([1]),
+    );
+    return native.encodeIngestionChunk(...sanitized);
+  } catch (error) {
+    throw normalize(error, 'invalid_request');
+  }
+}
+
+// napi truncates a fractional JavaScript number into the i64 chunk index, so
+// the exact chunk-bound protocol checks integrality before it reaches Rust.
+const ingestionChunkReceipt = native.BaseRegistryClient.prototype.ingestionChunkReceipt;
+native.BaseRegistryClient.prototype.ingestionChunkReceipt = function (...args) {
+  try {
+    if (!Number.isSafeInteger(args[2])) throw inputError('invalid_request');
+    return ingestionChunkReceipt.apply(this, args).catch((error) => { throw normalize(error); });
+  } catch (error) {
+    throw normalize(error, 'invalid_request');
+  }
+};
+
+const ingestionPrefixDigestUpdate = native.BRegIngestionPrefixDigest.prototype.update;
+native.BRegIngestionPrefixDigest.prototype.update = function (data) {
+  try {
+    if (!Buffer.isBuffer(data) || isSharedArrayBuffer(data.buffer)) {
+      throw inputError('invalid_request');
+    }
+    return ingestionPrefixDigestUpdate.call(this, data);
+  } catch (error) {
+    throw normalize(error, 'invalid_request');
+  }
+};
+
 class BaseRegistryClient extends native.BaseRegistryClient {
   constructor(config) {
     try {
@@ -372,6 +436,9 @@ module.exports = {
   BRegPatchBinding: native.BRegPatchBinding,
   BRegLifecycleAuthority: native.BRegLifecycleAuthority,
   BRegLifecycleAction: native.BRegLifecycleAction,
+  BRegRequestResultReference: native.RequestResultReference,
+  BRegRetainedRequestProposalView: native.RetainedRequestProposal,
+  BRegRetainedRequestHistoryPage: native.RetainedRequestHistoryPage,
   BRegAttachmentSlot: native.BRegAttachmentSlot,
   BRegAttachmentUpload: native.BRegAttachmentUpload,
   BRegImmediateActionBinding: native.BRegImmediateActionBinding,
@@ -382,4 +449,7 @@ module.exports = {
   BRegPreparedLifecycle,
   BRegRecoveredCreate: native.BRegRecoveredCreate,
   BRegRecoveredLifecycle: native.BRegRecoveredLifecycle,
+  BRegIngestionChunk: native.BRegIngestionChunk,
+  BRegIngestionPrefixDigest: native.BRegIngestionPrefixDigest,
+  encodeIngestionChunk,
 };

package/breg/index.d.ts

@@ -41,6 +41,30 @@ export declare class BaseRegistryClient {
   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. */
   batchRecords(binding: BRegBatchBinding, request: any, idempotencyKey: string): Promise<CompleteOutcome>
+  /**
+   * Announce one whole input and open a durable ingestion run for it. The
+   * run request names the access profile, which the client selects for the
+   * exchange.
+   */
+  createIngestionRun(entityRoute: string, request: any): Promise<CompleteOutcome>
+  /** Read one bounded page of ingestion runs for one entity route. */
+  listIngestionRuns(entityRoute: string, query?: any | undefined | null): Promise<CompleteOutcome>
+  /** Read the current durable state of one ingestion run. */
+  readIngestionRun(entityRoute: string, runId: string, accessProfile?: string | undefined | null): Promise<CompleteOutcome>
+  /**
+   * Submit one bounded chunk of an open ingestion run under the run's
+   * access profile. A resubmitted chunk replays its retained receipt
+   * instead of executing twice.
+   */
+  submitIngestionChunk(entityRoute: string, runId: string, chunk: BRegIngestionChunk, profileId: string): Promise<CompleteOutcome>
+  /** Cancel an open ingestion run. Committed chunks stay committed. */
+  cancelIngestionRun(entityRoute: string, runId: string, accessProfile?: string | undefined | null): Promise<CompleteOutcome>
+  /**
+   * Read the retained receipt of one committed chunk under the run's
+   * access profile. An erased receipt answers with the
+   * `ingestion.receipt_erased` problem instead.
+   */
+  ingestionChunkReceipt(entityRoute: string, runId: string, chunkIndex: number, profileId: string): Promise<CompleteOutcome>
   /** Tombstone one record against its current strong ETag. */
   tombstoneRecord(binding: BRegTombstoneBinding, recordIdentifier: string, etag: string, idempotencyKey: string, formatValue?: string | undefined | null): Promise<CompleteOutcome>
   /**
@@ -53,6 +77,11 @@ export declare class BaseRegistryClient {
   /** Empty one governed attachment slot. */
   deleteAttachment(slot: BRegAttachmentSlot, recordIdentifier: string, etag: string, idempotencyKey: string, formatValue?: string | undefined | null): Promise<CompleteOutcome>
   lifecycleActions(authority: BRegLifecycleAuthority, record: any, formatValue?: string | undefined | null): Array<BRegLifecycleAction>
+  /**
+   * Decode one already loaded record's retained request-history page.
+   * This performs no I/O and does not advance the returned continuation.
+   */
+  requestHistory(record: any, formatValue?: string | undefined | null): RetainedRequestHistoryPage | null
   executeLifecycleAction(action: BRegLifecycleAction, idempotencyKey: string): Promise<CompleteOutcome>
   /** Prepare inert lifecycle evidence before any token acquisition or I/O. */
   prepareLifecycleAction(authority: BRegLifecycleAuthority, record: any, action: BRegLifecycleAction, idempotencyKey: string, formatValue?: string | undefined | null): BRegPreparedLifecycle
@@ -151,15 +180,42 @@ export declare class BRegImmediateActionBinding {
 }
 export type ImmediateActionBinding = BRegImmediateActionBinding
 
+/**
+ * One bounded, digest-bound chunk of an ingestion run. The chunk digest is
+ * derived in Rust from the exact canonical batch body the items hash to.
+ */
+export declare class BRegIngestionChunk {
+  get chunkIndex(): number
+  get itemCount(): number
+  /** The derived lowercase SHA-256 of the chunk's canonical batch body. */
+  get digest(): string
+  get prefixDigest(): string
+}
+export type IngestionChunk = BRegIngestionChunk
+
+/**
+ * Accumulate the raw source bytes of one ingestion input and derive the
+ * prefix digest the run binds: the lowercase SHA-256 of everything absorbed
+ * through the end of the current chunk. The digest of an empty accumulation
+ * is `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`.
+ * The digest is never a chain over chunk digests: the server stores it as an
+ * opaque value and cannot re-derive the raw bytes.
+ */
+export declare class BRegIngestionPrefixDigest {
+  constructor()
+  /** Absorb the next raw source bytes, typically one chunk's source extent. */
+  update(data: Buffer): void
+  /** The lowercase SHA-256 of every raw source byte absorbed so far. */
+  digest(): string
+}
+export type IngestionPrefixDigest = BRegIngestionPrefixDigest
+
 export declare class BRegLifecycleAction {
   withReason(reason: string): BRegLifecycleAction
   get bodyJson(): string
-  get reviewJson(): string | null
   get operation(): string
-  get stage(): string | null
   get href(): string
   get body(): any
-  get review(): any | null
 }
 export type LifecycleAction = BRegLifecycleAction
 
@@ -252,6 +308,37 @@ export declare class PrivateKeyJwt {
 }
 export type PrivateKeyJwtBinding = PrivateKeyJwt
 
+/** One inert caller-visible target written by an applied request. */
+export declare class RequestResultReference {
+  get targetEntityIdentifier(): string
+  get targetRecordIdentifier(): string
+  get targetRevision(): number
+  toString(): string
+}
+
+/** One explicitly loaded retained request-history page. */
+export declare class RetainedRequestHistoryPage {
+  get proposals(): Array<RetainedRequestProposal>
+  get nextAfterProposalVersion(): number | null
+  findProposal(requestEntityIdentifier: string, requestIdentifier: string, proposalVersion: number): RetainedRequestProposal | null
+  findApplication(requestEntityIdentifier: string, requestIdentifier: string, proposalVersion: number, applicationIdentifier: string): RetainedRequestProposal | null
+  toString(): string
+}
+
+/** One exact retained proposal in an explicitly loaded history page. */
+export declare class RetainedRequestProposal {
+  get requestEntityIdentifier(): string
+  get requestIdentifier(): string
+  get proposalVersion(): number
+  get bregState(): string
+  get current(): boolean
+  get detailErased(): boolean
+  get applicationIdentifier(): string | null
+  get resultLinkCount(): number
+  get resultReferences(): Array<RequestResultReference>
+  toString(): string
+}
+
 export interface CompleteOutcome {
   kind: string
   value: any
@@ -260,6 +347,15 @@ export interface CompleteOutcome {
   location?: string
 }
 
+/**
+ * Encode one ingestion chunk submission: derive its digest in Rust and bind
+ * the announced prefix digest into the exact wire body. `items` are the same
+ * batch items the entity's atomic batch route executes; `prefixDigest` is the
+ * lowercase SHA-256 of the complete raw source input through the end of this
+ * chunk, which `BRegIngestionPrefixDigest` accumulates.
+ */
+export declare function encodeIngestionChunk(chunkIndex: number, items: any, prefixDigest: string): BRegIngestionChunk
+
 /** Validated product result serialized before the JavaScript number boundary. */
 export interface JsonOutcome {
   kind: string

package/casework/client.d.ts

@@ -1,4 +1,7 @@
+/** An integer for which `Number.isSafeInteger` is true. */
 export type SafeInteger = number
+/** A string validated as an RFC 9562 UUID by the native binding. */
+export type Uuid = string
 export type JsonScalar = string | number | boolean | null
 export type JsonValue = JsonScalar | ReadonlyArray<JsonValue> | { readonly [key: string]: JsonValue }
 export type JsonObject = { readonly [key: string]: JsonValue }
@@ -13,7 +16,7 @@ export interface CaseworkClientConfig {
 }
 
 export type InboxView = 'mine' | 'my_teams' | 'team_holdings' | 'overdue' | 'completed_by_me'
-export type OccurrenceKind = 'review' | 'application' | 'hosted'
+export type OccurrenceKind = 'review' | 'application'
 export type OccurrenceState = 'open' | 'claimed' | 'waiting_applicant' | 'waiting_application' | 'synchronizing' | 'completed' | 'superseded' | 'cancelled'
 export type OperationName = string
 export type AttemptState = 'pending' | 'uncertain' | 'completed' | 'refused'
@@ -21,8 +24,9 @@ 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> }
+export type TaskGrantBounds = { type: 'evidence'; requirement: string } | { type: 'breg'; permissions: ReadonlyArray<TaskPermission> } | { type: 'scheduling'; permissions: ReadonlyArray<SchedulingTaskPermission> }
 export interface TaskPermission { collection: string; operations: ReadonlyArray<string> }
+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 }
 export interface TaskTemplatePreview {
@@ -84,7 +88,6 @@ export interface WorkItem {
   updatedAt: string
   actions: ReadonlyArray<CaseworkAction>
   routingCopy?: CorrectionRoutingCopy
-  hosted?: HostedWorkItemContext
   routing?: WorkItemRouting
   clockOccurrences?: ReadonlyArray<ClockOccurrenceView>
   liveAttempt?: AttemptStatus
@@ -213,85 +216,6 @@ export interface SourcePolicy {
   description: string
   requests: ReadonlyArray<SourceRequestPolicy>
 }
-export interface HostedRetentionPolicy { terminalDays: SafeInteger; accountabilityDays: SafeInteger }
-export interface HostedOutcomePolicy { id: string; label: string; reasonRequired: boolean }
-export interface HostedKindPolicy {
-  id: string
-  version: string
-  queue: string
-  decidingProfiles: ReadonlyArray<string>
-  retention: HostedRetentionPolicy
-  displaySchema: JsonValue
-  outcomes: ReadonlyArray<HostedOutcomePolicy>
-}
-export interface HostedWorkItemContext {
-  requesterReference: string
-  kind: string
-  version: string
-  display: JsonValue
-  kindPolicyDigest: string
-  outcomes: ReadonlyArray<HostedOutcomePolicy>
-}
-export interface HostedCreateRequest { kind: string; requesterReference: string; display: JsonValue }
-export interface HostedNoteRequest { note: string }
-export interface HostedCancelRequest { reason: string }
-export interface HostedDecisionRequest { outcome: string; reason?: string }
-export interface RequesterHostedItem {
-  itemId: string
-  requesterReference: string
-  kind: string
-  version: string
-  display: JsonValue
-  state: OccurrenceState
-  revision: SafeInteger
-  kindPolicyDigest: string
-  createdAt: string
-  updatedAt: string
-}
-export type HostedTerminalResult = {
-  itemId: string
-  eventId: string
-  requesterReference: string
-  kindPolicyDigest: string
-  terminalAt: string
-} & (
-  | { state: 'completed'; outcome: string; actorRef: string }
-  | { state: 'cancelled'; cancellationReason: string }
-)
-export interface HostedTerminalQuery { cursor?: string; limit?: SafeInteger }
-export interface HostedPageQuery { cursor?: string; limit?: SafeInteger }
-export interface HostedNote {
-  noteId: string
-  itemId: string
-  note: string
-  itemRevision: SafeInteger
-  recordedAt: string
-}
-export type HostedHistoryKind = 'created' | 'claimed' | 'assigned' | 'delegated' | 'caseload_moved' | 'released' | 'note_added' | 'completed' | 'cancelled'
-export interface HostedHistoryEntry {
-  eventId: string
-  itemId: string
-  itemRevision: SafeInteger
-  kind: HostedHistoryKind
-  occurredAt: string
-  actorRef?: string
-  assignment?: AssignmentContext
-  note?: string
-  outcome?: string
-  reason?: string
-  cancellationReason?: string
-}
-export interface HostedAccountabilityRecord {
-  itemId: string
-  eventId: string
-  actorRef: string
-  actor: IssuerPrincipal
-  profileId: string
-  outcome: string
-  reason?: string
-  recordedAt: string
-  retainedUntil: string
-}
 export interface Description {
   projectId: string
   policyVersion: string
@@ -299,7 +223,6 @@ export interface Description {
   sources: ReadonlyArray<SourcePolicy>
   calendars: ReadonlyArray<CalendarPolicy>
   clocks: ReadonlyArray<ClockPolicy>
-  hostedKinds: ReadonlyArray<HostedKindPolicy>
 }
 export interface TeamRecord {
   id: string
@@ -354,6 +277,11 @@ export type KnownCaseworkProblemCode =
   | 'request.source-rejected'
   | 'request.unprocessable'
   | 'request.unsupported-media-type'
+  | 'review.initiator-excluded'
+  | 'review.initiator-required'
+  | 'review.result-expired'
+  | 'review.submission-conflict'
+  | 'review.task-not-held'
   | 'runtime.failure'
   | 'service.unavailable'
   | 'source-profile.not-applicable'
@@ -372,6 +300,7 @@ 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 class CaseworkClientError extends Error {
   readonly kind: 'configuration' | 'invalid_request' | 'transport' | 'problem' | 'protocol'
@@ -382,10 +311,10 @@ 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'
+    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?: string
+  readonly protocolFailure?: CaseworkProtocolFailure
 }
 
 export type ClockRuntimeState = 'running' | 'paused' | 'completed' | 'cancelled' | 'verification_pending' | 'source_facts_missing'
@@ -416,22 +345,157 @@ export interface ClockRecomputePreview { previewId: string; clockId: string; hol
 export interface ClockRecomputeApplyRequest { previewId: string }
 export interface ClockRecomputeResult { previewId: string; appliedOccurrences: ReadonlyArray<string> }
 
+export type ContentDigest = `sha256:${string}`
+export interface ReviewSubjectBinding { source: string; type: string; id: string; version: string; digest: ContentDigest }
+export interface ReviewPolicyBinding { id: string; version: string; digest: ContentDigest }
+export interface HumanIdentity { issuer: string; subject: string }
+export type ReviewContext =
+  | { strategy: 'submitted'; snapshot: Readonly<Record<string, JsonValue>> }
+  | { strategy: 'source'; binding: { reference: string } }
+export interface ReviewCreateRequest {
+  kind: string
+  subject: ReviewSubjectBinding
+  requesterReference: string
+  initiator?: HumanIdentity
+  context: ReviewContext
+  resultConstraints?: JsonObject | null
+}
+export interface ReviewRequestAccepted {
+  requestId: Uuid
+  subject: ReviewSubjectBinding
+  policy: ReviewPolicyBinding
+  submissionDigest: ContentDigest
+}
+export type ReviewRequestLifecycle = 'reviewing' | 'approved' | 'rejected' | 'changes_requested' | 'answered' | 'cancelled' | 'superseded'
+export interface ReviewRequestView extends ReviewRequestAccepted {
+  requesterReference: string
+  lifecycle: ReviewRequestLifecycle
+  activeStage?: string
+  createdAt: string
+  updatedAt: string
+}
+export type ReviewResultStatus = 'approved' | 'rejected' | 'changes_requested' | 'answered' | 'cancelled' | 'superseded'
+export interface ReviewResult extends ReviewRequestAccepted {
+  resultId: Uuid
+  status: ReviewResultStatus
+  outcome?: string
+  result?: JsonObject
+  completedAt: string
+  availableUntil: string
+}
+export type ReviewResultOutcome =
+  | { kind: 'available'; value: ReviewResult; traceId: string }
+  | { kind: 'pending' | 'concealed_or_unknown' | 'expired'; value: null; traceId: string }
+export interface ReviewResultFeedEntry { eventId: Uuid; requestId: Uuid; resultId: Uuid; completedAt: string }
+export interface ReviewResultFeedPage { items: ReadonlyArray<ReviewResultFeedEntry>; nextCursor?: Uuid }
+export interface ReviewCancelRequest { subject: ReviewSubjectBinding; reason: string }
+export type ReviewCancelResponse =
+  | { outcome: 'cancelled'; result: ReviewResult }
+  | { outcome: 'already_terminal'; result: ReviewResult }
+export interface ReviewPageQuery { cursor?: Uuid; limit?: SafeInteger }
+export interface ReviewTaskQuery extends ReviewPageQuery { queue?: string }
+export interface WorkItemHistoryQuery { cursor?: string; limit?: SafeInteger }
+export type ReviewerTaskState = 'open' | { held: { holder: IssuerPrincipal } } | 'decided'
+export interface ReviewerTask {
+  taskId: Uuid
+  requestId: Uuid
+  stageIndex: SafeInteger
+  stageId: string
+  queue: string
+  revision: SafeInteger
+  eligibleProfiles: ReadonlyArray<string>
+  state: ReviewerTaskState
+  decidedByCaller?: boolean
+}
+export interface ReviewTaskPage { items: ReadonlyArray<ReviewerTask>; nextCursor?: Uuid }
+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>> }
+  | { strategy: 'source'; reference: string; bindingStatus: ReviewSourceBindingStatus; projection?: ReviewSourceProjection }
+export interface ReviewTaskContext {
+  taskId: Uuid
+  requestId: Uuid
+  subject: ReviewSubjectBinding
+  requesterReference: string
+  policy: ReviewPolicyBinding
+  policySnapshot: ReviewKindPolicySnapshot
+  resultConstraints?: JsonObject
+  context: ReviewTaskContextData
+}
+export type ReviewClockCorrelation =
+  | { scope: 'subject'; source: string; subjectType: string; id: string }
+  | { scope: 'activity'; taskId: Uuid; stageId: string }
+export interface ReviewClockOccurrence {
+  clockOccurrenceId: Uuid
+  clockId: string
+  requestId: Uuid
+  correlation: ReviewClockCorrelation
+  state: 'running' | 'paused' | 'completed' | 'cancelled' | 'source_facts_missing'
+  policyDigest: ContentDigest
+  anchorAt: string
+  dueAt?: string
+  atRiskAt?: string
+  completedAt?: string
+}
+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 }
+export interface ReviewTaskDecisionRequest { decision: ReviewerDecision }
+export type ReviewHistoryAudience = 'reviewers' | 'requester'
+export interface ReviewNoteRequest { audience: ReviewHistoryAudience; note: string }
+export interface ReviewHistoryEntry { eventId: Uuid; requestId: Uuid; taskId?: Uuid; kind: string; actorRef?: string; detail: JsonValue; occurredAt: string }
+export interface ReviewHistoryPage { items: ReadonlyArray<ReviewHistoryEntry>; nextCursor?: Uuid }
+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
+}
+export interface ReviewStagePolicy { id: string; queue: string; decidingProfiles: ReadonlyArray<string>; requiredApprovals: SafeInteger; excludeInitiator?: boolean; excludePreviousStageReviewers?: boolean }
+export interface ReviewRetentionPolicy { terminalDays: SafeInteger; accountabilityDays: SafeInteger }
+export interface ReviewKindPolicySnapshot {
+  identity: ReviewPolicyBinding
+  purpose: 'approval' | 'answer'
+  contextStrategy: 'submitted' | 'source'
+  stages: ReadonlyArray<ReviewStagePolicy>
+  clocks?: ReadonlyArray<string>
+  retention: ReviewRetentionPolicy
+  displaySchema: JsonValue
+  resultSchema?: JsonValue
+  outcomes?: ReadonlyArray<{ id: string; label: string; settlement: 'rejected' | 'changes_requested' | 'answered'; reasonRequired: boolean; resultRequired?: boolean }>
+}
+
 export class CaseworkClient {
   constructor(config: CaseworkClientConfig)
   description(token: string, profile: string): Promise<CaseworkOutcome<Description>>
-  createHostedItem(token: string, profile: string, idempotencyKey: string, request: HostedCreateRequest): Promise<CaseworkOutcome<RequesterHostedItem>>
-  getHostedItem(token: string, profile: string, itemId: string): Promise<CaseworkOutcome<RequesterHostedItem>>
-  addHostedNote(token: string, profile: string, itemId: string, expectedRevision: SafeInteger, idempotencyKey: string, note: HostedNoteRequest): Promise<CaseworkOutcome<RequesterHostedItem>>
-  requesterHostedNotes(token: string, profile: string, itemId: string, query?: HostedPageQuery | null): Promise<CaseworkOutcome<Page<HostedNote>>>
-  cancelHostedItem(token: string, profile: string, itemId: string, expectedRevision: SafeInteger, idempotencyKey: string, cancellation: HostedCancelRequest): Promise<CaseworkOutcome<HostedTerminalResult>>
-  hostedTerminalItems(token: string, profile: string, query?: HostedTerminalQuery | null): Promise<CaseworkOutcome<Page<HostedTerminalResult>>>
-  listHostedWorkItems(token: string, profile: string, query: ListWorkItemsQuery): Promise<CaseworkOutcome<WorkItemPage>>
-  getHostedWorkItem(token: string, profile: string, itemId: string): Promise<CaseworkOutcome<WorkItem>>
-  hostedWorkItemHistory(token: string, profile: string, itemId: string, query?: HostedPageQuery | null): Promise<CaseworkOutcome<Page<HostedHistoryEntry>>>
-  hostedAccountabilityRecord(token: string, profile: string, eventId: string): Promise<CaseworkOutcome<HostedAccountabilityRecord>>
-  claimHostedWorkItem(token: string, profile: string, action: CaseworkAction, idempotencyKey: string): Promise<CaseworkOutcome<MutationResponse>>
-  releaseHostedWorkItem(token: string, profile: string, action: CaseworkAction, idempotencyKey: string): Promise<CaseworkOutcome<MutationResponse>>
-  decideHostedWorkItem(token: string, profile: string, action: CaseworkAction, idempotencyKey: string, decision: HostedDecisionRequest): Promise<CaseworkOutcome<HostedTerminalResult>>
+  createOrRecoverReviewRequest(token: string, profile: string, idempotencyKey: string, request: ReviewCreateRequest, expectedSubmissionDigest: ContentDigest): Promise<CaseworkOutcome<ReviewRequestAccepted>>
+  reviewRequest(token: string, profile: string, requestId: Uuid): Promise<CaseworkOutcome<ReviewRequestView>>
+  reviewResult(token: string, profile: string, accepted: ReviewRequestAccepted): Promise<ReviewResultOutcome>
+  reviewResults(token: string, profile: string, query?: ReviewPageQuery | null): Promise<CaseworkOutcome<ReviewResultFeedPage>>
+  cancelReviewRequest(token: string, profile: string, accepted: ReviewRequestAccepted, idempotencyKey: string, request: ReviewCancelRequest): Promise<CaseworkOutcome<ReviewCancelResponse>>
+  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>>
+  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>>
+  listReviewTaskGrants(token: string, profile: string, sourceProfile: string, taskId: Uuid): Promise<CaseworkOutcome<TaskGrantList>>
+  approveReviewTaskGrant(token: string, profile: string, sourceProfile: string, taskId: Uuid, expectedRevision: SafeInteger, idempotencyKey: string, approval: TaskApprovalRequest): Promise<CaseworkOutcome<TaskGrantView>>
+  revokeReviewTaskGrant(token: string, profile: string, taskId: Uuid, grantId: string): Promise<CaseworkOutcome<TaskGrantRevocation>>
+  claimReviewTask(token: string, profile: string, taskId: Uuid, expectedRevision: SafeInteger, idempotencyKey: string, sourceProfile?: string | null): Promise<CaseworkOutcome<ReviewerTask>>
+  releaseReviewTask(token: string, profile: string, taskId: Uuid, expectedRevision: SafeInteger, idempotencyKey: string): Promise<CaseworkOutcome<ReviewerTask>>
+  assignReviewTask(token: string, profile: string, taskId: Uuid, expectedRevision: SafeInteger, idempotencyKey: string, request: AssignmentRequest, sourceProfile?: string): Promise<CaseworkOutcome<ReviewerTask>>
+  delegateReviewTask(token: string, profile: string, taskId: Uuid, expectedRevision: SafeInteger, idempotencyKey: string, request: DelegateRequest, sourceProfile?: string): Promise<CaseworkOutcome<ReviewerTask>>
+  reviewTaskDraft(token: string, profile: string, taskId: Uuid, sourceProfile?: string): Promise<CaseworkOutcome<ReviewTaskDraft | null>>
+  saveReviewTaskDraft(token: string, profile: string, taskId: Uuid, expectedRevision: SafeInteger, idempotencyKey: string, draft: ReviewTaskDraftInput, sourceProfile?: string): Promise<CaseworkOutcome<ReviewTaskDraft>>
+  deleteReviewTaskDraft(token: string, profile: string, taskId: Uuid, expectedRevision: SafeInteger, idempotencyKey: string, sourceProfile?: string): Promise<CaseworkOutcome<null>>
+  decideReviewTask(token: string, profile: string, taskId: Uuid, expectedRevision: SafeInteger, idempotencyKey: string, decision: ReviewTaskDecisionRequest, sourceProfile?: string | null): Promise<CaseworkOutcome<null>>
+  reviewHistory(token: string, profile: string, requestId: Uuid, query?: ReviewPageQuery | null, sourceProfile?: string | null): Promise<CaseworkOutcome<ReviewHistoryPage>>
+  addReviewNote(token: string, profile: string, requestId: Uuid, idempotencyKey: string, note: ReviewNoteRequest, sourceProfile?: string | null): Promise<CaseworkOutcome<ReviewHistoryEntry>>
+  reviewClocks(token: string, profile: string, requestId: Uuid, sourceProfile?: string | null): Promise<CaseworkOutcome<ReadonlyArray<ReviewClockOccurrence>>>
+  reviewAccountability(token: string, profile: string, eventId: Uuid): Promise<CaseworkOutcome<ReviewAccountabilityRecord>>
   listWorkItems(token: string, profile: string, sourceProfile: string, query: ListWorkItemsQuery): Promise<CaseworkOutcome<WorkItemPage>>
   nextWorkItem(token: string, profile: string, sourceProfile: string, query?: NextWorkItemQuery | null): Promise<CaseworkOutcome<WorkItemPage>>
   getWorkItem(token: string, profile: string, sourceProfile: string, itemId: string): Promise<CaseworkOutcome<WorkItem>>
@@ -451,7 +515,7 @@ export class CaseworkClient {
   decideWorkItem(token: string, profile: string, sourceProfile: string, action: CaseworkAction, idempotencyKey: string, decision: DecideRequest): Promise<CaseworkOutcome<MutationResponse>>
   recoverDecision(token: string, profile: string, sourceProfile: string, itemId: string, attemptId: string, recovery: RecoverAttemptRequest): Promise<CaseworkOutcome<MutationResponse>>
   recoverDecisionByKey(token: string, profile: string, sourceProfile: string, itemId: string, idempotencyKey: string, recovery: RecoverAttemptRequest): Promise<CaseworkOutcome<MutationResponse>>
-  workItemHistory(token: string, profile: string, sourceProfile: string, itemId: string, query?: HostedPageQuery | null): Promise<CaseworkOutcome<Page<HistoryEntry>>>
+  workItemHistory(token: string, profile: string, sourceProfile: string, itemId: string, query?: WorkItemHistoryQuery | null): Promise<CaseworkOutcome<Page<HistoryEntry>>>
   holdings(token: string, profile: string, sourceProfile: string, query?: HoldingsQuery | null): Promise<CaseworkOutcome<Page<HoldingSummary>>>
   directory(token: string, profile: string): Promise<CaseworkOutcome<DirectoryResponse>>
   directoryTargets(token: string, profile: string, query: DirectoryTargetsQuery): Promise<CaseworkOutcome<DirectoryTargetPage>>

package/casework/client.js

@@ -104,19 +104,32 @@ class CaseworkClient {
 
 for (const [method, jsonIndexes] of [
   ['description', []],
-  ['createHostedItem', [3]],
-  ['getHostedItem', []],
-  ['addHostedNote', [5]],
-  ['requesterHostedNotes', [3]],
-  ['cancelHostedItem', [5]],
-  ['hostedTerminalItems', [2]],
-  ['listHostedWorkItems', [2]],
-  ['getHostedWorkItem', []],
-  ['hostedWorkItemHistory', [3]],
-  ['hostedAccountabilityRecord', []],
-  ['claimHostedWorkItem', [2]],
-  ['releaseHostedWorkItem', [2]],
-  ['decideHostedWorkItem', [2, 4]],
+  ['createOrRecoverReviewRequest', [3]],
+  ['reviewRequest', []],
+  ['reviewResult', [2]],
+  ['reviewResults', [2]],
+  ['cancelReviewRequest', [2, 4]],
+  ['reviewKinds', []],
+  ['reviewKind', []],
+  ['reviewTasks', [2]],
+  ['reviewTask', []],
+  ['reviewTaskContext', []],
+  ['previewReviewTaskTemplates', []],
+  ['listReviewTaskGrants', []],
+  ['approveReviewTaskGrant', [6]],
+  ['revokeReviewTaskGrant', []],
+  ['claimReviewTask', []],
+  ['releaseReviewTask', []],
+  ['assignReviewTask', [5]],
+  ['delegateReviewTask', [5]],
+  ['reviewTaskDraft', []],
+  ['saveReviewTaskDraft', [5]],
+  ['deleteReviewTaskDraft', []],
+  ['decideReviewTask', [5]],
+  ['reviewHistory', [3]],
+  ['addReviewNote', [4]],
+  ['reviewClocks', []],
+  ['reviewAccountability', []],
   ['listWorkItems', [3]],
   ['nextWorkItem', [3]],
   ['getWorkItem', []],

package/casework/index.d.ts

@@ -3,19 +3,32 @@
 export declare class CaseworkClient {
   constructor(config: CaseworkClientConfig)
   description(token: string, profile: string): Promise<CaseworkOutcome>
-  createHostedItem(token: string, profile: string, idempotencyKey: string, request: any): Promise<CaseworkOutcome>
-  getHostedItem(token: string, profile: string, itemId: string): Promise<CaseworkOutcome>
-  addHostedNote(token: string, profile: string, itemId: string, expectedRevision: number, idempotencyKey: string, note: any): Promise<CaseworkOutcome>
-  requesterHostedNotes(token: string, profile: string, itemId: string, query?: any | undefined | null): Promise<CaseworkOutcome>
-  cancelHostedItem(token: string, profile: string, itemId: string, expectedRevision: number, idempotencyKey: string, cancellation: any): Promise<CaseworkOutcome>
-  hostedTerminalItems(token: string, profile: string, query?: any | undefined | null): Promise<CaseworkOutcome>
-  listHostedWorkItems(token: string, profile: string, query: any): Promise<CaseworkOutcome>
-  getHostedWorkItem(token: string, profile: string, itemId: string): Promise<CaseworkOutcome>
-  hostedWorkItemHistory(token: string, profile: string, itemId: string, query?: any | undefined | null): Promise<CaseworkOutcome>
-  hostedAccountabilityRecord(token: string, profile: string, eventId: string): Promise<CaseworkOutcome>
-  claimHostedWorkItem(token: string, profile: string, action: any, idempotencyKey: string): Promise<CaseworkOutcome>
-  releaseHostedWorkItem(token: string, profile: string, action: any, idempotencyKey: string): Promise<CaseworkOutcome>
-  decideHostedWorkItem(token: string, profile: string, action: any, idempotencyKey: string, decision: any): Promise<CaseworkOutcome>
+  createOrRecoverReviewRequest(token: string, profile: string, idempotencyKey: string, request: any, expectedSubmissionDigest: string): Promise<CaseworkOutcome>
+  reviewRequest(token: string, profile: string, requestId: string): Promise<CaseworkOutcome>
+  reviewResult(token: string, profile: string, accepted: any): Promise<CaseworkOutcome>
+  reviewResults(token: string, profile: string, query?: any | undefined | null): Promise<CaseworkOutcome>
+  cancelReviewRequest(token: string, profile: string, accepted: any, idempotencyKey: string, request: any): Promise<CaseworkOutcome>
+  reviewKinds(token: string, profile: string): Promise<CaseworkOutcome>
+  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>
+  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>
+  approveReviewTaskGrant(token: string, profile: string, sourceProfile: string, taskId: string, expectedRevision: number, idempotencyKey: string, approval: any): Promise<CaseworkOutcome>
+  revokeReviewTaskGrant(token: string, profile: string, taskId: string, grantId: string): Promise<CaseworkOutcome>
+  claimReviewTask(token: string, profile: string, taskId: string, expectedRevision: number, idempotencyKey: string, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  releaseReviewTask(token: string, profile: string, taskId: string, expectedRevision: number, idempotencyKey: string): Promise<CaseworkOutcome>
+  assignReviewTask(token: string, profile: string, taskId: string, expectedRevision: number, idempotencyKey: string, request: any, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  delegateReviewTask(token: string, profile: string, taskId: string, expectedRevision: number, idempotencyKey: string, request: any, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  reviewTaskDraft(token: string, profile: string, taskId: string, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  saveReviewTaskDraft(token: string, profile: string, taskId: string, expectedRevision: number, idempotencyKey: string, draft: any, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  deleteReviewTaskDraft(token: string, profile: string, taskId: string, expectedRevision: number, idempotencyKey: string, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  decideReviewTask(token: string, profile: string, taskId: string, expectedRevision: number, idempotencyKey: string, decision: any, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  reviewHistory(token: string, profile: string, requestId: string, query?: any | undefined | null, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  addReviewNote(token: string, profile: string, requestId: string, idempotencyKey: string, note: any, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  reviewClocks(token: string, profile: string, requestId: string, sourceProfile?: string | undefined | null): Promise<CaseworkOutcome>
+  reviewAccountability(token: string, profile: string, eventId: string): Promise<CaseworkOutcome>
   listWorkItems(token: string, profile: string, sourceProfile: string, query: any): Promise<CaseworkOutcome>
   nextWorkItem(token: string, profile: string, sourceProfile: string, query?: any | undefined | null): Promise<CaseworkOutcome>
   getWorkItem(token: string, profile: string, sourceProfile: string, itemId: string): Promise<CaseworkOutcome>

package/evidence/index.d.ts

@@ -265,8 +265,8 @@ export declare class SdJwtVcBatchResponse {
  * selector or disclosed value is copied into it here.
  */
 export type SubjectContinuity =
-  | { status: 'firstUse', receipt: any }
-  | { status: 'matched', receipt: any }
+  | { status: 'firstUse'; receipt: any }
+  | { status: 'matched'; receipt: any }
 
 /**
  * A response that satisfied every expectation.
@@ -306,7 +306,7 @@ export interface VerifiedEvidenceRequestBatch {
  * `{ status: "available", verified } | { status: "notAvailable" }`.
  */
 export type VerifiedEvidenceRequestBatchItem =
-  | { status: 'available', verified: VerifiedEvidence }
+  | { status: 'available'; verified: VerifiedEvidence }
   | { status: 'notAvailable' }
 
 /**

package/native.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const PACKAGE_VERSION = '0.32.0';
+const PACKAGE_VERSION = '0.34.0';
 const PRODUCTS = new Set(['discovery', 'evidence', 'relay', 'breg', 'casework']);
 
 function target() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@registrystack/client",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "description": "Unified Node.js client for Registry Stack products.",
   "license": "Apache-2.0",
   "homepage": "https://docs.registrystack.org/reference/client-api/",
@@ -57,8 +57,8 @@
     "typescript": "6.0.3"
   },
   "optionalDependencies": {
-    "@registrystack/client-darwin-arm64": "0.32.0",
-    "@registrystack/client-linux-arm64-gnu": "0.32.0",
-    "@registrystack/client-linux-x64-gnu": "0.32.0"
+    "@registrystack/client-darwin-arm64": "0.34.0",
+    "@registrystack/client-linux-arm64-gnu": "0.34.0",
+    "@registrystack/client-linux-x64-gnu": "0.34.0"
   }
 }