@continuonai/rcan-ts 0.2.0 → 0.3.0

package/README.md

@@ -9,6 +9,8 @@ Official TypeScript SDK for the **RCAN v1.2** Robot Communication and Accountabi
 npm install @continuonai/rcan-ts
 ```
 
+> **v0.2.0** — RCAN v1.2 spec compliance including §17 Distributed Registry Node Protocol
+
 ### CDN / Browser (no build step)
 
 ```html
@@ -139,6 +141,89 @@ result.warnings.forEach((w) => console.warn("⚠️", w));
 | `validateURI` | Validate a Robot URI string |
 | `validateMessage` | Validate a RCAN message object |
 | `validateConfig` | L1/L2/L3 conformance check for a robot RCAN config |
+| `NodeClient` | Resolve RRNs from federated registry nodes (§17) |
+| `fetchCanonicalSchema` | Fetch the canonical JSON schema from rcan.dev |
+| `validateConfigAgainstSchema` | Validate a config object against the live JSON schema |
+| `validateNodeAgainstSchema` | Validate a node manifest against the node schema |
+
+---
+
+## Distributed Registry Nodes (§17)
+
+RCAN v1.2 §17 introduces a federated registry network. `NodeClient` resolves RRNs from any node — root or delegated authoritative.
+
+```typescript
+import { NodeClient } from '@continuonai/rcan-ts';
+
+const client = new NodeClient();
+
+// Resolve an RRN across the federation
+const result = await client.resolve('RRN-BD-000000000001');
+console.log(`Resolved by: ${result.resolved_by}`);
+console.log(`Robot: ${result.record.name}`);
+
+// Discover the authoritative node for a namespace
+const node = await client.discover('RRN-BD-000000000001');
+console.log(`Authoritative: ${node.operator} at ${node.api_base}`);
+
+// List all known registry nodes
+const nodes = await client.listNodes();
+nodes.forEach(n => console.log(`${n.operator}: ${n.namespace_prefix}`));
+
+// Verify a node manifest
+const manifest = await client.getNodeManifest('https://registry.example.com');
+const isValid = client.verifyNode(manifest);
+
+// Error handling
+import { RCANNodeNotFoundError, RCANNodeTrustError } from '@continuonai/rcan-ts';
+try {
+  const result = await client.resolve('RRN-UNKNOWN-000000000001');
+} catch (e) {
+  if (e instanceof RCANNodeNotFoundError) {
+    console.log(`Not found: ${e.rrn}`);
+  } else if (e instanceof RCANNodeTrustError) {
+    console.log(`Trust failure: ${e.reason}`);
+  }
+}
+```
+
+### RRN Format
+
+```
+Root namespace:    RRN-000000000001    (12-digit recommended, 8-digit still valid)
+Delegated:        RRN-BD-000000000001  (prefix 2-8 alphanumeric chars)
+Legacy (valid):   RRN-00000001         (8-digit, backward compatible)
+```
+
+## Schema Validation
+
+Validate configs against the canonical JSON schema published at rcan.dev:
+
+```typescript
+import { validateConfigAgainstSchema, validateNodeAgainstSchema } from '@continuonai/rcan-ts';
+
+// Validate a RCAN config against the canonical schema from rcan.dev
+const result = await validateConfigAgainstSchema(myConfig);
+if (!result.valid) {
+  console.error('Config invalid:', result.errors);
+} else if (result.skipped) {
+  console.warn('Schema validation skipped (rcan.dev unreachable)');
+}
+
+// Validate a node manifest
+const nodeResult = await validateNodeAgainstSchema(manifest);
+```
+
+### CDN / Browser Usage
+
+```html
+<script src="https://unpkg.com/@continuonai/rcan-ts/dist/rcan.iife.js"></script>
+<script>
+  const { validateConfig, NodeClient } = window.RCAN;
+  const client = new NodeClient();
+  client.resolve('RRN-000000000001').then(r => console.log(r));
+</script>
+```
 
 ---
 

package/bin/rcan-validate.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { NodeClient, validateConfig, VERSION, SPEC_VERSION } from '../dist/index.js';
+import { readFileSync } from 'fs';
+import { parseArgs } from 'util';
+
+const { values, positionals } = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    version: { type: 'boolean', short: 'v' },
+    file: { type: 'string', short: 'f' },
+  },
+  allowPositionals: true,
+});
+
+if (values.version) {
+  console.log(`rcan-validate (ts) ${VERSION} (RCAN spec ${SPEC_VERSION})`);
+  process.exit(0);
+}
+
+const [subcommand, target] = positionals;
+
+if (subcommand === 'node') {
+  if (!target) {
+    console.error('Usage: rcan-validate node <url>');
+    process.exit(1);
+  }
+
+  const client = new NodeClient();
+  console.log(`Validating node manifest: ${target}`);
+
+  try {
+    const manifest = await client.getNodeManifest(target);
+    const valid = client.verifyNode(manifest);
+
+    const checks = [
+      ['node_type', manifest.node_type, ['root','authoritative','resolver','cache'].includes(manifest.node_type)],
+      ['operator', manifest.operator, !!manifest.operator],
+      ['namespace_prefix', manifest.namespace_prefix, !!manifest.namespace_prefix],
+      ['public_key', manifest.public_key?.substring(0, 20) + '...', manifest.public_key?.startsWith('ed25519:')],
+      ['api_base', manifest.api_base, manifest.api_base?.startsWith('https://')],
+    ];
+
+    for (const [name, value, pass] of checks) {
+      console.log(`  ${pass ? '✓' : '✗'} ${name}: ${value}`);
+    }
+
+    const passed = checks.filter(([,,p]) => p).length;
+    console.log(`\n${valid ? 'PASS' : 'FAIL'} (${passed}/${checks.length} checks)`);
+    process.exit(valid ? 0 : 1);
+  } catch (e) {
+    console.error(`❌ Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+if (subcommand === 'config') {
+  const filePath = target || values.file;
+  if (!filePath) {
+    console.error('Usage: rcan-validate config <file>');
+    process.exit(1);
+  }
+
+  try {
+    const raw = readFileSync(filePath, 'utf-8');
+    const config = JSON.parse(raw);
+    const result = validateConfig(config);
+    if (result.ok) {
+      console.log('✓ Config valid');
+      if (result.warnings?.length) {
+        result.warnings.forEach(w => console.warn(`  ⚠️  ${w}`));
+      }
+      process.exit(0);
+    } else {
+      console.error('✗ Config invalid:');
+      result.issues?.forEach(i => console.error(`  ❌ ${i}`));
+      process.exit(1);
+    }
+  } catch (e) {
+    console.error(`❌ Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+
+console.error(`Unknown subcommand: ${subcommand}`);
+console.error('Usage: rcan-validate node <url> | rcan-validate config <file> | rcan-validate --version');
+process.exit(1);

package/dist/browser.d.mts

@@ -256,6 +256,31 @@ interface RCANMessageEnvelope {
     signature?: string;
     [key: string]: unknown;
 }
+interface RCANRegistryNode {
+    rcan_node_version: string;
+    node_type: "root" | "authoritative" | "resolver" | "cache";
+    operator: string;
+    namespace_prefix: string;
+    public_key: string;
+    api_base: string;
+    registry_ui?: string;
+    spec_version?: string;
+    capabilities?: string[];
+    sync_endpoint?: string;
+    last_sync?: string;
+    ttl_seconds?: number;
+    contact?: string;
+    governance?: string;
+    federation_protocol?: string;
+}
+interface RCANResolveResult {
+    rrn: string;
+    resolved_by: string;
+    namespace: string;
+    record: Record<string, unknown>;
+    cache_status: "HIT" | "MISS" | "STALE";
+    resolved_at: string;
+}
 
 /**
  * RCAN Validation — validate messages, configs, and URIs.
@@ -298,6 +323,22 @@ declare class RCANSignatureError extends RCANError {
 declare class RCANRegistryError extends RCANError {
     constructor(message: string);
 }
+declare class RCANNodeError extends RCANError {
+    readonly nodeUrl?: string | undefined;
+    constructor(message: string, nodeUrl?: string | undefined);
+}
+declare class RCANNodeNotFoundError extends RCANNodeError {
+    readonly rrn: string;
+    constructor(rrn: string, nodeUrl?: string);
+}
+declare class RCANNodeSyncError extends RCANNodeError {
+    readonly cause?: Error | undefined;
+    constructor(message: string, nodeUrl?: string, cause?: Error | undefined);
+}
+declare class RCANNodeTrustError extends RCANNodeError {
+    readonly reason: "invalid_signature" | "expired_cert" | "unknown_issuer" | "missing_pubkey";
+    constructor(reason: RCANNodeTrustError["reason"], nodeUrl?: string);
+}
 
 /**
  * rcan-ts — RegistryClient
@@ -367,6 +408,68 @@ declare class RegistryClient {
     }): Promise<Robot[]>;
 }
 
+/**
+ * rcan-ts — NodeClient
+ * Federation-aware node discovery and RRN resolution.
+ *
+ * Zero runtime dependencies — uses globalThis.fetch (Node 18+, browsers, CF Workers).
+ *
+ * @see https://rcan.dev/spec#section-federation
+ */
+
+declare class NodeClient {
+    private readonly rootUrl;
+    private readonly timeoutMs;
+    constructor(rootUrl?: string, timeoutMs?: number);
+    private _fetch;
+    /**
+     * Fetch /.well-known/rcan-node.json from any node URL.
+     * Throws RCANNodeTrustError if the manifest is malformed.
+     * Throws RCANNodeSyncError on network failure.
+     */
+    getNodeManifest(nodeUrl: string): Promise<RCANRegistryNode>;
+    /**
+     * Get list of known registry nodes from root /api/v1/nodes.
+     * Optionally filter by namespace prefix (e.g. "BD").
+     */
+    listNodes(prefix?: string): Promise<RCANRegistryNode[]>;
+    /**
+     * Find the authoritative node for an RRN.
+     * - Delegated RRN (RRN-BD-00000001): GET /api/v1/nodes?prefix=BD, return first match.
+     * - Root RRN (RRN-00000042): return root node manifest.
+     * - Unknown format: throws RCANNodeNotFoundError.
+     */
+    discover(rrn: string): Promise<RCANRegistryNode>;
+    /**
+     * Resolve an RRN across the federation.
+     * First tries {rootUrl}/api/v1/resolve/{rrn}.
+     * On 404, discovers the authoritative node and tries {node.api_base}/robots/{rrn}.
+     */
+    resolve(rrn: string): Promise<RCANResolveResult>;
+    /**
+     * Verify a node manifest is well-formed.
+     * Checks required fields, ed25519: public_key prefix, valid node_type, https:// api_base.
+     */
+    verifyNode(manifest: unknown): manifest is RCANRegistryNode;
+}
+
+declare function fetchCanonicalSchema(schemaName: string): Promise<object | null>;
+/**
+ * Validate a config object against the canonical rcan-config schema from rcan.dev.
+ * Returns { valid: true } or { valid: false, errors: string[] }.
+ * Gracefully returns { valid: true, skipped: true } if schema unreachable.
+ */
+declare function validateConfigAgainstSchema(config: unknown): Promise<{
+    valid: boolean;
+    errors?: string[];
+    skipped?: boolean;
+}>;
+declare function validateNodeAgainstSchema(manifest: unknown): Promise<{
+    valid: boolean;
+    errors?: string[];
+    skipped?: boolean;
+}>;
+
 /**
  * rcan-ts — Official TypeScript SDK for RCAN v1.2
  * Robot Communication and Accountability Network
@@ -375,7 +478,9 @@ declare class RegistryClient {
  * @see https://github.com/continuonai/rcan-ts
  */
 
-declare const VERSION = "0.1.0";
+declare const VERSION = "0.3.0";
+declare const SPEC_VERSION = "1.2";
+/** @deprecated Use SPEC_VERSION instead */
 declare const RCAN_VERSION = "1.2";
 
-export { type ApprovalStatus, AuditChain, AuditError, type ChainVerifyResult, CommitmentRecord, type CommitmentRecordData, type CommitmentRecordJSON, ConfidenceGate, GateError, HiTLGate, type ListResult, type PendingApproval, RCANAddressError, type RCANAgentConfig, type RCANConfig, RCANError, RCANGateError, RCANMessage, type RCANMessageData, type RCANMessageEnvelope, RCANMessageError, type RCANMetadata, RCANRegistryError, RCANSignatureError, RCANValidationError, RCAN_VERSION, type RegistrationResult, RegistryClient, type Robot, type RobotRegistration, RobotURI, RobotURIError, type RobotURIOptions, type SignatureBlock, VERSION, type ValidationResult, validateConfig, validateMessage, validateURI };
+export { type ApprovalStatus, AuditChain, AuditError, type ChainVerifyResult, CommitmentRecord, type CommitmentRecordData, type CommitmentRecordJSON, ConfidenceGate, GateError, HiTLGate, type ListResult, NodeClient, type PendingApproval, RCANAddressError, type RCANAgentConfig, type RCANConfig, RCANError, RCANGateError, RCANMessage, type RCANMessageData, type RCANMessageEnvelope, RCANMessageError, type RCANMetadata, RCANNodeError, RCANNodeNotFoundError, RCANNodeSyncError, RCANNodeTrustError, RCANRegistryError, type RCANRegistryNode, type RCANResolveResult, RCANSignatureError, RCANValidationError, RCAN_VERSION, type RegistrationResult, RegistryClient, type Robot, type RobotRegistration, RobotURI, RobotURIError, type RobotURIOptions, SPEC_VERSION, type SignatureBlock, VERSION, type ValidationResult, fetchCanonicalSchema, validateConfig, validateConfigAgainstSchema, validateMessage, validateNodeAgainstSchema, validateURI };

package/dist/browser.mjs

@@ -747,6 +747,39 @@ var RCANRegistryError = class extends RCANError {
     Object.setPrototypeOf(this, new.target.prototype);
   }
 };
+var RCANNodeError = class _RCANNodeError extends RCANError {
+  constructor(message, nodeUrl) {
+    super(message);
+    this.nodeUrl = nodeUrl;
+    this.name = "RCANNodeError";
+    Object.setPrototypeOf(this, _RCANNodeError.prototype);
+  }
+};
+var RCANNodeNotFoundError = class _RCANNodeNotFoundError extends RCANNodeError {
+  constructor(rrn, nodeUrl) {
+    super(`RRN not found in federation: ${rrn}`, nodeUrl);
+    this.rrn = rrn;
+    this.name = "RCANNodeNotFoundError";
+    Object.setPrototypeOf(this, _RCANNodeNotFoundError.prototype);
+  }
+};
+var RCANNodeSyncError = class _RCANNodeSyncError extends RCANNodeError {
+  constructor(message, nodeUrl, cause) {
+    super(message, nodeUrl);
+    this.cause = cause;
+    this.name = "RCANNodeSyncError";
+    Object.setPrototypeOf(this, _RCANNodeSyncError.prototype);
+  }
+};
+var RCANNodeTrustError = class _RCANNodeTrustError extends RCANNodeError {
+  constructor(reason, nodeUrl) {
+    super(`Node trust verification failed: ${reason}`, nodeUrl);
+    __publicField(this, "reason");
+    this.name = "RCANNodeTrustError";
+    this.reason = reason;
+    Object.setPrototypeOf(this, _RCANNodeTrustError.prototype);
+  }
+};
 
 // src/registry.ts
 var DEFAULT_BASE_URL = "https://rcan-spec.pages.dev";
@@ -871,8 +904,250 @@ var RegistryClient = class {
   }
 };
 
+// src/node.ts
+var ROOT_NODE_URL = "https://rcan.dev";
+var NODE_MANIFEST_PATH = "/.well-known/rcan-node.json";
+var VALID_NODE_TYPES = /* @__PURE__ */ new Set([
+  "root",
+  "authoritative",
+  "resolver",
+  "cache"
+]);
+function parseRRNNamespace(rrn) {
+  const delegated = rrn.match(/^RRN-([A-Z0-9]{2,8})-(\d{8,16})$/);
+  if (delegated) return { type: "delegated", prefix: delegated[1], serial: delegated[2] };
+  const root = rrn.match(/^RRN-(\d{8,16})$/);
+  if (root) return { type: "root", serial: root[1] };
+  return null;
+}
+var NodeClient = class {
+  constructor(rootUrl = ROOT_NODE_URL, timeoutMs = 1e4) {
+    __publicField(this, "rootUrl");
+    __publicField(this, "timeoutMs");
+    this.rootUrl = rootUrl.replace(/\/$/, "");
+    this.timeoutMs = timeoutMs;
+  }
+  // ── Private helpers ─────────────────────────────────────────────────────────
+  async _fetch(url) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      return await globalThis.fetch(url, { signal: controller.signal });
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new RCANNodeSyncError(`Request timed out: ${url}`, url, err);
+      }
+      throw new RCANNodeSyncError(
+        `Network error fetching ${url}: ${err.message}`,
+        url,
+        err instanceof Error ? err : void 0
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ── Public API ───────────────────────────────────────────────────────────────
+  /**
+   * Fetch /.well-known/rcan-node.json from any node URL.
+   * Throws RCANNodeTrustError if the manifest is malformed.
+   * Throws RCANNodeSyncError on network failure.
+   */
+  async getNodeManifest(nodeUrl) {
+    const url = `${nodeUrl.replace(/\/$/, "")}${NODE_MANIFEST_PATH}`;
+    const resp = await this._fetch(url);
+    if (!resp.ok) {
+      if (resp.status === 404) {
+        throw new RCANNodeNotFoundError(url, nodeUrl);
+      }
+      throw new RCANNodeSyncError(
+        `Failed to fetch node manifest from ${nodeUrl}: HTTP ${resp.status}`,
+        nodeUrl
+      );
+    }
+    let data;
+    try {
+      data = await resp.json();
+    } catch (err) {
+      throw new RCANNodeSyncError(
+        `Invalid JSON in node manifest from ${nodeUrl}`,
+        nodeUrl,
+        err instanceof Error ? err : void 0
+      );
+    }
+    if (!this.verifyNode(data)) {
+      throw new RCANNodeTrustError("missing_pubkey", nodeUrl);
+    }
+    return data;
+  }
+  /**
+   * Get list of known registry nodes from root /api/v1/nodes.
+   * Optionally filter by namespace prefix (e.g. "BD").
+   */
+  async listNodes(prefix) {
+    const qs = prefix ? `?prefix=${encodeURIComponent(prefix)}` : "";
+    const url = `${this.rootUrl}/api/v1/nodes${qs}`;
+    const resp = await this._fetch(url);
+    if (!resp.ok) {
+      throw new RCANNodeSyncError(
+        `Failed to list nodes from ${url}: HTTP ${resp.status}`,
+        url
+      );
+    }
+    let data;
+    try {
+      data = await resp.json();
+    } catch (err) {
+      throw new RCANNodeSyncError(
+        `Invalid JSON in nodes list from ${url}`,
+        url,
+        err instanceof Error ? err : void 0
+      );
+    }
+    if (Array.isArray(data)) return data;
+    if (data && typeof data === "object" && "nodes" in data) {
+      return data.nodes;
+    }
+    return [];
+  }
+  /**
+   * Find the authoritative node for an RRN.
+   * - Delegated RRN (RRN-BD-00000001): GET /api/v1/nodes?prefix=BD, return first match.
+   * - Root RRN (RRN-00000042): return root node manifest.
+   * - Unknown format: throws RCANNodeNotFoundError.
+   */
+  async discover(rrn) {
+    const parsed = parseRRNNamespace(rrn);
+    if (!parsed) {
+      throw new RCANNodeNotFoundError(rrn, this.rootUrl);
+    }
+    if (parsed.type === "root") {
+      return this.getNodeManifest(this.rootUrl);
+    }
+    const nodes = await this.listNodes(parsed.prefix);
+    if (nodes.length === 0) {
+      throw new RCANNodeNotFoundError(rrn, this.rootUrl);
+    }
+    return nodes[0];
+  }
+  /**
+   * Resolve an RRN across the federation.
+   * First tries {rootUrl}/api/v1/resolve/{rrn}.
+   * On 404, discovers the authoritative node and tries {node.api_base}/robots/{rrn}.
+   */
+  async resolve(rrn) {
+    const primaryUrl = `${this.rootUrl}/api/v1/resolve/${encodeURIComponent(rrn)}`;
+    let resp;
+    try {
+      resp = await this._fetch(primaryUrl);
+    } catch (err) {
+      throw err;
+    }
+    if (resp.ok) {
+      try {
+        return await resp.json();
+      } catch (err) {
+        throw new RCANNodeSyncError(
+          `Invalid JSON in resolve response for ${rrn}`,
+          this.rootUrl,
+          err instanceof Error ? err : void 0
+        );
+      }
+    }
+    if (resp.status !== 404) {
+      throw new RCANNodeSyncError(
+        `Unexpected HTTP ${resp.status} resolving ${rrn}`,
+        this.rootUrl
+      );
+    }
+    const node = await this.discover(rrn);
+    const fallbackUrl = `${node.api_base.replace(/\/$/, "")}/robots/${encodeURIComponent(rrn)}`;
+    const fallbackResp = await this._fetch(fallbackUrl);
+    if (!fallbackResp.ok) {
+      if (fallbackResp.status === 404) {
+        throw new RCANNodeNotFoundError(rrn, node.api_base);
+      }
+      throw new RCANNodeSyncError(
+        `HTTP ${fallbackResp.status} from authoritative node for ${rrn}`,
+        node.api_base
+      );
+    }
+    try {
+      return await fallbackResp.json();
+    } catch (err) {
+      throw new RCANNodeSyncError(
+        `Invalid JSON in fallback resolve response for ${rrn}`,
+        node.api_base,
+        err instanceof Error ? err : void 0
+      );
+    }
+  }
+  /**
+   * Verify a node manifest is well-formed.
+   * Checks required fields, ed25519: public_key prefix, valid node_type, https:// api_base.
+   */
+  verifyNode(manifest) {
+    if (!manifest || typeof manifest !== "object") return false;
+    const m = manifest;
+    if (typeof m.rcan_node_version !== "string" || !m.rcan_node_version) return false;
+    if (typeof m.node_type !== "string" || !VALID_NODE_TYPES.has(m.node_type)) return false;
+    if (typeof m.operator !== "string" || !m.operator) return false;
+    if (typeof m.namespace_prefix !== "string" || !m.namespace_prefix) return false;
+    if (typeof m.public_key !== "string" || !m.public_key.startsWith("ed25519:")) return false;
+    if (typeof m.api_base !== "string" || !m.api_base.startsWith("https://")) return false;
+    return true;
+  }
+};
+
+// src/schema.ts
+var SCHEMA_BASE = "https://rcan.dev/schemas";
+var schemaCache = /* @__PURE__ */ new Map();
+async function fetchCanonicalSchema(schemaName) {
+  if (schemaCache.has(schemaName)) return schemaCache.get(schemaName);
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch(`${SCHEMA_BASE}/${schemaName}`, { signal: controller.signal });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const schema = await res.json();
+    schemaCache.set(schemaName, schema);
+    return schema;
+  } catch {
+    return null;
+  }
+}
+async function validateConfigAgainstSchema(config) {
+  const schema = await fetchCanonicalSchema("rcan-config.schema.json");
+  if (!schema) return { valid: true, skipped: true };
+  const errors = [];
+  if (typeof config !== "object" || config === null) {
+    return { valid: false, errors: ["Config must be an object"] };
+  }
+  const cfg = config;
+  const required = schema.required ?? [];
+  for (const key of required) {
+    if (!(key in cfg)) errors.push(`Missing required field: ${key}`);
+  }
+  return errors.length === 0 ? { valid: true } : { valid: false, errors };
+}
+async function validateNodeAgainstSchema(manifest) {
+  const schema = await fetchCanonicalSchema("rcan-node.schema.json");
+  if (!schema) return { valid: true, skipped: true };
+  const errors = [];
+  if (typeof manifest !== "object" || manifest === null) {
+    return { valid: false, errors: ["Manifest must be an object"] };
+  }
+  const m = manifest;
+  const required = schema.required ?? [];
+  for (const key of required) {
+    if (!(key in m)) errors.push(`Missing required field: ${key}`);
+  }
+  return errors.length === 0 ? { valid: true } : { valid: false, errors };
+}
+
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.3.0";
+var SPEC_VERSION = "1.2";
 var RCAN_VERSION = "1.2";
 export {
   AuditChain,
@@ -881,11 +1156,16 @@ export {
   ConfidenceGate,
   GateError,
   HiTLGate,
+  NodeClient,
   RCANAddressError,
   RCANError,
   RCANGateError,
   RCANMessage,
   RCANMessageError,
+  RCANNodeError,
+  RCANNodeNotFoundError,
+  RCANNodeSyncError,
+  RCANNodeTrustError,
   RCANRegistryError,
   RCANSignatureError,
   RCANValidationError,
@@ -893,9 +1173,13 @@ export {
   RegistryClient,
   RobotURI,
   RobotURIError,
+  SPEC_VERSION,
   VERSION,
+  fetchCanonicalSchema,
   validateConfig,
+  validateConfigAgainstSchema,
   validateMessage,
+  validateNodeAgainstSchema,
   validateURI
 };
 //# sourceMappingURL=browser.mjs.map