@registrystack/client 0.31.0 → 0.33.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

@@ -87,9 +87,47 @@ export class PrivateKeyJwt {
   bearerToken(): Promise<string>
 }
 
+/** One immutable verified person or grant context. Reconstruct after host source facts change. */
+export interface ExchangeContext {
+  issuer: string
+  subject: string
+  audience: string
+  generation: string
+  deadlineSeconds: SafeInteger
+  grantId?: string | null
+}
+
+export type ExchangePrivateKeyJwtConfig = PrivateKeyJwtConfig & {
+  resource: string
+  scopes: ReadonlyArray<string>
+}
+
+export interface FirstPartyExchangeSource {
+  key: PrivateJwk
+  /** Reviewed host attributes; registry_actor_kind must be human and grant claims are refused. */
+  attributes: Readonly<Record<string, JsonValue>>
+}
+
+export interface RemoteExchangeSource {
+  /** Exact assertion URL supplied by the authority client, such as Casework.taskAssertionEndpoint. */
+  endpoint: string
+  bootstrap: ExchangePrivateKeyJwtConfig
+  bootstrapResource: string
+  bootstrapScope: string
+  requestTimeoutMilliseconds?: SafeInteger | null
+  connectTimeoutMilliseconds?: SafeInteger | null
+  userAgent?: string | null
+  trustedRootCertificates?: string | null
+}
+
+export type ExchangeAuthorizationConfig =
+  | { client: ExchangePrivateKeyJwtConfig; context: ExchangeContext; firstParty: FirstPartyExchangeSource }
+  | { client: ExchangePrivateKeyJwtConfig; context: ExchangeContext; remote: RemoteExchangeSource }
+
 export type BaseRegistryAuthorization =
   | { static: string }
   | { privateKeyJwt: PrivateKeyJwtConfig }
+  | { exchange: ExchangeAuthorizationConfig }
 
 export interface BaseRegistryClientConfig {
   baseUrl: string
@@ -178,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' | 'superseded'
+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'
+    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
@@ -215,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>
@@ -227,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 {
@@ -305,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
@@ -554,6 +600,132 @@ 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
+
 export interface BRegChangeRequestCapability {
   readonly planner: {
     readonly kind: 'declarative' | 'rhai'
@@ -574,17 +746,13 @@ export interface BRegChangeRequestCapability {
     readonly possibleWriteCount: SafeInteger | null
     readonly possibleWriteOperations: ReadonlyArray<string>
   }
-  readonly reviewMode: 'none' | 'staged'
-  readonly stages: ReadonlyArray<{
-    readonly id: string
-    readonly approvals: SafeInteger
-    readonly excludeSubmitter: boolean
-    readonly excludePreviousReviewers: boolean
-  }> | null
+  readonly review: BRegRequestReviewRequirement
+  readonly onApproved: {
+    readonly mode: 'manual' | 'automatic'
+    readonly executor: string | 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
   }
 }
 
@@ -677,18 +845,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. */
@@ -801,9 +1005,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