@registrystack/client 0.43.0 → 0.45.0

package/breg/index.d.ts

@@ -15,27 +15,33 @@ export declare class BaseRegistryClient {
   statisticsPublish(dataset: string, period: string, status: string, accessProfile: string, idempotencyKey: string): Promise<RawOutcome>
   statisticsWithdraw(dataset: string, period: string, version: number, reason: string, accessProfile: string, idempotencyKey: string): Promise<RawOutcome>
   registryContract(accessProfile?: string | undefined | null): Promise<BRegMetadata>
-  entitySchema(recordTypeIdentifier: string, accessProfile?: string | undefined | null): Promise<RawOutcome>
+  recordSchema(recordTypeIdentifier: string, accessProfile?: string | undefined | null): Promise<RawOutcome>
   /** Retrieve one bounded first page of record revisions as inert JSON. */
-  recordRevisions(entityRoute: string, recordIdentifier: string, accessProfile?: string | undefined | null): Promise<RawOutcome>
+  recordRevisions(recordRoute: string, recordIdentifier: string, accessProfile?: string | undefined | null): Promise<RawOutcome>
   /** Retrieve one exact retained revision as validated inert record JSON. */
-  getRecordRevision(entityRoute: string, recordIdentifier: string, revision: number, options?: any | undefined | null): Promise<RawOutcome>
-  getRecord(entityRoute: string, recordIdentifier: string, options?: any | undefined | null): Promise<CompleteOutcome>
-  listRecords(entityRoute: string, options?: any | undefined | null): Promise<PageOutcome>
+  getRecordRevision(recordRoute: string, recordIdentifier: string, revision: number, options?: any | undefined | null): Promise<RawOutcome>
+  /**
+   * Read the first revision of one record as the compact
+   * `{recordType, recordId, revision, createdAt}` JSON, or null when the
+   * caller may not read it.
+   */
+  eventRecordCreationRevision(recordRoute: string, recordIdentifier: string, accessProfile?: string | undefined | null): Promise<string | null>
+  getRecord(recordRoute: string, recordIdentifier: string, options?: any | undefined | null): Promise<CompleteOutcome>
+  listRecords(recordRoute: string, options?: any | undefined | null): Promise<PageOutcome>
   continueList(value: any): Promise<PageOutcome>
-  getGeoJsonRecord(entityRoute: string, recordIdentifier: string, options?: any | undefined | null): Promise<CompleteOutcome>
-  listGeoJsonRecords(entityRoute: string, options?: any | undefined | null): Promise<PageOutcome>
+  getGeoJsonRecord(recordRoute: string, recordIdentifier: string, options?: any | undefined | null): Promise<CompleteOutcome>
+  listGeoJsonRecords(recordRoute: string, options?: any | undefined | null): Promise<PageOutcome>
   continueGeoJsonList(value: any): Promise<PageOutcome>
-  listCurrentRecords(entityRoute: string, options?: any | undefined | null): Promise<PageOutcome>
+  listCurrentRecords(recordRoute: string, options?: any | undefined | null): Promise<PageOutcome>
   continueCurrentList(value: any): Promise<PageOutcome>
-  listRecordsAsOf(entityRoute: string, options?: any | undefined | null): Promise<PageOutcome>
+  listRecordsAsOf(recordRoute: string, options?: any | undefined | null): Promise<PageOutcome>
   continueAsOfList(value: any): Promise<PageOutcome>
-  listSnapshotRecords(entityRoute: string, options?: any | undefined | null): Promise<PageOutcome>
+  listSnapshotRecords(recordRoute: string, options?: any | undefined | null): Promise<PageOutcome>
   continueSnapshotList(value: any): Promise<PageOutcome>
-  listRelationshipRecords(entityRoute: string, recordIdentifier: string, pathRoute: string, options?: any | undefined | null): Promise<PageOutcome>
+  listRelationshipRecords(recordRoute: string, recordIdentifier: string, pathRoute: string, options?: any | undefined | null): Promise<PageOutcome>
   continueRelationshipList(value: any): Promise<PageOutcome>
-  lookupRecord(entityRoute: string, selector: string, values?: any | undefined | null, options?: any | undefined | null): Promise<CompleteOutcome>
-  startProposal(binding: BRegActionBinding, inputsJson: string, key: string): Promise<BRegProposal>
+  lookupRecord(recordRoute: string, selector: string, values?: any | undefined | null, options?: any | undefined | null): Promise<CompleteOutcome>
+  startProposal(binding: BRegActionBinding, inputs: any, key: string): Promise<BRegProposal>
   readProposal(proposal: BRegProposal): Promise<BRegProposal>
   readProposalSubmission(proposal: BRegProposal, version: number): Promise<CompleteOutcome>
   getProposal(binding: BRegProposalGetBinding, id: string): Promise<BRegProposal>
@@ -47,8 +53,12 @@ export declare class BaseRegistryClient {
   readProposalReviewContextBatch(binding: BRegProposalReviewBinding, ids: Array<string>): Promise<CompleteOutcome>
   uploadProposalAttachment(proposal: BRegProposal, slot: string, contentType: string, bytes: Buffer, key: string): Promise<BRegProposal>
   deleteProposalAttachment(proposal: BRegProposal, slot: string, key: string): Promise<BRegProposal>
-  listProposals(collection: BRegProposalCollection, queryJson: string): Promise<ProposalPage>
-  prepareProposal(proposal: BRegProposal, operation: string, bodyJson: string, key: string): BRegPreparedProposal
+  listProposals(collection: BRegProposalCollection, query: any): Promise<ProposalPage>
+  prepareProposal(proposal: BRegProposal, operation: string, body: any, key: string): BRegPreparedProposal
+  /** Prepare a transition from exact JSON through the same lifecycle authority. */
+  prepareProposalJson(proposal: BRegProposal, operation: string, bodyJson: string, key: string): BRegPreparedProposal
+  /** List through the same metadata-selected collection with an exact JSON query. */
+  listProposalsJson(collection: BRegProposalCollection, queryJson: string): Promise<ProposalPage>
   recoverProposal(proposal: BRegProposal, attempt: BRegPreparedProposal): BRegPreparedProposal
   executeProposal(attempt: BRegPreparedProposal): Promise<BRegProposal>
   /** Fetch opaque target conditions for one metadata-selected action. */
@@ -58,7 +68,7 @@ export declare class BaseRegistryClient {
   /**
    * Invoke one metadata-selected immediate action. An invocation whose
    * outcome is unknown is resent identically under the same key, at most
-   * `maxMutationRetries` times.
+   * `maximumMutationRetries` times.
    */
   invokeAction(binding: BRegActionBinding, inputs: any, idempotencyKey: string, conditions?: BRegActionTargetConditions | undefined | null): Promise<CompleteOutcome>
   /**
@@ -75,7 +85,7 @@ export declare class BaseRegistryClient {
   /**
    * Explicitly send a recovered invocation under its original key. An
    * invocation whose outcome is unknown is resent identically under that
-   * key, at most `maxMutationRetries` times.
+   * key, at most `maximumMutationRetries` times.
    */
   executeRecoveredAction(binding: BRegActionBinding, recovered: BRegRecoveredAction): Promise<CompleteOutcome>
   /** Execute a recovered proposal start with its exact original request and key. */
@@ -91,7 +101,7 @@ export declare class BaseRegistryClient {
   /**
    * Execute one metadata-selected atomic batch. A batch whose outcome is
    * unknown is resent identically under the same key, at most
-   * `maxMutationRetries` times.
+   * `maximumMutationRetries` times.
    */
   batchRecords(binding: BRegBatchBinding, request: any, idempotencyKey: string): Promise<CompleteOutcome>
   /**
@@ -99,42 +109,42 @@ export declare class BaseRegistryClient {
    * 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>
+  createIngestionRun(recordRoute: string, request: any): Promise<CompleteOutcome>
+  /** Read one bounded page of ingestion runs for one record route. */
+  listIngestionRuns(recordRoute: 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>
+  readIngestionRun(recordRoute: 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>
+  submitIngestionChunk(recordRoute: 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>
+  cancelIngestionRun(recordRoute: 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>
+  ingestionChunkReceipt(recordRoute: 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>
-  getRecordJson(entityRoute: string, recordIdentifier: string, options?: any | undefined | null): Promise<JsonOutcome>
-  listRecordsJson(entityRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
+  getRecordJson(recordRoute: string, recordIdentifier: string, options?: any | undefined | null): Promise<JsonOutcome>
+  listRecordsJson(recordRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
   continueListJson(value: any): Promise<JsonOutcome>
-  getGeoJsonRecordJson(entityRoute: string, recordIdentifier: string, options?: any | undefined | null): Promise<JsonOutcome>
-  listGeoJsonRecordsJson(entityRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
+  getGeoJsonRecordJson(recordRoute: string, recordIdentifier: string, options?: any | undefined | null): Promise<JsonOutcome>
+  listGeoJsonRecordsJson(recordRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
   continueGeoJsonListJson(value: any): Promise<JsonOutcome>
-  listCurrentRecordsJson(entityRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
+  listCurrentRecordsJson(recordRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
   continueCurrentListJson(value: any): Promise<JsonOutcome>
-  listRecordsAsOfJson(entityRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
+  listRecordsAsOfJson(recordRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
   continueAsOfListJson(value: any): Promise<JsonOutcome>
-  listSnapshotRecordsJson(entityRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
+  listSnapshotRecordsJson(recordRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
   continueSnapshotListJson(value: any): Promise<JsonOutcome>
-  listRelationshipRecordsJson(entityRoute: string, recordIdentifier: string, pathRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
+  listRelationshipRecordsJson(recordRoute: string, recordIdentifier: string, pathRoute: string, options?: any | undefined | null): Promise<JsonOutcome>
   continueRelationshipListJson(value: any): Promise<JsonOutcome>
-  lookupRecordJson(entityRoute: string, selector: string, valuesJson?: string | undefined | null, options?: any | undefined | null): Promise<JsonOutcome>
+  lookupRecordJson(recordRoute: string, selector: string, valuesJson?: string | undefined | null, options?: any | undefined | null): Promise<JsonOutcome>
   /** Fetch opaque target conditions from exact action-input JSON. */
   actionTargetConditionsJson(binding: BRegActionBinding, inputsJson: string): Promise<BRegActionTargetConditions>
   /** Read field-guard availability from exact action-input JSON. */
@@ -207,6 +217,8 @@ export declare class BRegIngestionPrefixDigest {
 export type IngestionPrefixDigest = BRegIngestionPrefixDigest
 
 export declare class BRegMetadata {
+  /** The event record descriptor declared for one record type, as JSON text. */
+  eventRecordDescriptor(recordType: string): string
   /** Read-only capability inventory for each exact Action/profile pair. */
   get proposalActions(): any
   /** Caller-filtered inert descriptors. Selectors below remain the only authority constructors. */
@@ -328,6 +340,22 @@ export interface CompleteOutcome {
  */
 export declare function encodeIngestionChunk(chunkIndex: number, items: any, prefixDigest: string): BRegIngestionChunk
 
+/**
+ * Project one record revision into the event record view. The input is the
+ * JSON arguments document of the Rust projection; the result is the view
+ * document as JSON text.
+ */
+export declare function eventRecordView(argumentsJson: string): string
+
+/** Exact BReg hook request supplied by a receiver. */
+export interface HookDeliveryInput {
+  method: string
+  path: string
+  headers: Record<string, string>
+  body: Buffer
+  key: Buffer
+}
+
 /** Validated product result serialized before the JavaScript number boundary. */
 export interface JsonOutcome {
   kind: string
@@ -364,8 +392,8 @@ export interface RawOutcome {
   reprDigest?: string
 }
 
-/** Authenticated BReg webhook metadata and exact body. */
-export interface VerifiedWebhookDelivery {
+/** Authenticated BReg hook metadata and exact body. */
+export interface VerifiedHookDelivery {
   id: string
   source: string
   type: string
@@ -378,14 +406,5 @@ export interface VerifiedWebhookDelivery {
   body: Buffer
 }
 
-/** Verify a BReg Version 1 webhook signature without applying receiver policy. */
-export declare function verifyWebhookDelivery(input: WebhookDeliveryInput): VerifiedWebhookDelivery
-
-/** Exact BReg webhook request supplied by a receiver. */
-export interface WebhookDeliveryInput {
-  method: string
-  path: string
-  headers: Record<string, string>
-  body: Buffer
-  key: Buffer
-}
+/** Verify a BReg Version 1 hook signature without applying receiver policy. */
+export declare function verifyHookDelivery(input: HookDeliveryInput): VerifiedHookDelivery

package/casework/client.d.ts

@@ -8,11 +8,11 @@ export type JsonObject = { readonly [key: string]: JsonValue }
 
 export interface CaseworkClientConfig {
   baseUrl: string
-  requestTimeoutMilliseconds?: SafeInteger | null
-  connectTimeoutMilliseconds?: SafeInteger | null
-  maxResponseBytes?: SafeInteger | null
-  userAgent?: string | null
-  trustedRootCertificates?: string | null
+  attemptTimeoutMilliseconds?: SafeInteger
+  connectTimeoutMilliseconds?: SafeInteger
+  maximumResponseBytes?: SafeInteger
+  userAgent?: string
+  trustedRootCertificates?: string
   /**
    * How many times an idempotency-keyed mutation whose outcome is unknown is
    * resent, identically and under the same key, before its error is
@@ -20,7 +20,7 @@ export interface CaseworkClientConfig {
    * unkeyed operations, and review request create and cancel are never
    * resent. Any other value is a `configuration` error.
    */
-  maxMutationRetries?: SafeInteger | null
+  maximumMutationRetries?: SafeInteger
 }
 
 export type PageStatus = 'complete' | 'budget-exhausted' | 'source-unavailable'
@@ -72,7 +72,7 @@ export type DirectoryTargetPage = Page<DirectoryMember>
 export interface QueueRecord { id: string; label: string }
 export type RoutingPredicate = { equals: JsonValue } | { oneOf: ReadonlyArray<JsonValue> }
 export interface RoutingCondition { stage?: string; fields?: Readonly<Record<string, RoutingPredicate>> }
-export interface RoutingRule { id: string; because: string; when: RoutingCondition; queue: string }
+export interface RoutingRule { id: string; label?: string; because: string; when: RoutingCondition; queue: string }
 export type WorkingWeekday = 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday' | 'sunday'
 export interface CalendarPolicy { id: string; timezone: string; workingWeekdays: ReadonlyArray<WorkingWeekday>; holidaySet: string }
 export interface WorkingDays { workingDays: SafeInteger }
@@ -189,7 +189,7 @@ export class CaseworkClientError extends Error {
   readonly traceId?: string
   readonly validation?: {
     readonly path: string
-    readonly reason: 'policy-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' | 'public-reason-required' | 'public-reason-not-declared' | 'approval-outcome-differs'
+    readonly reason: 'binding-invalid' | 'field-required' | 'policy-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' | 'public-reason-required' | 'public-reason-not-declared' | 'approval-outcome-differs'
     /** Outcome identifiers the review policy declares for the requested settlement when an outcome is refused; empty otherwise. */
     readonly allowed: ReadonlyArray<string>
   }
@@ -364,15 +364,16 @@ export interface ReviewAccountabilityRecord {
   occurredAt: string; retainedUntil: string
   decisionReceipt?: ReviewDecisionReceipt
 }
-export interface ReviewStagePolicy { id: string; queue: string; decidingProfiles: ReadonlyArray<string>; requiredApprovals: SafeInteger; excludeInitiator?: boolean; excludePreviousStageReviewers?: boolean }
+export interface ReviewStagePolicy { id: string; label?: string; queue: string; decidingProfiles: ReadonlyArray<string>; requiredApprovals: SafeInteger; negativeDecisions?: 'settle' | 'advise'; excludeInitiator?: boolean; excludePreviousStageReviewers?: boolean }
 export interface ReviewRetentionPolicy { terminalRetentionDays: SafeInteger; accountabilityRetentionDays: SafeInteger }
 export interface ReviewContextContract { id: string; revision: ContentDigest; schemaDigest: ContentDigest }
 export type ReviewContextPolicy = { mode: 'submitted' } | { mode: 'current-source'; provider: string; contract: ReviewContextContract }
 export type ReviewContextCapability = 'human-display' | 'service-status' | 'task-grant-context' | 'routing-context'
 export interface ReviewContextProviderPolicy { id: string; capabilities: ReadonlyArray<ReviewContextCapability>; sourceNamespace: string; deploymentRef: string; serviceProfiles?: Partial<Record<ReviewContextCapability, string>> }
-export interface ReviewPolicy { id: string; version: string; purpose: 'approval' | 'answer'; context: ReviewContextPolicy; routing?: ReadonlyArray<RoutingRule>; stages: ReadonlyArray<ReviewStagePolicy>; clocks?: ReadonlyArray<string>; retention: ReviewRetentionPolicy; displaySchema: JsonValue; resultSchema?: JsonValue; outcomes?: ReadonlyArray<{ id: string; label: string; settlement: 'approved' | 'rejected' | 'changes-requested' | 'answered'; reasonRequired: boolean; publicReason: 'required' | 'optional' | 'none'; resultRequired?: boolean }> }
+export interface ReviewPolicy { id: string; label?: string; version: string; purpose: 'approval' | 'answer'; context: ReviewContextPolicy; routing?: ReadonlyArray<RoutingRule>; stages: ReadonlyArray<ReviewStagePolicy>; clocks?: ReadonlyArray<string>; retention: ReviewRetentionPolicy; displaySchema: JsonValue; resultSchema?: JsonValue; outcomes?: ReadonlyArray<{ id: string; label: string; settlement: 'approved' | 'rejected' | 'changes-requested' | 'answered'; reasonRequired: boolean; publicReason: 'required' | 'optional' | 'none'; resultRequired?: boolean }> }
 export interface ReviewPolicyClosure {
   identity: PolicyBinding
+  label?: string
   purpose: 'approval' | 'answer'
   context: ReviewContextPolicy
   routing?: ReadonlyArray<RoutingRule>

package/casework/client.js

@@ -85,12 +85,50 @@ function sanitize(value, kind) {
   return cloneJson(value, { nodes: 0, bytes: 0, active: new WeakSet() }, 0, kind);
 }
 
+function configurationValue(config) {
+  if (!config || typeof config !== 'object' || Array.isArray(config) || isProxy(config)) {
+    throw normalized({}, 'configuration');
+  }
+  const prototype = Object.getPrototypeOf(config);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw normalized({}, 'configuration');
+  }
+  const allowed = new Set([
+    'baseUrl',
+    'attemptTimeoutMilliseconds',
+    'connectTimeoutMilliseconds',
+    'maximumResponseBytes',
+    'userAgent',
+    'trustedRootCertificates',
+    'maximumMutationRetries',
+  ]);
+  const copy = Object.create(null);
+  for (const key of Reflect.ownKeys(config)) {
+    if (typeof key !== 'string' || !allowed.has(key)) throw normalized({}, 'configuration');
+    const descriptor = Object.getOwnPropertyDescriptor(config, key);
+    if (!descriptor || !descriptor.enumerable || !Object.hasOwn(descriptor, 'value')) {
+      throw normalized({}, 'configuration');
+    }
+    const value = descriptor.value;
+    if (key === 'baseUrl' || key === 'userAgent' || key === 'trustedRootCertificates') {
+      if (typeof value !== 'string') throw normalized({}, 'configuration');
+      copy[key] = value;
+    } else {
+      if (!Number.isSafeInteger(value) || value < 0 || value > 0xffff_ffff) {
+        throw normalized({}, 'configuration');
+      }
+      copy[key] = value;
+    }
+  }
+  return copy;
+}
+
 const NativeCaseworkClient = native.CaseworkClient;
 
 class CaseworkClient {
   constructor(config) {
     try {
-      this.native = new NativeCaseworkClient(sanitize(config, 'configuration'));
+      this.native = new NativeCaseworkClient(configurationValue(config));
     } catch (error) {
       throw normalized(error, 'configuration');
     }

package/casework/index.d.ts

@@ -55,16 +55,16 @@ export declare class CaseworkClient {
 
 export interface CaseworkClientConfig {
   baseUrl: string
-  requestTimeoutMilliseconds?: number
+  attemptTimeoutMilliseconds?: number
   connectTimeoutMilliseconds?: number
-  maxResponseBytes?: number
+  maximumResponseBytes?: 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
+  maximumMutationRetries?: number
 }
 
 export interface CaseworkOutcome {

package/compatibility.json

@@ -0,0 +1,18 @@
+{
+  "schemaVersion": "registry-stack.sdk-compatibility.v1",
+  "sdkPackage": {
+    "name": "registry-stack-client",
+    "version": "0.45.0"
+  },
+  "namespaces": {
+    "discovery": {
+      "testedServerBaseline": "0.45.0",
+      "compatibleServerPatchLine": "0.45.x",
+      "responseCompatibility": {
+        "additiveObjectMembers": "ignored-after-duplicate-key-rejection",
+        "unknownProblemCodes": "http-status-only",
+        "proof": "registry-discovery-client::client::tests::real_client_ignores_additive_response_members_at_every_response_level"
+      }
+    }
+  }
+}

package/coordinator/client.d.ts

@@ -0,0 +1,248 @@
+/** An integer for which `Number.isSafeInteger` is true. */
+export type SafeInteger = number
+/** A lowercase hyphenated UUID, checked before any request is sent. */
+export type RunId = string
+/** An RFC 3339 instant returned by Coordinator. */
+export type Instant = string
+export type JsonScalar = string | number | boolean | null
+export type JsonValue = JsonScalar | ReadonlyArray<JsonValue> | { readonly [key: string]: JsonValue }
+
+export interface CoordinatorClientConfig {
+  baseUrl: string
+  attemptTimeoutMilliseconds?: SafeInteger
+  connectTimeoutMilliseconds?: SafeInteger
+  maximumResponseBytes?: SafeInteger
+  userAgent?: string
+  /** Additional trust roots for the deployment, as PEM text. */
+  trustedRootCertificates?: string
+  /**
+   * How many times an admission 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.
+   */
+  maximumMutationRetries?: SafeInteger
+}
+
+export interface StartRunRequest { workflow: string; workflowRevision: string; input: JsonValue }
+
+/** The active compiled contract under current start authority. */
+export interface WorkflowContract {
+  workflow: string
+  workflowRevision: string
+  input: JsonValue
+  outcomes: { readonly [name: string]: JsonValue }
+}
+
+export interface RunStatus {
+  runId: RunId
+  workflow: string
+  workflowRevision: string
+
+  bindingDigest: string
+  step: string
+  state: string
+  outcome?: string | null
+  output?: JsonValue | null
+  failureCode?: string | null
+  /** Where a refused call input left its operation contract, as an RFC 6901 pointer that names no value. */
+  failurePath?: string | null
+  admittedAt: Instant
+  deadlineAt: Instant
+  nextDueAt?: Instant | null
+  uncertain: boolean
+  restoreReviewRequired: boolean
+  cancelRequested: boolean
+  authoredCancelRequested: boolean
+}
+
+export interface StepStatus {
+  step: string
+  state: string
+  generation: SafeInteger
+  attempt: SafeInteger
+  nextDueAt?: Instant | null
+  leaseExpiresAt?: Instant | null
+  commandPrepared: boolean
+  uncertain: boolean
+  receiptExpired: boolean
+  failureCode?: string | null
+  /** Where a refused call input left its operation contract, as an RFC 6901 pointer that names no value. */
+  failurePath?: string | null
+  /** What a person needs to clear a hold: for `in-force-ambiguous`, the two records in force and the date. */
+  holdDetail?: HoldDetail
+}
+
+/** The records and date behind a held step. */
+export interface HoldDetail {
+  date: string
+  recordIdentifiers: string[]
+}
+
+export type RetryBlockReason =
+  | 'not-recoverable'
+  | 'deadline-reached'
+  | 'receipt-expired'
+  | 'binding-changed'
+  | 'other-binding-live'
+  | 'snapshot-incompatible'
+  | 'cancelled'
+  | 'restore-hold'
+  | 'restore-review-required'
+  | 'payload-erased'
+  | 'evaluation-uncertain'
+
+/** Coordinator-authored operation identifier. */
+export type OperationId = string
+export type OperationEffect = 'read' | 'mutation' | 'evaluation'
+export type OperationKeyRequirement = 'none' | 'required'
+export type OperationRecovery = 'read-again' | 'same-command-and-receipt' | 'same-command' | 'hold-after-dispatch'
+
+/** Pinned public contract metadata. It does not establish current authority. */
+export interface OperationIdentity {
+  id: OperationId
+  version: SafeInteger
+  product: string
+  effect: OperationEffect
+  keyRequirement: OperationKeyRequirement
+  requiresPreparation: boolean
+  recovery: OperationRecovery
+  readReceipt: boolean
+}
+
+export interface RecoveryStatus {
+  retryAllowed: boolean
+  reason?: RetryBlockReason | null
+  operation?: OperationIdentity
+}
+
+export type EffectState = 'accepted' | 'unknown'
+export interface EffectStatus {
+  step: string
+  operation: OperationIdentity
+  operationRevision: string
+  state: EffectState
+}
+/**
+ * The latest answered read of a followed BReg Proposal. It carries no
+ * Proposal input and names no person. `stateSince` is when Coordinator first
+ * saw the current state and turn, not when BReg entered it.
+ */
+export interface LastObservation {
+  state: string
+  turn?: string
+  submissionVersion: SafeInteger
+  handoffRefusal?: string
+  observedAt: Instant
+  stateSince: Instant
+}
+export interface WaitStatus {
+  step: string
+  acceptedStep: string
+  completion: string
+  completionRevision: string
+  timeoutAt: Instant
+  nextObservationAt: Instant | null
+  notBefore: Instant
+  minimumIntervalSeconds: SafeInteger
+  observations: SafeInteger
+  observationLimit: SafeInteger
+  /** What the latest answered read of a followed BReg Proposal showed. */
+  lastObservation?: LastObservation
+  /** The operator's "Open the request" link, when the deployment configures one. */
+  requestLink?: string
+}
+
+export interface RunInspection {
+  run: RunStatus
+  steps: ReadonlyArray<StepStatus>
+  effects: ReadonlyArray<EffectStatus>
+  waits: ReadonlyArray<WaitStatus>
+  recovery: RecoveryStatus
+}
+
+export type RunListState =
+  | 'running'
+  | 'finished'
+  | 'failed'
+  | 'cancelled'
+  | 'cancelled-after-effect'
+  | 'expired'
+  | 'attention'
+  | 'cancel-requested'
+
+/** Whose turn a followed BReg Proposal showed at its last answered read. */
+export type ProposalTurn = 'party' | 'official' | 'nobody'
+
+/** One stable page of runs the caller may read, newest admission first. */
+export interface RunList { runs: ReadonlyArray<RunStatus>; nextCursor?: string }
+
+/** The runtime accepted a same-command retry; the worker has not run it yet. */
+export interface RetryScheduled { runId: RunId; status: 'retry-scheduled' }
+
+export interface CoordinatorOutcome<T> { kind: 'complete'; value: T }
+export type CoordinatorProtocolFailure = 'header-bounds' | 'media-type' | 'body' | 'problem' | 'status' | 'protocol'
+
+export class CoordinatorClientError extends Error {
+  readonly kind: 'configuration' | 'invalid-request' | 'transport' | 'problem' | 'protocol'
+  /**
+   * Whether the call may have taken effect although this error was raised:
+   * a timeout or broken exchange after sending, an unusable answer, or a
+   * 5xx. When true for `start`, recover by sending the same workflow, revision, and input
+   * again under the same idempotency key; a new key could admit a second
+   * run. When true for `retrySame` or `cancel`, which take no key and are
+   * never resent, read the run before asking again. False for a
+   * configuration or request defect, a connection never established, and
+   * every 4xx refusal.
+   */
+  readonly outcomeUnknown: boolean
+  /**
+   * The `family.reason` code of the RFC 9457 problem document the service
+   * answered, such as `run.not-visible`, present only when `kind` is
+   * `'problem'`. The service's title and detail are never copied.
+   */
+  readonly code?: string
+  readonly status?: SafeInteger
+  readonly transportKind?: string
+  readonly protocolFailure?: CoordinatorProtocolFailure
+}
+
+export class CoordinatorClient {
+  constructor(config: CoordinatorClientConfig)
+  /**
+   * Admit `{workflow, workflowRevision, input}` under the caller's key. Fresh
+   * starts must match the active revision. Recover unknown admissions with the
+   * original revision even after activation changes. An unknown outcome is resent with
+   * the same key and body at most `maximumMutationRetries` times; a 4xx is never
+   * resent. The key is scoped to the caller and the workflow, so the same key
+   * under two workflows starts two runs, and an allowed workflow the deployment does
+   * not serve is refused with 404 `workflow.not-served`, a known outcome never resent.
+   */
+  start(token: string, idempotencyKey: string, request: StartRunRequest): Promise<CoordinatorOutcome<RunStatus>>
+  /** Discover the active typed contract under current start authority; starts no run. */
+  workflow(token: string, workflow: string): Promise<CoordinatorOutcome<WorkflowContract>>
+  status(token: string, runId: RunId): Promise<CoordinatorOutcome<RunStatus>>
+  inspect(token: string, runId: RunId): Promise<CoordinatorOutcome<RunInspection>>
+  /** Read the original operation's receipt and update recovery state. Never resubmits the operation. */
+  reconcile(token: string, runId: RunId, reason: string): Promise<CoordinatorOutcome<RunInspection>>
+  /**
+   * Read one stable page of caller-visible runs. Pass `nextCursor` unchanged
+   * with the same caller, `state`, `attention`, `proposal`, and `turn`
+   * values. `attention: true` selects the effective states `attention` and
+   * `failed`. `proposal` selects runs waiting on that BReg Proposal; `turn`
+   * selects runs whose Proposal wait last showed that turn.
+   */
+  list(token: string, limit: SafeInteger, cursor?: string | null, state?: RunListState | null, attention?: boolean | null, proposal?: string | null, turn?: ProposalTurn | null): Promise<CoordinatorOutcome<RunList>>
+  /**
+   * Schedule the run's saved command again, unchanged, when its inspection
+   * allows a retry. Takes no idempotency key, so it is sent exactly once. `reason` is
+   * 1 to 256 bytes without control characters, checked before sending.
+   */
+  retrySame(token: string, runId: RunId, reason: string): Promise<CoordinatorOutcome<RetryScheduled>>
+  /**
+   * Stop further progression. Never undoes a product effect. Takes no
+   * idempotency key, so it is sent exactly once. `reason` is 1 to 256 bytes
+   * without control characters, checked before sending.
+   */
+  cancel(token: string, runId: RunId, reason: string): Promise<CoordinatorOutcome<RunStatus>>
+}