@registrystack/client 0.42.0 → 0.44.0

package/coordinator/client.d.ts

@@ -0,0 +1,218 @@
+/** 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
+}
+
+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
+}
+export interface WaitStatus {
+  step: string
+  acceptedStep: string
+  completion: string
+  completionRevision: string
+  timeoutAt: Instant
+  nextObservationAt: Instant | null
+  notBefore: Instant
+  minimumIntervalSeconds: SafeInteger
+  observations: SafeInteger
+  observationLimit: SafeInteger
+}
+
+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'
+
+/** 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`, and `attention` values. `attention: true`
+   * selects the effective states `attention` and `failed`.
+   */
+  list(token: string, limit: SafeInteger, cursor?: string | null, state?: RunListState | null, attention?: boolean | 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>>
+}

package/coordinator/client.js

@@ -0,0 +1,140 @@
+'use strict';
+
+const { types: { isProxy } } = require('node:util');
+const native = require('./index');
+
+const MAX_JSON_DEPTH = 64;
+const MAX_JSON_NODES = 20_000;
+const MAX_JSON_STRING_BYTES = 1024 * 1024;
+
+class CoordinatorClientError extends Error {
+  constructor(envelope) {
+    super(envelope.message);
+    this.name = 'CoordinatorClientError';
+    this.kind = envelope.kind;
+    this.outcomeUnknown = envelope.outcomeUnknown === true;
+    for (const field of ['code', 'status', 'transportKind', 'protocolFailure']) {
+      if (envelope[field] !== undefined && envelope[field] !== null) this[field] = envelope[field];
+    }
+  }
+}
+
+const FALLBACK_MESSAGES = {
+  configuration: 'Coordinator client configuration is invalid',
+  'invalid-request': 'Coordinator client arguments are invalid',
+  protocol: 'Registry Coordinator client failed',
+};
+
+function normalized(error, fallbackKind) {
+  if (error instanceof CoordinatorClientError) return error;
+  if (error instanceof Error && typeof error.message === 'string') {
+    try {
+      const envelope = JSON.parse(error.message);
+      if (envelope && typeof envelope.kind === 'string') return new CoordinatorClientError(envelope);
+    } catch {
+      // napi argument conversion errors have no mapped envelope.
+    }
+  }
+  if (fallbackKind) {
+    return new CoordinatorClientError({
+      kind: fallbackKind,
+      message: FALLBACK_MESSAGES[fallbackKind],
+      outcomeUnknown: fallbackKind === 'protocol',
+    });
+  }
+  return error;
+}
+
+function cloneJson(value, budget, depth, kind) {
+  if (depth > MAX_JSON_DEPTH || ++budget.nodes > MAX_JSON_NODES) throw normalized({}, kind);
+  if (value === null || typeof value === 'boolean') return value;
+  if (typeof value === 'string') {
+    budget.bytes += Buffer.byteLength(value, 'utf8');
+    if (budget.bytes > MAX_JSON_STRING_BYTES) throw normalized({}, kind);
+    return value;
+  }
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
+      throw normalized({}, kind);
+    }
+    return value;
+  }
+  if (value === undefined || typeof value !== 'object' || isProxy(value)) throw normalized({}, kind);
+  const array = Array.isArray(value);
+  const prototype = Object.getPrototypeOf(value);
+  if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) {
+    throw normalized({}, kind);
+  }
+  if (budget.active.has(value)) throw normalized({}, kind);
+  budget.active.add(value);
+  try {
+    if (array) {
+      if (value.length > MAX_JSON_NODES - budget.nodes) throw normalized({}, kind);
+      const keys = Reflect.ownKeys(value);
+      if (keys.length !== value.length + 1) throw normalized({}, kind);
+      const result = new Array(value.length);
+      for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor || !Object.hasOwn(descriptor, 'value')) throw normalized({}, kind);
+        result[index] = cloneJson(descriptor.value, budget, depth + 1, kind);
+      }
+      return result;
+    }
+    const result = Object.create(null);
+    for (const key of Reflect.ownKeys(value)) {
+      if (typeof key !== 'string') throw normalized({}, kind);
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !Object.hasOwn(descriptor, 'value')) throw normalized({}, kind);
+      if (descriptor.enumerable) {
+        budget.bytes += Buffer.byteLength(key, 'utf8');
+        if (budget.bytes > MAX_JSON_STRING_BYTES) throw normalized({}, kind);
+        result[key] = cloneJson(descriptor.value, budget, depth + 1, kind);
+      }
+    }
+    return result;
+  } finally {
+    budget.active.delete(value);
+  }
+}
+
+function sanitize(value, kind) {
+  return cloneJson(value, { nodes: 0, bytes: 0, active: new WeakSet() }, 0, kind);
+}
+
+const NativeCoordinatorClient = native.CoordinatorClient;
+
+class CoordinatorClient {
+  constructor(config) {
+    try {
+      this.native = new NativeCoordinatorClient(sanitize(config, 'configuration'));
+    } catch (error) {
+      throw normalized(error, 'configuration');
+    }
+  }
+}
+
+for (const [method, jsonIndexes] of [
+  ['start', [2]],
+  ['workflow', []],
+  ['status', []],
+  ['inspect', []],
+  ['reconcile', []],
+  ['list', []],
+  ['retrySame', []],
+  ['cancel', []],
+]) {
+  CoordinatorClient.prototype[method] = function (...args) {
+    try {
+      for (const index of jsonIndexes) {
+        if (args[index] !== undefined && args[index] !== null) {
+          args[index] = sanitize(args[index], 'invalid-request');
+        }
+      }
+      return this.native[method](...args).catch((error) => { throw normalized(error, 'protocol'); });
+    } catch (error) {
+      throw normalized(error, 'invalid-request');
+    }
+  };
+}
+
+module.exports = { CoordinatorClient, CoordinatorClientError };

package/coordinator/index.d.ts

@@ -0,0 +1,19 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+
+export declare class CoordinatorClient {
+  constructor(config: import('./client').CoordinatorClientConfig)
+  start(token: string, idempotencyKey: string, request: import('./client').StartRunRequest): Promise<import('./client').CoordinatorOutcome<import('./client').RunStatus>>
+  workflow(token: string, workflow: string): Promise<import('./client').CoordinatorOutcome<import('./client').WorkflowContract>>
+  status(token: string, runId: import('./client').RunId): Promise<import('./client').CoordinatorOutcome<import('./client').RunStatus>>
+  inspect(token: string, runId: import('./client').RunId): Promise<import('./client').CoordinatorOutcome<import('./client').RunInspection>>
+  reconcile(token: string, runId: import('./client').RunId, reason: string): Promise<import('./client').CoordinatorOutcome<import('./client').RunInspection>>
+  list(token: string, limit: number, cursor?: string | null, state?: import('./client').RunListState | null, attention?: boolean | null): Promise<import('./client').CoordinatorOutcome<import('./client').RunList>>
+  retrySame(token: string, runId: import('./client').RunId, reason: string): Promise<import('./client').CoordinatorOutcome<import('./client').RetryScheduled>>
+  cancel(token: string, runId: import('./client').RunId, reason: string): Promise<import('./client').CoordinatorOutcome<import('./client').RunStatus>>
+}
+
+export interface CoordinatorOutcome {
+  kind: 'complete'
+  value: unknown
+}

package/coordinator/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../native').load('coordinator');

package/discovery/client.d.ts

@@ -2,10 +2,10 @@ export type ServiceKind = 'evidence';
 
 export interface DiscoveryClientOptions {
   baseUrl: string;
-  requestTimeoutMilliseconds?: number;
+  attemptTimeoutMilliseconds?: number;
   connectTimeoutMilliseconds?: number;
   maximumResponseBytes?: number;
-  trustedRootCertificates?: Buffer;
+  trustedRootCertificates?: string;
 }
 
 export interface EvidenceTypeResolveRequest {

package/discovery/client.js

@@ -158,7 +158,7 @@ function configurationValue(options) {
   }
   const allowed = new Set([
     'baseUrl',
-    'requestTimeoutMilliseconds',
+    'attemptTimeoutMilliseconds',
     'connectTimeoutMilliseconds',
     'maximumResponseBytes',
     'trustedRootCertificates',
@@ -172,10 +172,10 @@ function configurationValue(options) {
     }
     const value = descriptor.value;
     if (key === 'trustedRootCertificates') {
-      if (!Buffer.isBuffer(value) || value.length > 4 * 1024 * 1024) {
+      if (typeof value !== 'string' || Buffer.byteLength(value, 'utf8') > 4 * 1024 * 1024) {
         throw inputError('configuration');
       }
-      copy[key] = Buffer.from(value);
+      copy[key] = value;
     } else if (key === 'baseUrl') {
       if (typeof value !== 'string') throw inputError('configuration');
       copy[key] = value;

package/discovery/index.d.ts

@@ -13,10 +13,10 @@ export declare class DiscoveryClient {
 
 export interface DiscoveryClientOptions {
   baseUrl: string
-  requestTimeoutMilliseconds?: number
+  attemptTimeoutMilliseconds?: number
   connectTimeoutMilliseconds?: number
   maximumResponseBytes?: number
-  trustedRootCertificates?: Buffer
+  trustedRootCertificates?: string
 }
 
 export declare function renewUnchangedSelection(previous: any, current: any): any

package/evidence/client.d.ts

@@ -120,8 +120,8 @@ export interface PrivateKeyJwtConfig {
   scopes?: ReadonlyArray<string>
   assertionLifetimeSeconds?: number
   refreshMarginSeconds?: number
-  requestTimeoutMs?: number
-  connectTimeoutMs?: number
+  attemptTimeoutMilliseconds?: number
+  connectTimeoutMilliseconds?: number
   userAgent?: string
   /** Additional trust roots for the token endpoint, as a PEM bundle. */
   trustedRootCertificates?: string
@@ -151,11 +151,8 @@ export interface EvidenceExchangeContext {
  * This is not a `PrivateKeyJwtConfig`, even though the two describe the same
  * kind of client: an exchange is pinned to one resource and scope set, so both
  * are required here, and the object is read by the shared exchange
- * configuration parser rather than by the binding's own reader, so its timeout
- * members are the full-word ones that parser accepts. State at most one of
- * `requestTimeoutMilliseconds` and `requestTimeoutSeconds`, and at most one of
- * `connectTimeoutMilliseconds` and `connectTimeoutSeconds`; naming both of a
- * pair is refused.
+ * configuration parser rather than by the binding's own reader. Node exposes
+ * both timeout controls in milliseconds.
  */
 export interface EvidenceExchangeClientConfig {
   tokenEndpoint: string
@@ -180,10 +177,8 @@ export interface EvidenceExchangeClientConfig {
   scopes: ReadonlyArray<string>
   assertionLifetimeSeconds?: number
   refreshMarginSeconds?: number
-  requestTimeoutMilliseconds?: number
-  requestTimeoutSeconds?: number
+  attemptTimeoutMilliseconds?: number
   connectTimeoutMilliseconds?: number
-  connectTimeoutSeconds?: number
   userAgent?: string
   /** Additional trust roots for the token endpoint, as a PEM bundle. */
   trustedRootCertificates?: string
@@ -195,10 +190,8 @@ export interface EvidenceExchangeRemoteSourceConfig {
   bootstrap: EvidenceExchangeClientConfig
   bootstrapResource: string
   bootstrapScope: string
-  requestTimeoutMilliseconds?: number
-  requestTimeoutSeconds?: number
+  attemptTimeoutMilliseconds?: number
   connectTimeoutMilliseconds?: number
-  connectTimeoutSeconds?: number
   userAgent?: string
   /** Additional trust roots for the authority, as a PEM bundle. */
   trustedRootCertificates?: string
@@ -220,12 +213,12 @@ export interface EvidenceClientConfig {
   /** Configure exactly one of `token` or `authorization`. */
   token?: EvidenceTokenConfig
   authorization?: { exchange: EvidenceExchangeAuthorizationConfig }
-  requestTimeoutMs?: number
-  connectTimeoutMs?: number
+  attemptTimeoutMilliseconds?: number
+  connectTimeoutMilliseconds?: number
   userAgent?: string
   /** Additional trust roots for the deployment, as a PEM bundle. */
   trustedRootCertificates?: string
-  maxResponseBytes?: number
+  maximumResponseBytes?: number
   maxMetadataBytes?: number
 }
 

package/evidence/index.d.ts

@@ -26,7 +26,7 @@ export declare class EvidenceClient {
    * mandatory trust inputs. A key set or revoked-key list the verifier could
    * never use is refused, exactly as the Rust configuration refuses it.
    *
-   * `maxResponseBytes` bounds the signed response `send` reads.
+   * `maximumResponseBytes` bounds the signed response `send` reads.
    * `maxMetadataBytes` bounds the documents `discover` and `fetchJwks` read,
    * which are neither signed nor verified, and is a separate decision.
    */

package/index.d.ts

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

package/index.js

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

package/messaging/client.d.ts

@@ -9,18 +9,19 @@ export type JsonValue = JsonScalar | ReadonlyArray<JsonValue> | { readonly [key:
 
 export interface MessagingClientConfig {
   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
+  /** Additional trust roots for the deployment, as PEM text. */
+  trustedRootCertificates?: string
   /**
    * How many times a submission whose outcome is unknown is resent,
    * identically and under the same idempotency key, before its error is
    * returned: a whole number from 0 to 2, default 2; 0 sends it once. Any
    * other value is a `configuration` error.
    */
-  maxMutationRetries?: SafeInteger | null
+  maximumMutationRetries?: SafeInteger
 }
 
 export type Channel = 'email' | 'sms'

package/native.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const PACKAGE_VERSION = '0.42.0';
-const PRODUCTS = new Set(['discovery', 'evidence', 'breg', 'casework', 'messaging', 'scheduling']);
+const PACKAGE_VERSION = '0.44.0';
+const PRODUCTS = new Set(["breg", "casework", "coordinator", "discovery", "evidence", "messaging", "scheduling"]);
 
 function target() {
   if (process.platform === 'darwin' && process.arch === 'arm64') return 'darwin-arm64';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@registrystack/client",
-  "version": "0.42.0",
+  "version": "0.44.0",
   "description": "Unified Node.js client for Registry Stack products.",
   "license": "Apache-2.0",
   "homepage": "https://docs.registrystack.org/reference/client-api/",
@@ -15,7 +15,9 @@
     "breg",
     "casework",
     "messaging",
-    "scheduling"
+    "scheduling",
+    "render",
+    "coordinator"
   ],
   "publishConfig": {
     "access": "public",
@@ -32,18 +34,25 @@
     ".": {
       "types": "./index.d.ts",
       "default": "./index.js"
+    },
+    "./compatibility.json": "./compatibility.json",
+    "./coordinator": {
+      "types": "./coordinator/client.d.ts",
+      "default": "./coordinator/client.js"
     }
   },
   "files": [
     "index.js",
     "index.d.ts",
     "native.js",
+    "compatibility.json",
     "discovery",
     "evidence",
     "breg",
     "casework",
     "messaging",
-    "scheduling"
+    "scheduling",
+    "coordinator"
   ],
   "engines": {
     "node": ">=24.11.0"
@@ -59,8 +68,8 @@
     "typescript": "6.0.3"
   },
   "optionalDependencies": {
-    "@registrystack/client-darwin-arm64": "0.42.0",
-    "@registrystack/client-linux-arm64-gnu": "0.42.0",
-    "@registrystack/client-linux-x64-gnu": "0.42.0"
+    "@registrystack/client-darwin-arm64": "0.44.0",
+    "@registrystack/client-linux-arm64-gnu": "0.44.0",
+    "@registrystack/client-linux-x64-gnu": "0.44.0"
   }
 }