@nekzus/liop 2.5.0-beta.1 → 2.5.0-beta.3

package/dist/{index-cMV0_yD9.d.ts → index-BYDtRGue.d.ts}

@@ -1,17 +1,9 @@
-import { L as LiopVerifier } from './verifier-COnid_dg.js';
-import { MeshNodeConfig } from './mesh.js';
+import { L as LiopVerifier } from './verifier-DqZ9MQ9l.js';
+import { M as MeshNodeConfig } from './node-Djzm6UYd.js';
+import * as grpc from '@grpc/grpc-js';
 import { EventEmitter } from 'node:events';
-import { M as McpEra, C as CallToolRequest, a as CallToolResult } from './types-lJIxBlWF.js';
-
-/**
- * LIOP Certificate Manager (CertManager)
- * Provides automated certificate monitoring, X.509 validity inspection,
- * and hot-reloading for mutual TLS (mTLS) without node restarts.
- *
- * Compliance:
- * - NIST SP 800-52 Rev. 2: Guidelines for the Selection and Use of TLS
- * - Zero-Trust Architecture (NIST SP 800-207): Continuous cryptographic verification
- */
+import { Z as ZkPolicy } from './zk-DzYNWBgo.js';
+import { M as McpEra, C as CallToolRequest, a as CallToolResult } from './types-29zv9X1V.js';
 
 interface CertManagerOptions {
     /** Path to the root CA certificate (PEM format) */
@@ -77,23 +69,6 @@ declare class CertManager extends EventEmitter {
     dispose(): void;
 }
 
-/**
- * LIOP TLS Configuration
- *
- * Provides conditional TLS credential factories for gRPC connections.
- * When TLS options are provided, connections are secured with mutual TLS.
- * Otherwise, falls back to insecure credentials (alpha/development mode).
- *
- * Production Hardening (Phase 128):
- * - When NODE_ENV=production and TLS is configured but certificate loading
- *   fails, the system throws a fatal error instead of silently degrading
- *   to insecure credentials. This prevents MITM/eavesdropping attacks
- *   caused by misconfigured certificate paths going unnoticed.
- * - Reference: gRPC-node official docs — "Using insecure credentials in
- *   production poses significant security risks including eavesdropping,
- *   MITM attacks, and lack of authentication."
- */
-
 interface LiopTlsOptions {
     /** Path to the root CA certificate (PEM format) */
     rootCert?: string;
@@ -105,7 +80,28 @@ interface LiopTlsOptions {
     mutualTls?: boolean;
     /** Optional CertManager instance for automated certificate management and hot reloading */
     certManager?: CertManager;
+    /**
+     * Explicitly permit unencrypted (insecure) credentials for local development,
+     * Docker testbeds, or tooling harnesses without emitting console warnings.
+     * Ignored if isTlsEnforced() is true (production/enforced mode always throws).
+     */
+    insecure?: boolean;
+    /**
+     * Explicitly suppress the fallback warning when insecure credentials are created.
+     */
+    suppressWarning?: boolean;
 }
+/**
+ * Creates gRPC server credentials from TLS options.
+ * In production or when LIOP_ENFORCE_TLS=true, refuses to fall back to insecure.
+ * When mutualTls=true, enforces client certificate authentication against root CA.
+ */
+declare function createServerCredentials(tls?: LiopTlsOptions): grpc.ServerCredentials;
+/**
+ * Creates gRPC channel credentials from TLS options.
+ * In production or when LIOP_ENFORCE_TLS=true, refuses to fall back to insecure.
+ */
+declare function createChannelCredentials(tls?: LiopTlsOptions): grpc.ChannelCredentials;
 
 /**
  * LIOP Client
@@ -119,15 +115,12 @@ declare class LiopClient {
     private serverInfo?;
     verifier: LiopVerifier;
     private oauthToken?;
+    private tokenManager?;
     /** Protocol negotiation era */
     era: McpEra;
     /** Negotiated protocol version */
     protocolVersion: string;
     constructor(tls?: LiopTlsOptions);
-    /**
-     * Requests an M2M access token from the Nexus Authorization Server using Client Credentials.
-     */
-    private acquireM2MToken;
     /**
      * Discovers and connects to the target server or mesh capability.
      * If address is omitted, it sets up the MeshNode to act purely dynamically.
@@ -174,7 +167,10 @@ declare class LiopClient {
     /**
      * Invokes a tool.
      */
-    callTool(request: CallToolRequest, _wasmPayload?: Buffer): Promise<CallToolResult>;
+    callTool(request: CallToolRequest, _wasmPayload?: Buffer, options?: {
+        zkPolicy?: ZkPolicy;
+        circuitName?: string;
+    }): Promise<CallToolResult>;
     private getOrCreateRpcClient;
     /**
      * Reads a specific resource by URI.
@@ -187,6 +183,19 @@ declare class LiopClient {
             text: string;
         }>;
     }>;
+    /**
+     * Returns the local PeerId string if the mesh node is active, null otherwise.
+     * PeerIds are public identifiers by libp2p protocol design (Ed25519 public key hash).
+     */
+    get peerId(): string | null;
+    /**
+     * Returns true if the mesh node is initialized and running.
+     */
+    get isMeshActive(): boolean;
+    /**
+     * Returns the number of active P2P connections, or 0 if the mesh is inactive.
+     */
+    get connectionCount(): number;
     getServerInfo(): {
         name: string;
         version: string;
@@ -197,4 +206,4 @@ declare class LiopClient {
     close(): Promise<void>;
 }
 
-export { type CertInfo as C, type LiopTlsOptions as L, CertManager as a, type CertManagerOptions as b, LiopClient as c };
+export { type CertInfo as C, type LiopTlsOptions as L, CertManager as a, type CertManagerOptions as b, LiopClient as c, createChannelCredentials as d, createServerCredentials as e };

package/dist/{index-BW95kAL4.d.ts → index-ByzjpRCk.d.ts}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { MeshNode } from './mesh.js';
-import { J as JwtValidator, S as ServerInfo, a as CallToolResult, P as Prompt, G as GetPromptRequest, d as GetPromptResult, C as CallToolRequest, T as Tool, R as Resource } from './types-lJIxBlWF.js';
+import { M as MeshNodeConfig, a as MeshNode } from './node-Djzm6UYd.js';
+import { d as AuditLogger, J as JwtValidator, S as ServerInfo, a as CallToolResult, P as Prompt, e as GetPromptRequest, f as GetPromptResult, C as CallToolRequest, T as Tool, R as Resource } from './types-29zv9X1V.js';
 
 /**
  * LIOP OAuth 2.1 Hybrid Auth — Configuration Types
@@ -100,60 +100,6 @@ declare const AUTH_DEFAULTS: {
     readonly signingAlgorithm: "EdDSA";
 };
 
-/**
- * LIOP Immutable Audit Logger (Phase Beta-3)
- * SOC 2 Type II & HIPAA compliant audit trail with cryptographic Hash-Chain.
- * Guarantees tamper-evidence and non-repudiation for all Logic-on-Origin executions.
- */
-type AuditStatus = "SUCCESS" | "BLOCKED_EGRESS" | "ERROR" | "POLICY_VIOLATION";
-interface AuditEntry {
-    id: string;
-    timestamp: string;
-    traceId: string;
-    agentDid: string;
-    peerId: string;
-    toolName: string;
-    datasetHash: string;
-    fuelConsumed: number;
-    outputHash: string;
-    zkReceiptSig: string;
-    status: AuditStatus;
-    prevEntryHash: string;
-    entryHash: string;
-}
-interface AuditRecordParams {
-    timestamp?: string;
-    traceId?: string;
-    agentDid: string;
-    peerId: string;
-    toolName: string;
-    datasetHash?: string;
-    fuelConsumed: number;
-    outputHash?: string;
-    zkReceiptSig?: string;
-    status: AuditStatus;
-}
-declare const GENESIS_HASH: string;
-declare function computeEntryHash(entryWithoutHash: Omit<AuditEntry, "entryHash">): string;
-declare class AuditLogger {
-    private entries;
-    private lastEntryHash;
-    private filePath?;
-    constructor(filePath?: string);
-    recordExecution(params: AuditRecordParams): AuditEntry;
-    getEntries(): readonly AuditEntry[];
-    getEntryCount(): number;
-    verifyIntegrity(): {
-        valid: boolean;
-        totalEntries: number;
-        brokenIndex?: number;
-        reason?: string;
-    };
-    exportJsonl(): string;
-    private loadFromFile;
-}
-declare const globalAuditLogger: AuditLogger;
-
 /** Single named entity detected by the NER scanner. */
 interface NerEntity {
     type: "person" | "place" | "organization";
@@ -211,11 +157,6 @@ interface OutputSanitizerConfig {
  */
 declare function sanitizeOutput(output: unknown, config?: OutputSanitizerConfig): unknown;
 
-/**
- * LIOP Professional PII Engine (The Shield V2 - Tier-1 Military Edition)
- * Implements high-fidelity detection based on NIST and OWASP standards.
- * Features Multi-Layer Verification (Regex + Algorithmic Validators).
- */
 type PiiRuleDefinition = {
     name: string;
     pattern: string | RegExp;
@@ -340,6 +281,10 @@ interface LiopServerOptions {
      * Path to a shared JSON file for persistent Query Budget tracking across multiple server instances.
      */
     budgetStorePath?: string;
+    /** Expected guest image identifier hash for sovereign enclaves (Hex) */
+    guestImageId?: string;
+    /** Static verification key mappings for fast-path analytical circuits */
+    zkVkeys?: Record<string, unknown>;
 }
 interface AggregationPolicy {
     /** Maximum number of object-type array elements allowed (default: 10) */
@@ -390,6 +335,29 @@ interface LogicExecutionPolicy {
      * Path to a shared JSON file for persistent Query Budget tracking across multiple server instances.
      */
     budgetStorePath?: string;
+    /**
+     * Zero-Knowledge proof mode required for this tool capability.
+     * - "none": standard HMAC-SHA256 session commitment
+     * - "optimistic": Groth16 v2 receipt generated if prover available, otherwise fallback
+     * - "required": strictly enforces Groth16 v2 proof generation; rejects if unavailable
+     */
+    zkMode?: "none" | "optimistic" | "required";
+    /**
+     * Optional custom guest image identifier hash for this capability.
+     */
+    guestImageId?: string;
+    /**
+     * Name of the designated R1CS circuit (e.g. "sum", "count", "average", "filter").
+     */
+    circuitName?: string;
+    /**
+     * Static verification key JSON structure for this capability.
+     */
+    vkey?: Record<string, unknown>;
+    /**
+     * Whether to co-sign the Groth16 receipt with an ML-DSA-65 post-quantum digital signature (FIPS 204).
+     */
+    pqcSign?: boolean;
 }
 declare class LiopServer {
     private serverInfo;
@@ -416,6 +384,7 @@ declare class LiopServer {
     private meshNode;
     private rpcServer;
     private boundPort;
+    private enclavePqcKeypair?;
     jwtValidator?: JwtValidator;
     oauthProvider?: any;
     private sessions;
@@ -458,11 +427,7 @@ declare class LiopServer {
      */
     connect(options?: {
         port?: number;
-        meshConfig?: {
-            listenAddresses?: string[];
-            bootstrapNodes?: string[];
-            identityPath?: string;
-        };
+        meshConfig?: MeshNodeConfig;
     }): Promise<void>;
     /**
      * Register a new Tool
@@ -541,6 +506,10 @@ declare class LiopServer {
      * Injects data into the secure sandbox context for Logic-on-Origin tools.
      */
     setSandboxData(records: Record<string, unknown>[]): void;
+    /**
+     * Returns the read-only sandbox records registered in the enclave.
+     */
+    getSandboxData(): readonly Record<string, unknown>[];
     getBoundPort(): number | null;
     /**
      * Connects to the libp2p Kademlia DHT and announces capabilities.
@@ -548,11 +517,7 @@ declare class LiopServer {
      */
     connectToMesh(options?: {
         port?: number;
-        meshConfig?: {
-            listenAddresses?: string[];
-            bootstrapNodes?: string[];
-            identityPath?: string;
-        };
+        meshConfig?: MeshNodeConfig;
     }): Promise<void>;
     /**
      * Internal worker execution with Egress Filtering logic.
@@ -581,4 +546,4 @@ declare class LiopServer {
     private applyInMemoryBudget;
 }
 
-export { AUTH_DEFAULTS as A, GENESIS_HASH as G, LiopServer as L, NerScanner as N, type OAuthClientConfig as O, PII_PATTERNS as P, type ToolHandler as T, type LiopServerOptions as a, type AggregationPolicy as b, type AuditEntry as c, AuditLogger as d, type AuditRecordParams as e, type AuditStatus as f, type AuthRole as g, type LiopAuthConfig as h, type LogicExecutionPolicy as i, type OutputSanitizerConfig as j, PII_PRESETS as k, type PiiRule as l, PiiScanner as m, computeEntryHash as n, globalAuditLogger as o, sanitizeOutput as s };
+export { AUTH_DEFAULTS as A, LiopServer as L, NerScanner as N, type OAuthClientConfig as O, PII_PATTERNS as P, type ToolHandler as T, type LiopServerOptions as a, type AggregationPolicy as b, type AuthRole as c, type LiopAuthConfig as d, type LogicExecutionPolicy as e, type OutputSanitizerConfig as f, PII_PRESETS as g, type PiiRule as h, PiiScanner as i, sanitizeOutput as s };

package/dist/index.d.ts

@@ -1,20 +1,48 @@
 export { LiopBridgeOptions, LiopMcpBridge, LiopStreamBridge, LiopStreamBridgeOptions } from './bridge.js';
-import { L as LiopTlsOptions } from './index-cMV0_yD9.js';
-export { C as CertInfo, a as CertManager, b as CertManagerOptions, c as LiopClient } from './index-cMV0_yD9.js';
+import { L as LiopTlsOptions } from './index-BYDtRGue.js';
+export { C as CertInfo, a as CertManager, b as CertManagerOptions, c as LiopClient, d as createChannelCredentials, e as createServerCredentials } from './index-BYDtRGue.js';
+import { ProofWithSignals, VerificationKey } from 'micro-zk-proofs';
+export { ProofWithSignals, VerificationKey } from 'micro-zk-proofs';
+export { L as LiopVerifier, T as TeePolicy, a as TeeVerificationOptions, b as TeeVerificationResult, V as VerifyZkOptions } from './verifier-DqZ9MQ9l.js';
 import * as http from 'node:http';
-export { I as InMemoryRateLimiter, L as LiopHybridGateway, a as LiopMcpRouter, R as RateLimitStatus, b as RateLimiterOptions } from './hybrid-CF__0YnC.js';
-export { LiopManifest, MeshNode, MeshNodeConfig } from './mesh.js';
+export { I as InMemoryRateLimiter, L as LiopHybridGateway, a as LiopMcpRouter, R as RateLimitStatus, b as RateLimiterOptions } from './hybrid-BZpCiUaV.js';
+import { A as AuthInfo } from './types-29zv9X1V.js';
+export { g as AuditEntry, h as AuditInterceptor, d as AuditLogger, i as AuditRecordParams, j as AuditStatus, k as CacheableResult, C as CallToolRequest, a as CallToolResult, D as DiscoverResult, l as GENESIS_HASH, m as GatewayAdmissionResult, n as GatewayInterceptor, o as GatewayInterceptorContext, G as GatewayInterceptorOptions, e as GetPromptRequest, f as GetPromptResult, I as InputRequest, p as InputRequiredResult, q as InputResponse, J as JwtValidator, L as LiopLogger, r as LogEvent, s as LogInterceptor, t as LogLevel, u as MCP_LEGACY_SUPPORT_ENABLED, v as MCP_PROTOCOL_VERSION, w as MCP_PROTOCOL_VERSION_LEGACY, M as McpEra, b as McpRequest, x as McpRequestMeta, c as McpResponse, P as Prompt, y as PromptSchema, R as Resource, z as ResourceSchema, S as ServerInfo, T as Tool, B as ToolSchema, E as computeEntryHash, F as executeGatewayInterceptor, H as globalAuditLogger, K as log } from './types-29zv9X1V.js';
+export { L as LiopManifest, a as MeshNode, M as MeshNodeConfig } from './node-Djzm6UYd.js';
+export { SWARM_KEY_BYTE_LENGTH, createSwarmKey, deserializeSwarmKey, loadSwarmKey, parseSwarmKey, saveSwarmKey, serializeSwarmKey } from './mesh.js';
 import * as grpc from '@grpc/grpc-js';
-export { A as AUTH_DEFAULTS, b as AggregationPolicy, c as AuditEntry, d as AuditLogger, e as AuditRecordParams, f as AuditStatus, g as AuthRole, G as GENESIS_HASH, h as LiopAuthConfig, L as LiopServer, a as LiopServerOptions, i as LogicExecutionPolicy, N as NerScanner, O as OAuthClientConfig, j as OutputSanitizerConfig, P as PII_PATTERNS, k as PII_PRESETS, l as PiiRule, m as PiiScanner, T as ToolHandler, n as computeEntryHash, o as globalAuditLogger, s as sanitizeOutput } from './index-BW95kAL4.js';
-import { A as AuthInfo } from './types-lJIxBlWF.js';
-export { e as CacheableResult, C as CallToolRequest, a as CallToolResult, D as DiscoverResult, G as GetPromptRequest, d as GetPromptResult, I as InputRequest, f as InputRequiredResult, g as InputResponse, J as JwtValidator, h as MCP_LEGACY_SUPPORT_ENABLED, i as MCP_PROTOCOL_VERSION, j as MCP_PROTOCOL_VERSION_LEGACY, M as McpEra, b as McpRequest, k as McpRequestMeta, c as McpResponse, P as Prompt, l as PromptSchema, R as Resource, m as ResourceSchema, S as ServerInfo, T as Tool, n as ToolSchema } from './types-lJIxBlWF.js';
+export { A as AUTH_DEFAULTS, b as AggregationPolicy, c as AuthRole, d as LiopAuthConfig, L as LiopServer, a as LiopServerOptions, e as LogicExecutionPolicy, N as NerScanner, O as OAuthClientConfig, f as OutputSanitizerConfig, P as PII_PATTERNS, g as PII_PRESETS, h as PiiRule, i as PiiScanner, T as ToolHandler, s as sanitizeOutput } from './index-ByzjpRCk.js';
 import * as jose from 'jose';
 import Provider from 'oidc-provider';
+export { D as DecodedReceipt, P as ProofType, R as RECEIPT_VERSION_V1, a as RECEIPT_VERSION_V2, b as ZK_JOURNAL_V2_SIZE, c as ZkJournalV2, Z as ZkPolicy, d as ZkReceipt, e as ZkVerificationError, f as ZkVerifier, g as decodeJournalV2, h as encodeJournalV2, r as receiptCodec } from './zk-DzYNWBgo.js';
 import '@modelcontextprotocol/sdk/server/mcp.js';
 import 'zod';
-import './verifier-COnid_dg.js';
 import 'node:events';
 
+declare const VERIFICATION_LATENCY_BUDGET_MS = 250;
+
+/**
+ * Verifies a Groth16 Zero-Knowledge proof against a verification key.
+ * Traps curve validation errors gracefully to ensure safe verification.
+ */
+declare function verifyGroth16Proof(vkey: VerificationKey, proofWithSignals: ProofWithSignals): boolean;
+/**
+ * Serializes a VerificationKey into a Buffer.
+ */
+declare function serializeVKey(vkey: VerificationKey): Buffer;
+/**
+ * Deserializes a Buffer into a typed VerificationKey.
+ */
+declare function deserializeVKey(buf: Buffer): VerificationKey;
+/**
+ * Serializes a ProofWithSignals into a Buffer.
+ */
+declare function serializeGrothProof(proofWithSignals: ProofWithSignals): Buffer;
+/**
+ * Deserializes a Buffer into a typed ProofWithSignals.
+ */
+declare function deserializeGrothProof(buf: Buffer): ProofWithSignals;
+
 /**
  * TokenEstimator — Pluggable strategy for counting tokens in text content.
  *
@@ -36,7 +64,7 @@ interface TokenEstimator {
  *
  * - Synchronous: safe for hot-path usage without async overhead
  * - Merge cache reduced to 10K entries for long-running server processes
- * - Inlined at build-time: zero external runtime dependencies in node_modules
+ * - External dependency: resolved from gpt-tokenizer in node_modules at runtime
  */
 declare class RealTokenEstimator implements TokenEstimator {
     readonly name = "o200k_base";
@@ -113,6 +141,7 @@ interface TokenOperationMetric {
     readonly toolName?: string;
     readonly peerId?: string;
     readonly durationMs?: number;
+    readonly originDatasetTokens?: number;
 }
 /** Session-level aggregate report */
 interface TokenSessionReport {
@@ -313,17 +342,25 @@ declare class MetricsRegistry {
 }
 declare const protocolMetrics: MetricsRegistry;
 declare const toolCallsTotal: Counter;
+declare const toolCallErrorsTotal: Counter;
 declare const fuelConsumed: Histogram;
 declare const meshPeersConnected: Gauge;
 declare const manifestCacheSize: Gauge;
 declare const egressBlocksTotal: Counter;
 declare const zkVerificationDurationMs: Histogram;
+declare const zkVerificationsTotal: Counter;
+declare const zkProofsByTypeTotal: Counter;
+declare const zkProvingDurationMs: Histogram;
+declare const zkVkeyCacheSize: Gauge;
+declare const tokensInputTotal: Counter;
+declare const tokensOutputTotal: Counter;
+declare const tokensSavedTotal: Counter;
+declare const operationDurationMs: Histogram;
+declare const pqcHandshakeDurationMs: Histogram;
+declare const pqcHandshakesTotal: Counter;
+declare const wireEgressBytesTotal: Counter;
+declare const wireSavedBytesTotal: Counter;
 
-/**
- * LIOP OpenTelemetry Distributed Tracing (Phase Beta-3)
- * W3C TraceContext compliant distributed tracer for gRPC & MCP transports.
- * Spec: https://www.w3.org/TR/trace-context/
- */
 interface SpanContext {
     traceId: string;
     spanId: string;
@@ -382,6 +419,16 @@ declare const GRPC_CHANNEL_OPTIONS: Readonly<Record<string, string | number>>;
  * TypeScript interfaces reflecting liop_core.proto (LIOP v1)
  * Optimized for logic-on-origin and high-performance serialization.
  */
+declare enum ProofMode {
+    PROOF_MODE_LEGACY_HMAC = 0,
+    PROOF_MODE_ZK_OPTIMISTIC = 1,
+    PROOF_MODE_ZK_BLOCKING = 2
+}
+declare enum ProofType {
+    PROOF_TYPE_HMAC_LEGACY = 0,
+    PROOF_TYPE_GROTH16 = 2,
+    PROOF_TYPE_GROTH16_PQC_HYBRID = 3
+}
 interface IntentRequest {
     agent_did: string;
     capability_hash: string;
@@ -399,14 +446,18 @@ interface LogicRequest {
     inputs: Record<string, Uint8Array>;
     pqc_ciphertext: Uint8Array;
     aes_nonce: Uint8Array;
+    requested_proof_mode?: ProofMode;
 }
 interface LogicResponse {
     semantic_evidence: string;
     cryptographic_proof: Uint8Array;
     zk_receipt: Uint8Array;
     is_error: boolean;
+    proof_type?: ProofType;
+    guest_image_id?: Uint8Array;
 }
 
+type TokenProvider = string | (() => Promise<string | undefined> | string | undefined);
 /**
  * LIOP gRPC Client Implementation
  * Provides a high-level interface for secure intent negotiation and logic execution.
@@ -414,8 +465,11 @@ interface LogicResponse {
 declare class LiopRpcClient {
     private client;
     private token?;
+    private lastResolvedToken?;
     readonly address: string;
-    constructor(address: string, tls?: LiopTlsOptions, token?: string);
+    constructor(address: string, tls?: LiopTlsOptions, token?: TokenProvider);
+    setToken(token?: TokenProvider): void;
+    private resolveToken;
     /**
      * Negotiates intent with the remote host.
      * Returns the ephemeral Kyber public key for payload encryption.
@@ -430,17 +484,28 @@ declare class LiopRpcClient {
 }
 
 /**
- * LIOP Post-Quantum Digital Signature Wrapper
- * Implements ML-DSA-65 (CRYSTALS-Dilithium, NIST FIPS 204) for quantum-resistant
- * manifest attestation, node revocation receipts, and cryptographic integrity.
- *
- * Characteristics:
- * - Security Category: NIST Level 3 (~AES-192 equivalent quantum resistance)
- * - Public Key Length: 1952 bytes
- * - Secret Key Length: 4032 bytes
- * - Signature Length: 3309 bytes
- * - Implementation: Pure TypeScript/JS via @noble/post-quantum
+ * LIOP Symmetric Payload Encryption Wrapper
+ * Uses AES-256-GCM to secure WASM Code transport over Zero-Trust networks.
+ * Fully compatible with the `aes-gcm` Rust crate used by Wasmtime.
  */
+declare const AesGcmWrapper: {
+    /**
+     * Encrypts a raw WASM payload using the shared secret negotiated via Kyber768.
+     *
+     * @param payload Raw incoming WASM byte array or string.
+     * @param sharedSecret A perfectly derived 32-byte (256-bit) shared secret array
+     * @returns The encrypted buffer to push to the GRPc stream, along with the 12-byte initialization vector natively generated.
+     */
+    encryptPayload(payload: Uint8Array | Buffer, sharedSecret: Uint8Array): {
+        ciphertext: Buffer;
+        nonce: Buffer;
+    };
+    /**
+     * Decrypts a remote Zero-Knowledge receipt using AES-256-GCM.
+     */
+    decryptPayload(ciphertextBuffer: Buffer, nonce: Buffer, sharedSecret: Uint8Array): Buffer;
+};
+
 declare const DILITHIUM65_CONSTANTS: {
     readonly PUBLIC_KEY_BYTES: 1952;
     readonly SECRET_KEY_BYTES: 4032;
@@ -460,6 +525,10 @@ declare const Dilithium65Wrapper: {
         publicKey: Uint8Array;
         secretKey: Uint8Array;
     };
+    /**
+     * Derives the ML-DSA-65 public key from a given secret key.
+     */
+    getPublicKey(secretKey: Uint8Array): Uint8Array;
     /**
      * Validates and imports a raw ML-DSA-65 public key.
      */
@@ -527,6 +596,132 @@ declare class LiopRpcServer {
     stop(): Promise<void>;
 }
 
+type TransportProvider = "http-gateway" | "p2p-grpc" | "local";
+interface ToolDefinition {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+}
+interface ToolRoute {
+    name: string;
+    provider: TransportProvider;
+    endpoint: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    latencyMs: number;
+    failCount: number;
+    lastSuccess: number;
+    authRequired?: boolean;
+}
+declare class RoutingTable {
+    private routes;
+    private static readonly MAX_FAILURES;
+    /**
+     * Registers or updates a collection of tools exposed via an HTTP Gateway.
+     */
+    registerGatewayTools(tools: ToolDefinition[], mcpEndpoint: string, authRequired?: boolean): void;
+    /**
+     * Registers tools discovered directly over the P2P Mesh (gRPC).
+     */
+    registerMeshTools(tools: ToolDefinition[], grpcTarget: string, authRequired?: boolean): void;
+    /**
+     * Registers an in-process local tool (e.g. LiopMeshStatus).
+     */
+    registerLocalTool(tool: ToolDefinition): void;
+    /**
+     * Resolves the optimal route for a specific tool.
+     */
+    resolve(toolName: string): ToolRoute | undefined;
+    /**
+     * Records a successful invocation on a route, resetting failures and updating latency.
+     */
+    recordSuccess(toolName: string, latencyMs: number): void;
+    /**
+     * Records a failed invocation on a route.
+     */
+    recordFailure(toolName: string): void;
+    /**
+     * Lists all registered tools in sorted format for tools/list.
+     */
+    getAllToolDefinitions(): ToolDefinition[];
+    getRoute(toolName: string): ToolRoute | undefined;
+    size(): number;
+    clear(): void;
+}
+
+interface TokenManagerOptions {
+    tokenEndpoint: string;
+    clientId: string;
+    clientSecret: string;
+    audience?: string;
+    scopes?: string | string[];
+    staticToken?: string;
+}
+declare class TokenManager {
+    private cachedToken;
+    private expiresAt;
+    private pendingPromise;
+    private readonly tokenEndpoint;
+    private readonly clientId;
+    private readonly clientSecret;
+    private readonly audience;
+    private readonly scope;
+    private staticToken?;
+    private static readonly REFRESH_BUFFER_MS;
+    constructor(options: TokenManagerOptions);
+    /**
+     * Returns a valid OAuth 2.1 access token.
+     * Automatically performs preemptive refresh if the token is close to expiry.
+     */
+    getToken(): Promise<string>;
+    /**
+     * Force-invalidates cached token, e.g. after receiving a 401 Unauthorized response.
+     */
+    invalidate(): void;
+    /**
+     * Returns true if the token is absent or has passed the refresh threshold.
+     */
+    isExpired(): boolean;
+    getExpiresAt(): number;
+    private fetchNewToken;
+}
+
+interface GatewayTopologyInfo {
+    baseUrl: string;
+    mcpEndpoint: string;
+    healthEndpoint: string;
+    tokenEndpoint: string;
+    issuer: string;
+    audience: string;
+    scopes: string[];
+    tools: string[];
+    tier: number;
+}
+interface MeshTopologyInfo {
+    bootstrapNodes: string[];
+    identityPath?: string;
+}
+interface TopologyProbeResult {
+    mode: "gateway" | "mesh" | "hybrid";
+    gateway?: GatewayTopologyInfo;
+    mesh?: MeshTopologyInfo;
+}
+interface TopologyProbeOptions {
+    blgUrl?: string;
+    nexusUrl?: string;
+    clientId?: string;
+    clientSecret?: string;
+    audience?: string;
+    staticToken?: string;
+    bootstrapNodes?: string[];
+    identityPath?: string;
+    autoProbeLocal?: boolean;
+}
+/**
+ * Probes the runtime environment and determines the optimal architecture mode.
+ */
+declare function probeTopology(options?: TopologyProbeOptions): Promise<TopologyProbeResult>;
+
 /**
  * Returns a filtered environment object containing only safe system variables,
  * preventing exposure of sensitive credentials and shell function injection.
@@ -574,21 +769,6 @@ declare class WasiSandbox {
     teardown(): Promise<void>;
 }
 
-/**
- * LIOP Embedded OAuth 2.1 Authorization Server
- *
- * Implements a lightweight, high-performance OAuth 2.1 / OIDC Authorization Server
- * for the Nexus node using `panva/node-oidc-provider`.
- *
- * Security Hardening:
- * - M2M (Machine-to-Machine) Client Credentials Grant ONLY (Zero human interaction interface).
- * - Algorithmic whitelist: EdDSA (Ed25519) for token signing.
- * - JWT Access Tokens: Allows stateless, cryptographically-secure validation on data nodes (NIST SP 800-207).
- * - Interaction Lockout: Throws exception on any interactive flow attempt to prevent hijack attacks (OWASP).
- *
- * Standards: OAuth 2.1, RFC 6749, RFC 7519, NIST SP 800-63B
- */
-
 interface OAuthServerClientConfig {
     client_id: string;
     client_secret: string;
@@ -610,15 +790,6 @@ interface OAuthServerResult {
  */
 declare function createOAuthServer(config: OAuthServerConfig): OAuthServerResult;
 
-/**
- * LIOP Protected Resource Metadata — RFC 9728
- *
- * Builds the JSON document served at /.well-known/oauth-protected-resource.
- * This enables MCP clients to discover the authorization server and
- * required scopes for accessing LIOP tools and resources.
- *
- * Standards: RFC 9728, MCP Spec 2025-11-25
- */
 /**
  * RFC 9728 Protected Resource Metadata response.
  *
@@ -683,4 +854,4 @@ declare function authorizeRequest(method: string, auth: AuthInfo | null, additio
 declare const LIOP_SCOPES: readonly ["liop:tools:list", "liop:tools:call", "liop:resources:read", "liop:schema:read", "liop:mesh:query"];
 type LiopScope = (typeof LIOP_SCOPES)[number];
 
-export { type AIProvider, AuthInfo, Counter, DILITHIUM65_CONSTANTS, Dilithium65Wrapper, ErrorCode, GRPC_CHANNEL_OPTIONS, GRPC_WEB_CONSTANTS, Gauge, type GrpcWebFrame, HeuristicTokenEstimator, Histogram, Kyber768Wrapper, LIOP_SCOPES, LiopError, LiopOTelBridge, LiopRpcClient, LiopRpcServer, type LiopScope, type LiopSpan, LiopTracer, type MetricDefinition, type MetricLabels, MetricsRegistry, type PromptConfig, RealTokenEstimator, type SandboxConfig, type SpanContext, type TokenEstimator, type TokenOperationMetric, type TokenSessionReport, TokenTelemetryEngine, type ToolTokenBreakdown, WasiSandbox, authorizeRequest, buildProtectedResourceMetadata, calculateAstInstructionFuel, createOAuthServer, createSyncTokenEstimator, createTokenEstimator, decodeFrames, defaultTracer, dispatchGrpcWebRequest, egressBlocksTotal, encodeDataFrame, encodeTrailerFrame, fuelConsumed, generateSystemInstructions, getDefaultEnvironment, isGrpcWebRequest, manifestCacheSize, meshPeersConnected, protocolMetrics, toolCallsTotal, zkVerificationDurationMs };
+export { type AIProvider, AesGcmWrapper, AuthInfo, Counter, DILITHIUM65_CONSTANTS, Dilithium65Wrapper, ErrorCode, GRPC_CHANNEL_OPTIONS, GRPC_WEB_CONSTANTS, type GatewayTopologyInfo, Gauge, type GrpcWebFrame, HeuristicTokenEstimator, Histogram, Kyber768Wrapper, LIOP_SCOPES, LiopError, LiopOTelBridge, LiopRpcClient, LiopRpcServer, type LiopScope, type LiopSpan, LiopTlsOptions, LiopTracer, type MeshTopologyInfo, type MetricDefinition, type MetricLabels, MetricsRegistry, type PromptConfig, RealTokenEstimator, RoutingTable, type SandboxConfig, type SpanContext, type TokenEstimator, TokenManager, type TokenManagerOptions, type TokenOperationMetric, type TokenProvider, type TokenSessionReport, TokenTelemetryEngine, type ToolDefinition, type ToolRoute, type ToolTokenBreakdown, type TopologyProbeOptions, type TopologyProbeResult, type TransportProvider, VERIFICATION_LATENCY_BUDGET_MS, WasiSandbox, authorizeRequest, buildProtectedResourceMetadata, calculateAstInstructionFuel, createOAuthServer, createSyncTokenEstimator, createTokenEstimator, decodeFrames, defaultTracer, deserializeGrothProof, deserializeVKey, dispatchGrpcWebRequest, egressBlocksTotal, encodeDataFrame, encodeTrailerFrame, fuelConsumed, generateSystemInstructions, getDefaultEnvironment, isGrpcWebRequest, manifestCacheSize, meshPeersConnected, operationDurationMs, pqcHandshakeDurationMs, pqcHandshakesTotal, probeTopology, protocolMetrics, serializeGrothProof, serializeVKey, tokensInputTotal, tokensOutputTotal, tokensSavedTotal, toolCallErrorsTotal, toolCallsTotal, verifyGroth16Proof, wireEgressBytesTotal, wireSavedBytesTotal, zkProofsByTypeTotal, zkProvingDurationMs, zkVerificationDurationMs, zkVerificationsTotal, zkVkeyCacheSize };