@terminals-tech/sdk 1.0.0-rc.1

package/dist/index.d.cts

@@ -0,0 +1,3548 @@
+import { JSONSchema7 } from 'json-schema';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+/**
+ * Delegation Primitive — Cross-surface/cross-agent work flow edges
+ *
+ * Part of the D/L/R (Delegate/Lease/Refine) interaction primitive system.
+ * Encodes directed work flow from one surface/agent to another.
+ *
+ * Grounded in Lafont's constructor (gamma) combinator —
+ * builds structure by creating new agent/surface bindings.
+ *
+ * @module core/primitives/delegation
+ */
+/**
+ * All surfaces in the workspace — aligned with NavigationRail WorkspaceMode.
+ */
+declare const SURFACE_IDS: readonly ["chat", "compose", "whiteboard", "world", "skills", "generate", "lobby"];
+type SurfaceId = (typeof SURFACE_IDS)[number];
+/** Endpoint in a delegation — a surface with optional item/agent specificity. */
+interface DelegationEndpoint<S = SurfaceId> {
+    surface: S;
+    itemId?: string;
+    agentId?: string;
+}
+/**
+ * A directed edge representing work flowing from one surface/agent to another.
+ *
+ * Every "Continue with Zero" button, every "Send to Compose" action,
+ * every persona switch is a DelegationEdge.
+ */
+interface DelegationEdge<S = SurfaceId, T = SurfaceId> {
+    /** Unique identifier (format: del_<uuid>) */
+    id: string;
+    /** Source endpoint */
+    from: DelegationEndpoint<S>;
+    /** Target endpoint */
+    to: DelegationEndpoint<T>;
+    /** Arbitrary payload carried across the delegation */
+    payload: unknown;
+    /** Links to L3 interaction-store for audit trail */
+    interactionId?: string;
+    /** AMB strategy for delegation resolution */
+    strategy?: "amb" | "race" | "explore" | "fallback";
+    /** Creation timestamp (Unix ms) */
+    createdAt: number;
+}
+/** Input for creating a DelegationEdge (id and createdAt are auto-generated). */
+type DelegationEdgeInput<S = SurfaceId, T = SurfaceId> = Omit<DelegationEdge<S, T>, "id" | "createdAt">;
+/**
+ * A linked sequence of delegation edges forming a workflow path.
+ *
+ * Inspired by Google Interactions API `previous_interaction_id` pattern.
+ * Tracks how work flows across surfaces within a session.
+ */
+interface DelegationChain {
+    /** Unique identifier (format: dch_<uuid>) */
+    id: string;
+    /** Ordered edges in the chain */
+    edges: DelegationEdge[];
+    /** The root interaction this chain belongs to */
+    rootInteractionId: string;
+    /** The surface the chain currently points to (last edge's `to`) */
+    currentSurface: SurfaceId;
+}
+declare function isValidSurfaceId(value: unknown): value is SurfaceId;
+declare function createDelegationEdge<S extends SurfaceId = SurfaceId, T extends SurfaceId = SurfaceId>(input: DelegationEdgeInput<S, T>): DelegationEdge<S, T>;
+declare function createDelegationChain(initialEdge: DelegationEdge, rootInteractionId: string): DelegationChain;
+
+/**
+ * SDK Primitives - Shared Type Definitions
+ *
+ * Minimal type definitions shared across SDK primitive modules.
+ * Part of the AXON architecture L1 (SDK Core).
+ */
+/**
+ * Metadata attached to operation results
+ */
+interface ResultMeta {
+    /** Operation duration in milliseconds */
+    duration: number;
+    /** ISO timestamp of operation completion */
+    timestamp: string;
+    /** Source identifier (function, module, service) */
+    source: string;
+    /** Optional trace ID for distributed tracing */
+    traceId?: string;
+}
+/**
+ * Task execution states
+ */
+type TaskStatus = "pending" | "running" | "completed" | "failed" | "cancelled" | "retrying";
+/**
+ * AXON architecture layers
+ *
+ * L1: SDK Core - Timeline, TemporalKV, session management
+ * L2: Platform - DAG orchestration, runners, tracing
+ * L3: Mesh Coordination - Event sourcing, convergence, matching
+ * L4: Brain Interface - Coherence, cognitive processing, swarm
+ * L5: External Protocols - MCP, A2A, ACP, Gemini
+ */
+type LayerLevel = "L1" | "L2" | "L3" | "L4" | "L5";
+/**
+ * Validated<T> - Branded type for semantically validated values
+ *
+ * Marks a value as having passed validation. The validation is
+ * performed at runtime, but the type system tracks that validation
+ * has occurred.
+ *
+ * This pattern prevents using unvalidated data in contexts that
+ * require validation, catching bugs at compile time.
+ *
+ * @typeParam T - The underlying validated type
+ *
+ * @example
+ * ```typescript
+ * function processConfig(config: Validated<Config>): void {
+ *   // Safe: config has been validated
+ * }
+ *
+ * const raw = { port: 8080 };
+ * // processConfig(raw); // Error: not Validated<Config>
+ *
+ * const validated = validated(raw);
+ * processConfig(validated); // OK
+ * ```
+ */
+type Validated<T> = T & {
+    readonly _validated: true;
+};
+/**
+ * Untrusted<T> - Branded type for untrusted/raw input values
+ *
+ * Marks a value as coming from an untrusted source (user input,
+ * external API, etc.). Must be validated before use.
+ *
+ * @typeParam T - The underlying type
+ */
+type Untrusted<T> = T & {
+    readonly _untrusted: true;
+};
+/**
+ * Mark a value as validated
+ *
+ * @param value - Value that has passed validation
+ * @returns Validated wrapper
+ */
+declare function validated<T>(value: T): Validated<T>;
+/**
+ * Remove the validation brand from a Validated<T> value
+ *
+ * Strips the `_validated` property and returns the underlying type.
+ * Use at consumption boundaries where the brand is no longer needed.
+ *
+ * @param value - Validated value to unbrand
+ * @returns The underlying value without the validation brand
+ */
+declare function unbrand<T>(value: Validated<T>): T;
+/**
+ * Mark a value as untrusted (from external source)
+ *
+ * @param value - Raw value from untrusted source
+ * @returns Untrusted wrapper
+ */
+declare function untrusted<T>(value: T): Untrusted<T>;
+
+/**
+ * SDK Message Primitives
+ *
+ * Canonical message types for all cross-layer communication.
+ * The atomic unit of communication in the terminals SDK.
+ *
+ * Part of AXON architecture L1 (SDK Core).
+ */
+
+/**
+ * SDKAddress - Universal address for any node in the SDK
+ *
+ * Format: `{layer}:{nodeType}:{nodeId}` or `{layer}:{nodeType}:{nodeId}:{userId}`
+ * Examples:
+ * - `L3:kernel:v0` - The AXON kernel
+ * - `L2:orchestrator:v0` - The orchestrator
+ * - `L4:brain:zero:user123` - Zero brain for a specific user
+ * - `L5:mcp:filesystem` - MCP filesystem server
+ */
+interface SDKAddress {
+    /** Architecture layer (L1-L5) */
+    layer: LayerLevel;
+    /** Node type identifier */
+    nodeType: string;
+    /** Node instance identifier */
+    nodeId: string;
+    /** Optional user scope */
+    userId?: string;
+}
+/**
+ * Message type discriminator
+ */
+type SDKMessageType = "command" | "query" | "event" | "response";
+/**
+ * Protocol type for external bridges
+ */
+type SDKProtocolType = "mcp" | "a2a" | "internal" | "ws" | "http";
+/**
+ * Message metadata
+ */
+interface SDKMessageMeta {
+    /** Message creation timestamp */
+    timestamp: number;
+    /** Distributed trace ID */
+    traceId: string;
+    /** Correlation ID for request/response pairing */
+    correlationId?: string;
+    /** Message priority (0=critical, 1=high, 2=normal, 3=low, 4=background) */
+    priority?: number;
+    /** Time-to-live in milliseconds */
+    ttl?: number;
+    /** Retry count */
+    retries?: number;
+    /** Session ID for context propagation */
+    sessionId?: string;
+    /** Interaction ID for multi-agent workflow aggregation */
+    interactionId?: string;
+}
+/**
+ * Protocol bridging info
+ */
+interface SDKProtocolInfo {
+    /** Protocol type */
+    type: SDKProtocolType;
+    /** Protocol version */
+    version: string;
+    /** Original message for protocol bridges */
+    originalMessage?: unknown;
+}
+/**
+ * SDKMessage<P> - The canonical message type for all SDK communication
+ *
+ * This is the high-level JSON message format used across layers.
+ * For binary/low-level communication with AXON kernel, convert using
+ * `toAxonMessage()` and `fromAxonMessage()`.
+ *
+ * @typeParam P - Payload type
+ */
+interface SDKMessage<P = unknown> {
+    /** Unique message identifier */
+    id: string;
+    /** Message type */
+    type: SDKMessageType;
+    /** Source node address */
+    source: SDKAddress;
+    /** Target node address */
+    target: SDKAddress;
+    /** Message payload */
+    payload: P;
+    /** Message metadata */
+    meta: SDKMessageMeta;
+    /** Optional protocol bridging info */
+    protocol?: SDKProtocolInfo;
+    /**
+     * Optional capability identifier for L5 protocol compatibility.
+     * Used to specify the capability being invoked (e.g., MCP tool name, A2A skill).
+     * This enables unified message handling across protocol bridges.
+     */
+    capability?: string;
+}
+
+/**
+ * Interaction Primitive - Multi-Agent Workflow Aggregation
+ *
+ * Interactions unify multi-agent workflows by aggregating messages and events
+ * via a shared interactionId. This provides:
+ * - Complete workflow audit trail
+ * - Causality tracking across agents
+ * - Semantic clustering of related operations
+ * - Replay and time-travel debugging
+ *
+ * Part of AXON architecture L1 (SDK Core).
+ *
+ * @module core/primitives/interaction
+ */
+
+/**
+ * Classification of interaction patterns.
+ *
+ * - request: A asks B to do something (single exchange)
+ * - conversation: Multi-turn dialogue between participants
+ * - collaboration: Multiple agents working together on shared goal
+ * - workflow: Orchestrated multi-step process with defined stages
+ * - observation: Read-only participation (monitoring, logging)
+ */
+type InteractionType = "request" | "conversation" | "collaboration" | "workflow" | "observation" | "generation" | "live_session" | "mutation";
+/**
+ * Lifecycle status of an interaction.
+ *
+ * - initiated: Created but not yet active
+ * - active: In progress
+ * - processing: Long-running provider operation
+ * - paused: Temporarily suspended
+ * - completed: Successfully finished
+ * - failed: Terminated with error
+ * - cancelled: User/system terminated
+ */
+type InteractionStatus = "initiated" | "active" | "processing" | "paused" | "completed" | "failed" | "cancelled";
+/**
+ * Role of a participant in an interaction.
+ *
+ * - initiator: Started the interaction
+ * - responder: Responding to initiator
+ * - observer: Read-only participant
+ * - coordinator: Orchestrating the workflow
+ */
+type ParticipantRole = "initiator" | "responder" | "observer" | "coordinator";
+/**
+ * A participant in an interaction with role and lifecycle tracking.
+ */
+interface Participant {
+    /** Universal address of the participant */
+    address: SDKAddress;
+    /** Role within the interaction */
+    role: ParticipantRole;
+    /** When participant joined (Unix ms) */
+    joinedAt: number;
+    /** When participant left (Unix ms), undefined if still active */
+    leftAt?: number;
+    /** Optional participant-specific metadata */
+    metadata?: Record<string, unknown>;
+    /** Capabilities required to participate in or fulfill this interaction */
+    requiredCapabilities?: string[];
+}
+/**
+ * A condition for workflow completion.
+ * Used to define when an interaction should transition to completed.
+ */
+interface InteractionExitCriterion {
+    /** Unique criterion identifier */
+    id: string;
+    /** Human-readable description */
+    description: string;
+    /** Expression or description of the condition */
+    condition: string;
+    /** Whether this criterion has been satisfied */
+    met: boolean;
+    /** When criterion was met (Unix ms) */
+    metAt?: number;
+}
+/**
+ * Interaction - The workflow container.
+ *
+ * Aggregates messages and events across agents via shared interactionId.
+ * Supports nesting (parent/child), context propagation, and semantic search.
+ *
+ * @typeParam TContext - Domain-specific context type
+ *
+ * @example
+ * ```typescript
+ * const interaction: Interaction<{ topic: string }> = {
+ *   id: 'int_abc-123',
+ *   type: 'conversation',
+ *   status: 'active',
+ *   participants: [
+ *     { address: agentA, role: 'initiator', joinedAt: Date.now() },
+ *     { address: agentB, role: 'responder', joinedAt: Date.now() }
+ *   ],
+ *   childIds: [],
+ *   createdAt: Date.now(),
+ *   context: { topic: 'code review' },
+ *   labels: ['anticipatory', 'pair-review'],
+ *   exitCriteria: []
+ * };
+ * ```
+ */
+interface Interaction<TContext = unknown> {
+    /** Unique identifier (format: int_<uuid>) */
+    id: string;
+    /** Interaction classification */
+    type: InteractionType;
+    /** Current lifecycle status */
+    status: InteractionStatus;
+    /** All participants in this interaction */
+    participants: Participant[];
+    /** Parent interaction ID (for nesting) */
+    parentId?: string;
+    /** Child interaction IDs (spawned sub-interactions) */
+    childIds: string[];
+    /** Creation timestamp (Unix ms) */
+    createdAt: number;
+    /** When interaction became active */
+    startedAt?: number;
+    /** When interaction completed/failed/cancelled */
+    completedAt?: number;
+    /** Domain-specific context */
+    context: TContext;
+    /** Categorical labels for filtering/analysis */
+    labels: string[];
+    /** Exit conditions for workflow completion */
+    exitCriteria: InteractionExitCriterion[];
+    /** Optional embedding for semantic search (384-dim recommended) */
+    embedding?: Float32Array;
+    /** Monotonic ordinal for strict sequencing of manifold mutations */
+    ordinal?: number;
+    /** Mathematical uncertainty/complexity of the cognitive state (UTOPIA Manifold) */
+    entropy?: number;
+    /** Derivative of attention/token generation speed over time */
+    momentum?: number;
+    /** Extensible metadata */
+    metadata?: Record<string, unknown>;
+    /** Capabilities required to participate in or fulfill this interaction */
+    requiredCapabilities?: string[];
+}
+
+/**
+ * Interaction Event Primitives - Lifecycle Event Schema
+ *
+ * Canonical event types for interaction lifecycle (creation + status transitions).
+ * Part of AXON architecture L1 (SDK Core).
+ */
+
+type InteractionLifecycleEventType = "interaction:created" | "interaction:status_changed";
+interface InteractionCreatedPayload {
+    interaction: Interaction;
+    /** Optional per-interaction sequence number (monotonic) */
+    sequence?: number;
+}
+interface InteractionStatusPayload {
+    interactionId: string;
+    from?: InteractionStatus;
+    to: InteractionStatus;
+    at: number;
+    /** Optional per-interaction sequence number (monotonic) */
+    sequence?: number;
+}
+type InteractionLifecycleEventPayload = InteractionCreatedPayload | InteractionStatusPayload;
+interface InteractionLifecycleEvent<TType extends InteractionLifecycleEventType = InteractionLifecycleEventType> {
+    type: TType;
+    payload: InteractionLifecycleEventPayload;
+}
+
+/**
+ * Interaction Lifecycle - Single Source of Truth
+ *
+ * Creates lifecycle events alongside interaction entity transitions.
+ * Part of AXON architecture L1 (SDK Core).
+ */
+
+interface InteractionCreateInput<TContext = unknown> {
+    type?: InteractionType;
+    status?: InteractionStatus;
+    context: TContext;
+    labels?: string[];
+    participants?: Array<{
+        address: SDKAddress;
+        role: "initiator" | "responder" | "observer" | "coordinator";
+        metadata?: Record<string, unknown>;
+    }>;
+    id?: string;
+    /** Parent interaction ID for hierarchy linking */
+    parentId?: string;
+}
+interface InteractionCreateResult<TContext = unknown> {
+    interaction: Interaction<TContext>;
+    events: InteractionLifecycleEvent[];
+}
+interface InteractionLifecycleOptions {
+    /** Optional per-interaction sequence number */
+    sequence?: number;
+    /** Optional override for event timestamp */
+    timestamp?: number;
+}
+declare function createInteractionWithEvents<TContext = unknown>(input: InteractionCreateInput<TContext>, options?: InteractionLifecycleOptions): InteractionCreateResult<TContext>;
+
+/**
+ * Tab Configuration for BaseHub
+ *
+ * Defines available tabs, their metadata, and helper utilities for tab management.
+ * All tabs support keyboard shortcuts and visual theming.
+ *
+ * MECE TAB DESIGN:
+ * ----------------
+ * Tabs follow Mutually Exclusive, Collectively Exhaustive (MECE) principles:
+ *
+ * ENABLED TABS (4):
+ * - Home   - System overview, primitives dashboard
+ * - Brain  - Knowledge base, data sources, accumulated context
+ * - Studio - Unified canvas: Chat + Compose + Execute (merged Zero/Compose/Orchestrate)
+ * - World  - 3D topology navigation (merged: Discover, Knowledge)
+ *
+ * DISABLED/MERGED TABS (6):
+ * - Zero        → Merged into Studio (Chat pane)
+ * - Compose     → Merged into Studio (Compose pane)
+ * - Orchestrate → Merged into Studio (Execution controls)
+ * - Discover    → Merged into World/Discover section
+ * - Monitor     → Merged into Studio/Insights panel
+ * - Knowledge   → Merged into World/Knowledge section
+ *
+ * RATIONALE:
+ * Studio unifies Chat/Compose/Orchestrate into one canvas-first abstraction.
+ * All three are complementary activities that benefit from side-by-side visibility.
+ *
+ * @see CLAUDE.md for architecture documentation
+ */
+/**
+ * Available tab identifiers
+ */
+type TabId = "home" | "brain" | "studio" | "zero" | "compose" | "orchestrate" | "discover" | "monitor" | "knowledge" | "world";
+/**
+ * Tab configuration metadata
+ */
+interface TabConfig {
+    /** Unique identifier for the tab */
+    id: TabId;
+    /** Display label for the tab */
+    label: string;
+    /** Description of tab functionality */
+    description: string;
+    /** Short label for compact UI (rail icons, mobile nav) */
+    short: string;
+    /** Icon identifier (for future UI integration) */
+    icon?: string;
+    /** Whether tab is enabled and visible */
+    enabled: boolean;
+    /** Keyboard shortcut for tab activation */
+    keyboardShortcut?: string;
+    /** Theme color for tab (hex format) */
+    color?: string;
+    /** Route href for navigation link */
+    href?: string;
+    /** Pathname patterns that activate this tab */
+    pathPatterns?: string[];
+}
+
+/**
+ * Coherence Metrics Types (L1 Core)
+ *
+ * Extracted from L4 Brains to prevent L1→L4 layer violation.
+ * These types are shared across layers for coherence measurement.
+ */
+interface CoherenceMetrics$1 {
+    /** Connection to factual/contextual reality (0-1) */
+    grounding: number;
+    /** Self-consistency of reasoning (0-1) */
+    internal: number;
+    /** Clarity and actionability of output (0-1) */
+    crystallization: number;
+    /** Overall coherence score (weighted average) */
+    overall: number;
+    /** Timestamp of measurement */
+    timestamp: number;
+}
+
+type CoherenceMetrics = CoherenceMetrics$1;
+/**
+ * Enhanced coherence result with human-readable explanations
+ */
+interface CoherenceResult extends CoherenceMetrics {
+    /** Human-readable explanations for each metric */
+    explanations: {
+        grounding: string;
+        internal: string;
+        crystallization: string;
+        overall: string;
+    };
+    /** Actionable improvement suggestions */
+    suggestions: string[];
+    /** Severity level based on overall score */
+    severity: "excellent" | "good" | "moderate" | "poor" | "critical";
+}
+interface CoherenceInput {
+    /** The agent's output text */
+    output: string;
+    /** Original context/prompt */
+    context?: string;
+    /** Previous outputs for consistency checking */
+    history?: string[];
+    /** Ground truth facts to check against */
+    groundTruth?: string[];
+}
+interface CoherenceConfig {
+    /** Weight for grounding score (default: 0.4) */
+    groundingWeight?: number;
+    /** Weight for internal consistency (default: 0.3) */
+    internalWeight?: number;
+    /** Weight for crystallization (default: 0.3) */
+    crystallizationWeight?: number;
+    /** Minimum confidence threshold (default: 0.5) */
+    minConfidence?: number;
+}
+/**
+ * Calculate overall coherence metrics
+ */
+declare function calculateCoherence(input: CoherenceInput, config?: CoherenceConfig): CoherenceMetrics;
+/**
+ * Check if coherence meets minimum threshold
+ */
+declare function isCoherent(metrics: CoherenceMetrics, minThreshold?: number): boolean;
+/**
+ * Get improvement suggestions based on metrics
+ */
+declare function getCoherenceSuggestions(metrics: CoherenceMetrics): string[];
+/**
+ * Calculate enhanced coherence with explanations
+ */
+declare function calculateCoherenceWithExplanations(input: CoherenceInput, config?: CoherenceConfig): CoherenceResult;
+
+/**
+ * Validation Primitives (IO Boundary Security)
+ *
+ * Uses Ajv for JSON Schema validation.
+ *
+ * IMPORTANT: This module is NOT compatible with Vercel Edge Runtime (Middleware)
+ * because Ajv uses `new Function()` for schema compilation. For Edge-compatible
+ * validation, use a non-eval based library or pre-compiled schemas.
+ */
+
+/**
+ * Validate untrusted data against a schema
+ *
+ * @param data - The untrusted data to validate
+ * @param schema - JSON Schema to validate against
+ * @returns Validated data or null if validation fails
+ */
+declare function validateWithSchema<T>(data: Untrusted<T>, schema: JSONSchema7 | Record<string, unknown>): Validated<T> | null;
+/**
+ * Helper to wrap and validate in one step
+ */
+declare function secureValidate<T>(data: T, schema: JSONSchema7 | Record<string, unknown>): Validated<T> | null;
+
+/**
+ * SDK Result Type - Railway-Oriented Error Handling
+ *
+ * Discriminated union type for type-safe error handling without exceptions.
+ * Inspired by Rust's Result<T, E> and functional programming patterns.
+ *
+ * Part of the AXON architecture L1 (SDK Core).
+ */
+
+/**
+ * Discriminated union representing success or failure
+ *
+ * @template T - Success value type
+ * @template E - Error type (defaults to Error)
+ *
+ * @example
+ * ```typescript
+ * const success: SDKResult<number> = ok(42);
+ * const failure: SDKResult<number> = err(new Error('failed'));
+ *
+ * if (isOk(success)) {
+ *   console.log(success.value); // Type-safe access to value
+ * }
+ * ```
+ */
+type SDKResult<T, E = Error> = {
+    ok: true;
+    value: T;
+    meta?: ResultMeta;
+} | {
+    ok: false;
+    error: E;
+    meta?: ResultMeta;
+};
+/**
+ * Create a successful result
+ *
+ * @template T - Success value type
+ * @param value - The success value
+ * @param meta - Optional metadata
+ * @returns Success result
+ *
+ * @example
+ * ```typescript
+ * const result = ok(42, {
+ *   duration: 100,
+ *   timestamp: new Date().toISOString(),
+ *   source: 'calculateAnswer'
+ * });
+ * ```
+ */
+declare function ok<T>(value: T, meta?: ResultMeta): SDKResult<T, never>;
+/**
+ * Create an error result
+ *
+ * @template E - Error type
+ * @param error - The error value
+ * @param meta - Optional metadata
+ * @returns Error result
+ *
+ * @example
+ * ```typescript
+ * const result = err(new Error('Database connection failed'), {
+ *   duration: 5000,
+ *   timestamp: new Date().toISOString(),
+ *   source: 'connectToDatabase'
+ * });
+ * ```
+ */
+declare function err<E = Error>(error: E, meta?: ResultMeta): SDKResult<never, E>;
+/**
+ * Type guard for successful results
+ *
+ * @param result - Result to check
+ * @returns True if result is Ok
+ *
+ * @example
+ * ```typescript
+ * const result = ok(42);
+ * if (isOk(result)) {
+ *   console.log(result.value); // Type narrowed to { ok: true, value: number }
+ * }
+ * ```
+ */
+declare function isOk<T, E>(result: SDKResult<T, E>): result is {
+    ok: true;
+    value: T;
+    meta?: ResultMeta;
+};
+/**
+ * Type guard for error results
+ *
+ * @param result - Result to check
+ * @returns True if result is Err
+ *
+ * @example
+ * ```typescript
+ * const result = err(new Error('failed'));
+ * if (isErr(result)) {
+ *   console.error(result.error); // Type narrowed to { ok: false, error: Error }
+ * }
+ * ```
+ */
+declare function isErr<T, E>(result: SDKResult<T, E>): result is {
+    ok: false;
+    error: E;
+    meta?: ResultMeta;
+};
+/**
+ * Map a successful result to a new value
+ *
+ * @template T - Input value type
+ * @template U - Output value type
+ * @template E - Error type
+ * @param result - Input result
+ * @param fn - Mapping function (only called if Ok)
+ * @returns Mapped result
+ *
+ * @example
+ * ```typescript
+ * const result = ok(42);
+ * const doubled = map(result, x => x * 2); // ok(84)
+ *
+ * const error = err(new Error('failed'));
+ * const mapped = map(error, x => x * 2); // err(Error('failed'))
+ * ```
+ */
+declare function map<T, U, E>(result: SDKResult<T, E>, fn: (value: T) => U): SDKResult<U, E>;
+/**
+ * Chain operations that return Results (flatMap/bind)
+ *
+ * @template T - Input value type
+ * @template U - Output value type
+ * @template E - Error type
+ * @param result - Input result
+ * @param fn - Function returning a Result (only called if Ok)
+ * @returns Flattened result
+ *
+ * @example
+ * ```typescript
+ * const parseNumber = (s: string): SDKResult<number> =>
+ *   isNaN(Number(s)) ? err(new Error('Not a number')) : ok(Number(s));
+ *
+ * const input = ok("42");
+ * const parsed = flatMap(input, parseNumber); // ok(42)
+ *
+ * const invalid = ok("xyz");
+ * const failed = flatMap(invalid, parseNumber); // err(Error('Not a number'))
+ * ```
+ */
+declare function flatMap<T, U, E>(result: SDKResult<T, E>, fn: (value: T) => SDKResult<U, E>): SDKResult<U, E>;
+/**
+ * Standard error codes for store operations
+ */
+type StoreErrorCode = "DB_ERROR" | "NOT_FOUND" | "CONFLICT" | "VALIDATION_ERROR";
+/**
+ * Store operation error
+ */
+interface StoreError {
+    code: StoreErrorCode;
+    message: string;
+    cause?: Error;
+}
+
+/**
+ * Registry primitives for type-safe key-value storage with LRU eviction and TTL expiration
+ * Part of the Terminals.tech SDK core primitives
+ */
+interface Registry<K, V> {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    size(): number;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    toArray(): V[];
+}
+interface RegistryConfig<K, V> {
+    maxSize?: number;
+    ttlMs?: number;
+    onEvict?: (key: K, value: V) => void;
+    onExpire?: (key: K, value: V) => void;
+}
+/**
+ * Factory: Basic registry with optional config
+ */
+declare function createRegistry<K, V>(config?: RegistryConfig<K, V>): Registry<K, V>;
+
+/**
+ * Node in a directed acyclic graph
+ */
+interface DAGNode<T> {
+    id: string;
+    data: T;
+}
+/**
+ * Edge connecting two nodes in a DAG
+ */
+interface DAGEdge<E = void> {
+    from: string;
+    to: string;
+    data?: E;
+}
+/**
+ * DAG validation error with specific type classification
+ */
+declare class DAGValidationError extends Error {
+    readonly type: "cycle" | "missing_node" | "duplicate_node" | "self_loop";
+    constructor(message: string, type: "cycle" | "missing_node" | "duplicate_node" | "self_loop");
+}
+/**
+ * Directed Acyclic Graph with efficient traversal and validation
+ */
+interface DAG<N, E = void> {
+    readonly nodes: ReadonlyMap<string, DAGNode<N>>;
+    readonly edges: ReadonlyArray<DAGEdge<E>>;
+    getNode(id: string): DAGNode<N> | undefined;
+    getIncoming(nodeId: string): DAGEdge<E>[];
+    getOutgoing(nodeId: string): DAGEdge<E>[];
+    getAncestors(nodeId: string): string[];
+    getDescendants(nodeId: string): string[];
+    getRoots(): string[];
+    getLeaves(): string[];
+    topologicalSort(): string[];
+    levels(): string[][];
+    bfs(startId: string, visitor: (node: DAGNode<N>) => boolean | void): void;
+    dfs(startId: string, visitor: (node: DAGNode<N>) => boolean | void): void;
+    hasCycle(): boolean;
+    validate(): SDKResult<void, DAGValidationError[]>;
+}
+/**
+ * Create a DAG with validation
+ *
+ * @param nodes - Array of nodes to include in the graph
+ * @param edges - Array of edges connecting nodes
+ * @returns Result containing the DAG or validation errors
+ *
+ * @example
+ * ```typescript
+ * const result = createDAG(
+ *   [
+ *     { id: 'a', data: { value: 1 } },
+ *     { id: 'b', data: { value: 2 } },
+ *     { id: 'c', data: { value: 3 } }
+ *   ],
+ *   [
+ *     { from: 'a', to: 'b' },
+ *     { from: 'b', to: 'c' }
+ *   ]
+ * )
+ *
+ * if (result.ok) {
+ *   const sorted = result.value.topologicalSort() // ['a', 'b', 'c']
+ *   const levels = result.value.levels() // [['a'], ['b'], ['c']]
+ * }
+ * ```
+ */
+declare function createDAG<N, E = void>(nodes: DAGNode<N>[], edges: DAGEdge<E>[]): SDKResult<DAG<N, E>, DAGValidationError[]>;
+
+/**
+ * Unified SDK Types
+ *
+ * Canonical type definitions for the Terminals.tech SDK.
+ * Isomorphic types that work across browser/server/edge/webcontainer environments.
+ *
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ *
+ * Type Organization:
+ * - Environment & Config
+ * - Storage Adapters
+ * - HTTP Client
+ * - LLM Providers
+ * - MCP (Model Context Protocol)
+ * - Authentication
+ * - Runners (code execution)
+ * - Context Injection
+ * - Events & Graphs
+ * - Embeddings
+ * - Observer-Oriented OOP Primitives (Observable pattern)
+ * - Layer-specific state types (Execution, Reasoning, Connection)
+ *
+ * @module sdk-types
+ */
+
+interface NodePolicy$1 {
+    fs?: {
+        mode?: "sandboxed" | "full";
+        allowedPaths?: string[];
+    };
+    network?: {
+        egress?: "ask" | "deny" | "allow:list";
+        allowList?: string[];
+    };
+}
+interface StackPolicies$1 {
+    fs?: {
+        mode?: "sandboxed" | "full";
+        allowedPaths?: string[];
+    };
+    network?: {
+        egress?: "ask" | "deny" | "allow:list";
+        allowList?: string[];
+    };
+}
+
+/**
+ * Phase Dynamics Primitives
+ *
+ * Minimal utilities for coupled-oscillator dynamics and synchronization metrics.
+ * Intended for L1 use by L3 mesh metrics, L4 brains (swarm), and L2 nodes.
+ */
+interface OrderParameter {
+    /** Synchronization magnitude (0..1) */
+    R: number;
+    /** Collective phase (radians, -π..π) */
+    psi: number;
+}
+declare function wrapTo2Pi(theta: number): number;
+declare function wrapToPi(theta: number): number;
+/**
+ * Kuramoto order parameter:
+ * R e^{iψ} = (1/N) Σ e^{iθ_j}
+ */
+declare function orderParameter(phases: ArrayLike<number>): OrderParameter;
+/**
+ * Phase Locking Value (PLV) between two phase time-series:
+ * PLV = |⟨exp(i(φ_a - φ_b))⟩|
+ */
+declare function phaseLockingValue(phiA: ArrayLike<number>, phiB: ArrayLike<number>): number;
+interface KuramotoStepOptions {
+    /**
+     * If true, wraps resulting phases to [-π, π) (default: true).
+     * When false, phases are allowed to drift unbounded.
+     */
+    wrap?: boolean;
+    /**
+     * If true, normalize coupling by per-node degree (default: true).
+     * Stabilizes dynamics across heterogeneous adjacency.
+     */
+    normalizeCoupling?: boolean;
+}
+/**
+ * Advance one Euler step of Kuramoto dynamics:
+ * dθ_i/dt = ω_i + K * Σ_j A_ij sin(θ_j - θ_i)
+ *
+ * - If `adjacency` is undefined, assumes all-to-all coupling (excluding self).
+ * - If `omega` is a scalar, uses the same ω for all oscillators.
+ *
+ * Returns a new Float32Array (pure; does not mutate the input phases).
+ */
+declare function kuramotoStep(phases: ArrayLike<number>, omega: ArrayLike<number> | number, K: number, adjacency: ArrayLike<ArrayLike<number>> | undefined, dt: number, opts?: KuramotoStepOptions): Float32Array;
+
+/**
+ * EventBus - Type-safe event emitter pattern
+ *
+ * Unified event infrastructure for Terminals.tech.
+ * Supports both generic pub/sub and layer-aware AXON signals.
+ *
+ * @example
+ * ```typescript
+ * // Define event types
+ * type MyEvents = {
+ *   'user:login': { userId: string; timestamp: number }
+ *   'user:logout': { userId: string }
+ *   'error': Error
+ * }
+ *
+ * // Create typed bus
+ * const bus = createEventBus<MyEvents>()
+ *
+ * // Subscribe with type safety
+ * const unsub = bus.on('user:login', (payload) => {
+ *   console.log(payload.userId) // TypeScript knows this is string
+ * })
+ *
+ * // Emit with type checking
+ * bus.emit('user:login', { userId: '123', timestamp: Date.now() })
+ *
+ * // Clean up
+ * unsub()
+ * ```
+ */
+
+/**
+ * Signal types for cross-layer communication
+ */
+type SignalType = "health_update" | "circuit_change" | "convergence_update" | "coherence_update" | "resonance_update" | "tensor_state_update" | "task_complete" | "task_failed" | "adaptation_required" | "backpressure_warning" | "audio_metrics_update" | "mesh_update" | "mesh_query" | "session_state_change" | "skill_capture_started" | "skill_action_recorded" | "skill_capture_completed" | "skill_crystallized" | "skill_training_started" | "skill_training_completed" | "skill_artifact_activated" | "skill_suggested" | "skill_executed" | "skill_peer_review" | "skill_delegation" | "skill_agent_refine" | "skill_selection" | "skill_backpressure" | "skill_budget_exceeded" | "skill_error" | "interaction_created" | "interaction_status_changed" | "deploy_scaffold" | "deploy_push" | "deploy_build" | "deploy_status" | "deploy_preview" | "deploy_live" | "deploy_error" | "potentiation_rising" | "potentiation_peak" | "potentiation_discharge" | "potentiation_reset" | "action_dispatched" | "action_executed" | "action_failed" | "combo_completed" | "input_surface_changed" | "forge_scene_saved" | "forge_iteration_recorded" | "forge_profile_crystallized" | "forge_profile_requested" | "integration_connected" | "integration_disconnected" | "integration_heartbeat" | "integration_error" | "ui_navigation" | "ui_surface_opened" | "ui_surface_closed" | "ui_interaction" | "ui_error_shown" | "ui_search" | "artifact_preview" | "manifold_node_added" | "manifold_edge_added" | "manifold_query" | "manifold_snapshot" | "connector_status_changed" | "connector_sync_started" | "connector_sync_complete" | "connector_sync_error" | "connector_document_indexed" | "graph_entity_upserted" | "graph_relationship_added" | "graph_traversal_complete" | "intent_signal_emitted" | "oscillator_phase_updated" | "oscillator_suggestion_generated" | "journey_note_created" | "journey_note_deleted" | "journey_edge_created" | "journey_cluster_created" | "journey_replay_entered" | "journey_replay_exited" | "journey_spatial_navigate" | "journey_completed" | "boundary_crossed" | "boundary_sealed" | "convergence_declared" | "convergence_lost" | "crystallization_declared" | "crystallization_melted" | "chat_message_sent" | "chat_message_received" | "chat_error" | "coherence_gate_accepted" | "coherence_gate_rejected" | "manifold_geodesic_computed" | "manifold_distance_measured" | "sematon_created" | "sematon_witnessed" | "sematon_folded" | "sematon_realized" | "sematon_expired";
+/**
+ * Layer-aware signal for AXON cross-layer communication
+ */
+interface Signal<T = unknown> {
+    id: string;
+    type: SignalType;
+    source: LayerLevel;
+    target: LayerLevel;
+    payload: T;
+    timestamp: number;
+    correlationId?: string;
+    /** Interaction ID for causal chain tracking across the AXON signal flow */
+    interactionId?: string;
+}
+/**
+ * Handler for layer-aware signals
+ */
+interface SignalHandler<T = unknown> {
+    (signal: Signal<T>): void | Promise<void>;
+}
+type EventHandler<T> = (payload: T) => void | Promise<void>;
+type WildcardHandler<Events> = <K extends keyof Events>(event: K, payload: Events[K]) => void | Promise<void>;
+interface TypedEventBus<Events extends Record<string, unknown>> {
+    /**
+     * Subscribe to an event
+     * @returns Unsubscribe function
+     */
+    on<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): () => void;
+    /**
+     * Subscribe to an event for a single emission
+     * @returns Unsubscribe function
+     */
+    once<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): () => void;
+    /**
+     * Unsubscribe from an event
+     */
+    off<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): void;
+    /**
+     * Emit an event to all subscribers
+     */
+    emit<K extends keyof Events>(event: K, payload: Events[K]): void;
+    /**
+     * Emit and wait for all async handlers
+     */
+    emitAsync<K extends keyof Events>(event: K, payload: Events[K]): Promise<void>;
+    /**
+     * Subscribe to all events
+     * @returns Unsubscribe function
+     */
+    onAny(handler: WildcardHandler<Events>): () => void;
+    /**
+     * Remove all listeners for an event, or all listeners
+     */
+    removeAllListeners<K extends keyof Events>(event?: K): void;
+    /**
+     * Get listener count for an event
+     */
+    listenerCount<K extends keyof Events>(event: K): number;
+    /**
+     * Get all registered event names
+     */
+    eventNames(): Array<keyof Events>;
+}
+/**
+ * Create a type-safe event bus
+ */
+declare function createEventBus<Events extends Record<string, unknown>>(): TypedEventBus<Events>;
+type Unsubscribe = () => void;
+/**
+ * SignalBus interface for AXON cross-layer communication
+ */
+interface SignalBus {
+    /**
+     * Emit a signal to all matching subscribers
+     */
+    emit<T>(type: SignalType, source: LayerLevel, target: LayerLevel, payload: T, correlationId?: string, interactionId?: string): Signal<T>;
+    /**
+     * Subscribe to signals matching criteria
+     */
+    subscribe(type: SignalType | "*", handler: SignalHandler, options?: {
+        sourceLayer?: LayerLevel;
+        targetLayer?: LayerLevel;
+    }): Unsubscribe;
+    /**
+     * Subscribe to signals from a specific layer
+     */
+    subscribeFromLayer(layer: LayerLevel, handler: SignalHandler): Unsubscribe;
+    /**
+     * Subscribe to signals targeting a specific layer
+     */
+    subscribeToLayer(layer: LayerLevel, handler: SignalHandler): Unsubscribe;
+    /**
+     * Get recent signals for debugging
+     */
+    getRecentSignals(count?: number): Signal[];
+    /**
+     * Get signals by correlation ID
+     */
+    getCorrelated(correlationId: string): Signal[];
+    /**
+     * Clear all subscriptions (for testing)
+     */
+    clearSubscriptions(): void;
+    /**
+     * Clear signal log (for testing)
+     */
+    clearLog(): void;
+}
+/**
+ * Create a layer-aware signal bus for AXON cross-layer communication
+ */
+declare function createSignalBus(maxLogSize?: number): SignalBus;
+/**
+ * Get or create the global signal bus instance
+ */
+declare function getSignalBus(): SignalBus;
+/**
+ * Convenience: Emit a signal on the global bus
+ */
+declare function emitSignal<T>(type: SignalType, source: LayerLevel, target: LayerLevel, payload: T, correlationId?: string, interactionId?: string): Signal<T>;
+/**
+ * Convenience: Subscribe to signals on the global bus
+ */
+declare function subscribeToSignals(type: SignalType | "*", handler: SignalHandler, options?: {
+    sourceLayer?: LayerLevel;
+    targetLayer?: LayerLevel;
+}): Unsubscribe;
+
+/**
+ * NeuroState - Unified Brain State Management
+ *
+ * Centralizes all cognitive signals (Coherence, Convergence, Load) into a single
+ * source of truth that drives the Computer Construct experience.
+ *
+ * Bridges the "Internal" (Coherence) with the "External" (Convergence/Mesh)
+ * to derive high-level "Mood" and system responsiveness.
+ */
+
+type SystemMood = "dormant" | "focused" | "flow" | "chaotic" | "overloaded";
+
+/**
+ * Real-time audio metrics from frequency analysis
+ */
+interface AudioMetrics {
+    /** Low frequency energy (bass) normalized 0-1 */
+    bass: number;
+    /** High frequency energy normalized 0-1 */
+    high: number;
+    /** Spectral centroid / brightness normalized 0-1 */
+    brightness: number;
+    /** Spectral entropy / chaos measure normalized 0-1 */
+    entropy: number;
+    /** Raw frequency bin data */
+    raw: Uint8Array;
+}
+
+/**
+ * L1 AudioSource — Omniprovider audio source abstraction
+ *
+ * Every audio source (playlist, generative, Lyria, external, DAW) implements
+ * this interface. SemanticOscillator provides Kuramoto-compatible phase coupling
+ * between audio parameters and app state signals.
+ */
+
+/** Continuous parameter with Kuramoto phase coupling */
+interface SemanticOscillator {
+    readonly name: string;
+    value: number;
+    set(v: number): void;
+    /** Kuramoto coupling: dv = K * sin(target - self) */
+    couple(targetPhase: number, strength: number): void;
+}
+/** Unified audio source interface — any provider, same shape */
+interface AudioSource {
+    readonly id: string;
+    readonly type: "playlist" | "generative" | "lyria" | "external" | "daw";
+    connect(destination: AudioNode): void;
+    disconnect(): void;
+    getMetrics(): AudioMetrics | null;
+    play(): Promise<void>;
+    pause(): void;
+    dispose(): void;
+    readonly oscillators: ReadonlyMap<string, SemanticOscillator>;
+}
+/** Platform-level audio configuration */
+interface AudioSourceConfig {
+    defaultSource: AudioSource["type"];
+    generativePreset?: {
+        root: number;
+        harmonicSeries: number[];
+        filterCutoff: number;
+        reverbWet: number;
+    };
+    lyriaPreset?: {
+        temperature: number;
+        guidance: number;
+        genreMix: Record<string, number>;
+        density: number;
+        brightness: number;
+    };
+    couplingStrength?: number;
+    entrainmentMode?: string;
+}
+
+/**
+ * Platform Configuration Types
+ *
+ * Each product powered by Terminals OS provides a PlatformConfig
+ * that customizes the workspace shell (NavigationRail, ContextBar,
+ * theme colors, identity).
+ *
+ * @module platform/types
+ */
+
+interface PlatformIdentity {
+    /** Unique platform identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** One-line tagline */
+    tagline: string;
+    /** Attribution line */
+    poweredBy: string;
+    /** Production domain for this platform (e.g. "pathfind.tech"). Omit for root OS. */
+    domain?: string;
+    /** Path for cross-domain auth handoff (e.g. "/auth/handoff"). Required when domain is set. */
+    handoffPath?: string;
+}
+/** Surface appearance tokens for glassmorphic UI */
+interface SurfaceTokens {
+    /** Page void background (hex, e.g. "#020303") */
+    void: string;
+    /** Card/panel background (CSS value, e.g. "rgba(255,255,255,0.03)") */
+    cardBg: string;
+    /** Default border (CSS value) */
+    border: string;
+    /** Hover border (CSS value) */
+    borderHover: string;
+    /** Backdrop blur class (e.g. "backdrop-blur-md") */
+    blur: string;
+    /** Selection background (hex) */
+    selectionBg: string;
+    /** Selection text (hex) */
+    selectionText: string;
+}
+/** Animation timing presets */
+interface AnimationTokens {
+    /** Crystallize reveal duration per element (ms) */
+    crystallizeDuration: number;
+    /** Stagger delay between elements (ms) */
+    staggerDelay: number;
+    /** Border rotation speed (s) */
+    borderSpinDuration: number;
+    /** Breathing/pulse cycle (s) */
+    breatheDuration: number;
+    /** Edge pulse cycle (s) */
+    edgePulseDuration: number;
+    /** GSAP scrub smoothing (0-1) */
+    scrubSmoothing: number;
+}
+interface PlatformTheme {
+    /** Primary accent color (hex) */
+    accent: string;
+    /** Glow variant for dark backgrounds (hex) */
+    accentGlow: string;
+    /** Optional per-layer color overrides */
+    layerOverrides?: Partial<Record<"L1" | "L2" | "L3" | "L4" | "L5", string>>;
+    /** Surface appearance tokens */
+    surfaces?: SurfaceTokens;
+    /** Animation timing tokens */
+    animations?: AnimationTokens;
+}
+interface QuickAction {
+    label: string;
+    icon: string;
+    href: string;
+    layer: "L1" | "L2" | "L3" | "L4" | "L5";
+}
+interface AmbientFieldConfig {
+    particleCount: number;
+    colors: string[];
+    connectionDistance: number;
+    connectionOpacity: number;
+    particleOpacity: number;
+    particleSize: [number, number];
+    fps: number;
+}
+interface DashboardConfig {
+    kpiRefreshMs?: number;
+    insightRefreshMs?: number;
+    showPipeline?: boolean;
+    showAmbientStrip?: boolean;
+}
+interface LobbyConfig {
+    ambientField?: AmbientFieldConfig;
+    shaderOpacity?: number;
+    showIntelligencePulse?: boolean;
+    quickActions?: QuickAction[];
+    moodToShaderMode?: Partial<Record<SystemMood, string>>;
+    dashboard?: DashboardConfig;
+}
+interface PlatformConfig {
+    identity: PlatformIdentity;
+    theme: PlatformTheme;
+    /** Override enabled tabs — merged with global TAB_CONFIGS */
+    tabOverrides?: Partial<Record<TabId, Partial<TabConfig>>>;
+    /** Landing page component path for dynamic import */
+    landingComponent?: string;
+    /** Lobby/home tab configuration */
+    lobby?: LobbyConfig;
+    /** Audio source configuration for this platform */
+    audio?: AudioSourceConfig;
+}
+
+/**
+ * Terminal SDK — High-level Terminal management
+ *
+ * Simplified API for terminal identity, interactions, and lifecycle.
+ * Hides Machine, Brain, Interface, MeshCoordinator, A2A, MCP internals.
+ *
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module sdk/terminal
+ */
+
+type terminal_Interaction<TContext = unknown> = Interaction<TContext>;
+type terminal_InteractionStatus = InteractionStatus;
+type terminal_InteractionType = InteractionType;
+type terminal_LayerLevel = LayerLevel;
+type terminal_PlatformConfig = PlatformConfig;
+type terminal_PlatformIdentity = PlatformIdentity;
+type terminal_PlatformTheme = PlatformTheme;
+type terminal_SurfaceId = SurfaceId;
+type terminal_TaskStatus = TaskStatus;
+declare const terminal_createInteractionWithEvents: typeof createInteractionWithEvents;
+declare namespace terminal {
+  export { type terminal_Interaction as Interaction, type terminal_InteractionStatus as InteractionStatus, type terminal_InteractionType as InteractionType, type terminal_LayerLevel as LayerLevel, type terminal_PlatformConfig as PlatformConfig, type terminal_PlatformIdentity as PlatformIdentity, type terminal_PlatformTheme as PlatformTheme, type terminal_SurfaceId as SurfaceId, type terminal_TaskStatus as TaskStatus, createInteractionWithEvents as createInteraction, terminal_createInteractionWithEvents as createInteractionWithEvents };
+}
+
+/**
+ * RetryStrategy - Unified retry pattern for async operations
+ *
+ * ## Architectural Note
+ *
+ * This module (base/retry.ts) provides **direct async wrappers** for imperative patterns.
+ * It is intentionally distinct from primitives/middleware.ts which provides
+ * **functional middleware composition** with the Middleware<T, R> type.
+ *
+ * The distinction serves different use cases:
+ * - **base/retry.ts**: Direct function wrapping for imperative code
+ *   - `withRetry(fn, strategy)` - wraps and executes immediately
+ *   - `retryable(fn, strategy)` - returns a retry-wrapped function
+ *   - `createCircuitBreaker(options)` - stateful circuit breaker instance
+ *
+ * - **primitives/middleware.ts**: Composable middleware chains
+ *   - `compose(...middlewares)` - functional composition
+ *   - `withResilience(config)` - declarative resilience configuration
+ *   - Designed for pipeline-style processing
+ *
+ * Both are valid patterns for different contexts. Do not force unification.
+ *
+ * @example
+ * ```typescript
+ * // Use exponential backoff
+ * const result = await withRetry(
+ *   () => fetch('/api/data'),
+ *   exponentialBackoff({ maxAttempts: 3, baseDelayMs: 100 })
+ * )
+ *
+ * // Custom strategy
+ * const customStrategy: RetryStrategy = {
+ *   maxAttempts: 5,
+ *   baseDelayMs: 200,
+ *   maxDelayMs: 5000,
+ *   shouldRetry: (error, attempt) => error.message !== 'unauthorized'
+ * }
+ * ```
+ */
+interface RetryStrategy {
+    /** Maximum number of attempts (including initial) */
+    maxAttempts: number;
+    /** Initial delay between retries in milliseconds */
+    baseDelayMs: number;
+    /** Maximum delay cap in milliseconds */
+    maxDelayMs: number;
+    /** Function to determine if retry should occur */
+    shouldRetry: (error: Error, attempt: number) => boolean;
+    /** Optional jitter factor (0-1) to randomize delays */
+    jitter?: number;
+}
+interface RetryOptions {
+    /** Override max attempts */
+    maxAttempts?: number;
+    /** Override base delay */
+    baseDelayMs?: number;
+    /** Override max delay */
+    maxDelayMs?: number;
+    /** Add jitter (0-1) */
+    jitter?: number;
+    /** Custom retry condition */
+    shouldRetry?: (error: Error, attempt: number) => boolean;
+    /** Callback on each retry */
+    onRetry?: (error: Error, attempt: number, delayMs: number) => void;
+    /** Abort signal to cancel retries */
+    signal?: AbortSignal;
+}
+/**
+ * Execute an async operation with retry logic
+ */
+declare function withRetry<T>(fn: () => Promise<T>, strategyOrOptions?: RetryStrategy | Partial<RetryOptions>): Promise<T>;
+/**
+ * Circuit breaker state
+ */
+interface CircuitBreakerState {
+    failures: number;
+    lastFailure: number | null;
+    isOpen: boolean;
+    nextAttempt: number | null;
+}
+interface CircuitBreakerOptions {
+    /** Number of failures before opening circuit */
+    failureThreshold: number;
+    /** Time to wait before attempting to close circuit (ms) */
+    resetTimeoutMs: number;
+    /** Optional: half-open state allows limited requests */
+    halfOpenRequests?: number;
+}
+/**
+ * Create a circuit breaker for protecting against cascading failures
+ */
+declare function createCircuitBreaker(options: CircuitBreakerOptions): {
+    /**
+     * Execute function with circuit breaker protection.
+     *
+     * States:
+     *   CLOSED  — failures < threshold, all requests pass through
+     *   OPEN    — failures >= threshold, fast-fails until resetTimeoutMs elapses
+     *   HALF_OPEN — resetTimeoutMs elapsed, allows `halfOpenRequests` concurrent probes
+     *
+     * Transitions:
+     *   T1: CLOSED → CLOSED (success resets failures)
+     *   T2: CLOSED → OPEN   (failure hits threshold)
+     *   T3: OPEN   → OPEN   (fast-fail, time not elapsed)
+     *   T4: OPEN   → HALF_OPEN (time elapsed, probe allowed)
+     *   T5: HALF_OPEN → CLOSED (probe succeeds)
+     *   T6: HALF_OPEN → OPEN   (probe fails)
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Get current state
+     */
+    getState(): Readonly<CircuitBreakerState>;
+    /**
+     * Manually reset the circuit breaker
+     */
+    reset(): void;
+};
+
+type NodePolicy = NodePolicy$1;
+type StackPolicies = StackPolicies$1;
+/**
+ * Runtime tier for node execution.
+ *
+ * Defines the execution environment for computational nodes:
+ * - `worker`: Web Worker/service worker
+ * - `container-lite`: Lightweight containerized runtime
+ * - `webcontainer`: Browser-based container (WebAssembly)
+ * - `edge`: Edge function/serverless
+ * - `wasm-hvm`: WebAssembly with HVM (Higher-order Virtual Machine)
+ * - `stack`: Nested stack execution
+ *
+ * @example
+ * const tier: RuntimeTier = "worker";
+ */
+type RuntimeTier = "worker" | "container-lite" | "webcontainer" | "edge" | "wasm-hvm" | "stack";
+/**
+ * Secret reference for node execution.
+ *
+ * Links a secret from the vault into node environment.
+ *
+ * @example
+ * const secret: NodeSecretRef = {
+ *   name: "api_key",
+ *   scope: "stack",
+ *   env: "OPENAI_API_KEY",
+ *   required: true
+ * };
+ */
+interface NodeSecretRef {
+    /** Secret identifier in vault */
+    name: string;
+    /** Resolution scope: node-local or stack-wide */
+    scope: "node" | "stack";
+    /** Environment variable name (defaults to name if omitted) */
+    env?: string;
+    /** Whether secret must exist (default: false) */
+    required?: boolean;
+}
+/**
+ * Runtime-specific entrypoints for node execution.
+ *
+ * Each runtime tier has its own entrypoint format.
+ * At least one entrypoint must be specified.
+ *
+ * @example
+ * const entrypoints: NodeEntrypoints = {
+ *   worker: { module: "./transform.js", export: "transform" },
+ *   edge: { endpoint: "https://api.example.com/process" }
+ * };
+ */
+interface NodeEntrypoints {
+    /** Web Worker entrypoint */
+    worker?: {
+        module: string;
+        export?: string;
+    };
+    /** Container-lite entrypoint */
+    "container-lite"?: {
+        command: string;
+        args?: string[];
+        cwd?: string;
+    };
+    /** WebContainer entrypoint */
+    webcontainer?: {
+        command: string;
+        args?: string[];
+        cwd?: string;
+    };
+    /** WASM HVM entrypoint */
+    "wasm-hvm"?: {
+        module: string;
+        function?: string;
+    };
+    /** Edge function entrypoint */
+    edge?: {
+        endpoint: string;
+    };
+}
+/**
+ * Base manifest fields shared by nodes and stacks.
+ *
+ * @internal
+ */
+interface BaseManifestV0 {
+    /** Unique identifier (must be stable across versions) */
+    id: string;
+    /** Semantic version (e.g., "1.0.0") */
+    version: string;
+    /** Human-readable name */
+    name?: string;
+    /** Description of functionality */
+    description?: string;
+    /** Security and resource policies */
+    policies?: NodePolicy | StackPolicies;
+    /** Arbitrary metadata for extensions */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Node manifest for DAG orchestrator.
+ *
+ * Defines a single computational node in a workflow.
+ * Nodes are atomic execution units with typed inputs/outputs.
+ *
+ * @example
+ * const node: NodeManifestV0 = {
+ *   id: "llm-transform",
+ *   version: "1.0.0",
+ *   kind: "transform",
+ *   runtimes: ["worker", "edge"],
+ *   entrypoints: {
+ *     worker: { module: "./llm.js", export: "transform" }
+ *   },
+ *   inputsSchema: {
+ *     type: "object",
+ *     properties: {
+ *       prompt: { type: "string" }
+ *     },
+ *     required: ["prompt"]
+ *   },
+ *   outputsSchema: {
+ *     type: "object",
+ *     properties: {
+ *       text: { type: "string" }
+ *     }
+ *   }
+ * };
+ */
+interface NodeManifestV0 extends BaseManifestV0 {
+    /** Node type classification */
+    kind: "prompt" | "mcp" | "task" | "transform" | "webhook" | "custom";
+    /** UI label override */
+    label?: string;
+    /** Supported runtime tiers (in priority order) */
+    runtimes: RuntimeTier[];
+    /** Runtime-specific execution entrypoints */
+    entrypoints: NodeEntrypoints;
+    /** JSON Schema for input validation */
+    inputsSchema?: JSONSchema7;
+    /** JSON Schema for output validation */
+    outputsSchema?: JSONSchema7;
+    /** Declared capabilities (e.g., "network", "filesystem") */
+    capabilities?: string[];
+    /** Secret references required by this node */
+    secrets?: NodeSecretRef[];
+    /** Lifecycle hooks for instrumentation */
+    hooks?: {
+        explain?: string;
+        debug?: string;
+        askInput?: string;
+    };
+    /** UI configuration */
+    ui?: {
+        /** Node-specific UI config */
+        config?: unknown;
+        /** Output viewer configuration */
+        viewer?: {
+            kind?: "text" | "table" | "json" | "custom";
+            componentId?: string;
+        };
+    };
+    /** MCP server integration */
+    mcp?: {
+        /** MCP server identifier */
+        server?: string;
+        /** Exposed MCP tools */
+        tools?: Array<{
+            name: string;
+            schema?: JSONSchema7;
+        }>;
+    };
+    /** Observability configuration */
+    observability?: {
+        /** Emit execution logs */
+        emitLogs?: boolean;
+        /** Emit output artifacts */
+        emitArtifacts?: boolean;
+        /** Trace attribute keys to capture */
+        traceAttributes?: string[];
+    };
+}
+/**
+ * Stack-level secret scope definition.
+ *
+ * Defines which nodes can access a secret.
+ *
+ * @example
+ * const secretScope: StackSecretScope = {
+ *   scope: ["fetch-node", "transform-node"],
+ *   required: true
+ * };
+ */
+interface StackSecretScope {
+    /** Node IDs that can access this secret */
+    scope: string[];
+    /** Whether secret must exist */
+    required?: boolean;
+}
+/**
+ * Stack-level runtime tier configuration.
+ *
+ * Allows stack-wide defaults with per-node overrides.
+ *
+ * @example
+ * const runtimes: StackRuntimes = {
+ *   default: ["worker", "edge"],
+ *   overrides: {
+ *     "heavy-compute": ["container-lite"]
+ *   }
+ * };
+ */
+interface StackRuntimes {
+    /** Default runtime tiers for all nodes */
+    default?: RuntimeTier[];
+    /** Per-node runtime tier overrides (nodeId -> tiers) */
+    overrides?: Record<string, RuntimeTier[]>;
+}
+/**
+ * Node configuration within a stack.
+ *
+ * References a node manifest and provides instance-specific config.
+ *
+ * @example
+ * const nodeConfig: StackNodeConfig = {
+ *   id: "fetch-1",
+ *   nodeRef: "http-fetch",
+ *   config: { timeout: 5000 },
+ *   runtimes: ["edge"],
+ *   secrets: ["api_key"]
+ * };
+ */
+interface StackNodeConfig {
+    /** Unique ID within stack */
+    id: string;
+    /** Reference to NodeManifestV0.id */
+    nodeRef: string;
+    /** Node-specific configuration */
+    config?: Record<string, unknown>;
+    /** Runtime tier override */
+    runtimes?: RuntimeTier[];
+    /** Security policy override */
+    policies?: NodePolicy;
+    /** Secret names from stack.secrets */
+    secrets?: string[];
+}
+/**
+ * Directed edge connecting two nodes in the stack DAG.
+ *
+ * Defines data flow from one node's outputs to another's inputs.
+ *
+ * @example
+ * const edge: StackEdge = {
+ *   from: "fetch-1",
+ *   to: "transform-1",
+ *   map: { "data": "input" }
+ * };
+ */
+interface StackEdge {
+    /** Source node ID */
+    from: string;
+    /** Target node ID */
+    to: string;
+    /** Output-to-input key mapping (defaults to identity) */
+    map?: Record<string, string>;
+}
+/**
+ * Manifest layer provenance.
+ *
+ * - `L0`: Landing/Zero layer (low-level primitives)
+ * - `L1`: Compose/Platform layer (higher-level abstractions)
+ */
+type ManifestLayer = "L0" | "L1" | "L2" | "L3" | "L4" | "L5";
+/**
+ * Stack manifest for DAG orchestrator.
+ *
+ * Defines a complete workflow as a directed acyclic graph (DAG) of nodes.
+ *
+ * @example
+ * const stack: StackManifestV0 = {
+ *   id: "data-pipeline",
+ *   version: "1.0.0",
+ *   nodes: [
+ *     { id: "fetch", nodeRef: "http-fetch", config: { url: "..." } },
+ *     { id: "transform", nodeRef: "llm-transform" }
+ *   ],
+ *   edges: [
+ *     { from: "fetch", to: "transform", map: { data: "input" } }
+ *   ],
+ *   secrets: {
+ *     api_key: { scope: ["fetch"], required: true }
+ *   }
+ * };
+ */
+interface StackManifestV0 extends BaseManifestV0 {
+    /** Node instances in this stack */
+    nodes: StackNodeConfig[];
+    /** Edges connecting nodes (data flow) */
+    edges?: StackEdge[];
+    /** Stack-level secret definitions */
+    secrets?: Record<string, StackSecretScope>;
+    /** Runtime tier configuration */
+    runtimes?: StackRuntimes;
+    /** Provenance layer (L0 or L1) */
+    layer?: ManifestLayer;
+}
+
+/**
+ * Skill Manifest Types (L1)
+ *
+ * Core types for the Skills Platform. A SkillManifest extends StackManifestV0
+ * with skill-specific metadata — a skill IS a stack with agent orchestration.
+ *
+ * @module skills/types
+ */
+
+type SkillCategory = "startup" | "legal" | "finance" | "engineering" | "content" | "research" | "operations" | "marketing" | "verification";
+type SkillOutputType = "document" | "website" | "spreadsheet" | "presentation" | "codebase" | "analysis" | "dataset" | "visual" | "video" | "audio" | "composite";
+declare const SKILL_TIERS: readonly ["flagship", "professional", "utility"];
+type SkillTier = (typeof SKILL_TIERS)[number];
+declare const SKILL_RANKS: readonly ["skill", "flow", "fleet", "org", "society"];
+type SkillRank = (typeof SKILL_RANKS)[number];
+/** Effective-dated rank assignment — immutable audit trail */
+interface RankAssignment {
+    /** Current rank */
+    rank: SkillRank;
+    /** ISO 8601 timestamp when this rank became effective */
+    effectiveFrom: string;
+    /** ISO 8601 timestamp when this rank was superseded (null = current) */
+    effectiveTo: string | null;
+    /** Evidence that promotion invariants were satisfied */
+    proof?: PromotionProof;
+}
+/**
+ * Promotion proof — the Curry-Howard witness type.
+ * Each promotion requires structural evidence that the entity
+ * satisfies the invariants of the target rank.
+ */
+interface PromotionProof {
+    /** Source rank */
+    from: SkillRank;
+    /** Target rank */
+    to: SkillRank;
+    /** Structural invariant checks that passed */
+    invariants: PromotionInvariant[];
+    /** Timestamp of promotion evaluation */
+    evaluatedAt: string;
+    /** Quality score at time of promotion (0-1) */
+    qualityScore: number;
+}
+interface PromotionInvariant {
+    /** Invariant name (e.g., "has_convergence", "has_3_plus_skills", "has_mesh_events") */
+    name: string;
+    /** Whether this invariant was satisfied */
+    satisfied: boolean;
+    /** Human-readable evidence */
+    evidence?: string;
+}
+interface SkillCapabilities {
+    /** Allow image generation via connected media providers */
+    allowImageGen?: boolean;
+    /** Allow video generation via connected media providers */
+    allowVideoGen?: boolean;
+    /** Allow MCP tool access during execution */
+    allowTools?: boolean;
+    /** Allow web search during execution */
+    allowWebSearch?: boolean;
+    /** Allow code execution in sandbox */
+    allowCodeExec?: boolean;
+}
+interface SkillAgent {
+    /** Agent role name (e.g., "Market Researcher", "Legal Analyst") */
+    role: string;
+    /** What this agent does in the workflow */
+    description: string;
+    /** Maps to a NodeManifestV0.id in the stack */
+    nodeRef?: string;
+    /** When true, a synthetic peer reviewer evaluates this agent's output after completion */
+    peerReview?: boolean;
+}
+interface SkillSampleOutput {
+    type: SkillOutputType;
+    title: string;
+    /** Screenshot or live preview URL */
+    previewUrl?: string;
+    description: string;
+}
+/** External service dependency for a skill */
+interface SkillServiceRequirement {
+    /** Unique key for this requirement (e.g., "search", "database", "email") */
+    key: string;
+    /** Human-readable label */
+    label: string;
+    /** Type of service needed */
+    type: "mcp" | "api" | "credential";
+    /** Description of what this service is used for */
+    description: string;
+    /** Whether this service is required or optional */
+    required: boolean;
+    /** Suggested MCP server names (for type: "mcp") */
+    suggestedServers?: string[];
+}
+interface SkillMeta<TInput extends Record<string, unknown> = Record<string, unknown>> {
+    /** Unique skill slug (url-safe) */
+    slug: string;
+    /** Display name */
+    title: string;
+    /** One-line value proposition */
+    tagline: string;
+    /** Detailed description (markdown) */
+    description: string;
+    /** Skill category */
+    category: SkillCategory;
+    /** Skill tier (complexity/impact level) */
+    tier: SkillTier;
+    /** Expected output artifact types */
+    outputs: SkillOutputType[];
+    /** Estimated execution time range in seconds [min, max] */
+    estimatedTime: [number, number];
+    /** Required input schema (JSON Schema) */
+    inputSchema: JSONSchema7;
+    /** Agent roles involved in this skill */
+    agents: SkillAgent[];
+    /** Sample input for demo/preview (typed to match inputSchema) */
+    sampleInput?: TInput;
+    /** Sample output artifacts for showcase */
+    sampleOutputs?: SkillSampleOutput[];
+    /** Tags for filtering */
+    tags: string[];
+    /** Author */
+    author: string;
+    /** Icon identifier (from icon set) */
+    icon?: string;
+    /** Cosmic gradient pair index (0-7 from cosmicGradients) */
+    gradientIndex?: number;
+    /** Output schema for composition chaining (JSON Schema) */
+    outputSchema?: JSONSchema7;
+    /** Allow agents to dynamically delegate tasks to ephemeral agents. Max 2 per run. */
+    allowDelegation?: boolean;
+    /** External service dependencies (MCP servers, APIs, credentials) */
+    services?: SkillServiceRequirement[];
+    /** Runtime capability toggles (image gen, video gen, tools, etc.) */
+    capabilities?: SkillCapabilities;
+    /** Current rank in the hierarchy (default: "skill") */
+    rank?: SkillRank;
+    /** Effective-dated rank history — immutable audit trail */
+    rankHistory?: RankAssignment[];
+    /**
+     * Convergence configuration for iterative agent output refinement.
+     *
+     * Future optimization: the manual convergence loop in runner.ts could be
+     * replaced by `withRetry()` + `withCircuitBreaker()` from
+     * `lib/terminals-tech/core/primitives/middleware` — they provide the same
+     * retry/backoff/threshold semantics with composable middleware chaining.
+     * See also `createRefinementLoop()` from `primitives/refinement` which
+     * encapsulates the score/delta/plateau logic as a standalone primitive.
+     */
+    convergence?: {
+        /** Max refinement iterations per agent. Default 1 (no refinement), max 5. */
+        maxIterations: number;
+        /** Quality threshold (0-1). Agent output must meet this to pass. Default 0.7. */
+        qualityThreshold: number;
+        /** Minimum quality improvement per iteration. Stops early if delta < this. Default 0.05. */
+        minDelta: number;
+        /** Refinement strategy: retry (re-execute), critique (LLM critic), refine (critique + inject feedback). */
+        strategy: "retry" | "critique" | "refine";
+    };
+}
+/**
+ * A SkillManifest extends StackManifestV0 with skill-specific metadata.
+ *
+ * This is the core type — a skill IS a stack manifest with agent orchestration
+ * metadata. The `skill` field contains all presentation and execution metadata.
+ *
+ * The `TInput` parameter establishes compile-time correspondence between
+ * the JSON Schema `inputSchema`, the typed `sampleInput`, and the runtime
+ * input validated by `SkillRunner.start()`.
+ */
+interface SkillManifest<TInput extends Record<string, unknown> = Record<string, unknown>> extends StackManifestV0 {
+    /** Skill-specific metadata */
+    skill: SkillMeta<TInput>;
+}
+
+type ManifestType = "skill" | "stack" | "node" | "project";
+type ManifestSource = "system" | "user" | "compose" | "marketplace" | "import";
+interface RegistryEntry {
+    type: ManifestType;
+    manifest: SkillManifest | StackManifestV0 | NodeManifestV0 | Record<string, unknown>;
+    source: ManifestSource;
+    registeredAt: number;
+    tags?: string[];
+}
+interface RegistryFilter {
+    type?: ManifestType;
+    source?: ManifestSource;
+    category?: SkillCategory;
+    tags?: string[];
+    limit?: number;
+}
+declare class ManifestRegistry {
+    private entries;
+    register(manifest: SkillManifest | StackManifestV0 | NodeManifestV0 | Record<string, unknown>, type: ManifestType, source: ManifestSource, tags?: string[]): void;
+    get(key: string): RegistryEntry | undefined;
+    getSkill(slug: string): SkillManifest | undefined;
+    getAll(filter?: RegistryFilter): RegistryEntry[];
+    resolve(ref: string): RegistryEntry | null;
+    search(query: string, filter?: RegistryFilter): RegistryEntry[];
+    unregister(key: string): boolean;
+    get size(): number;
+    clear(): void;
+    private deriveKey;
+}
+/** Singleton registry instance */
+declare const registry: ManifestRegistry;
+
+/**
+ * Core SDK — Fundamental utilities and data structures
+ *
+ * Result types, retry/circuit-breaker, event bus, validation, DAG, registry.
+ * Hides internal combinators, vector ops, stream internals.
+ *
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module sdk/core
+ */
+
+type core_CircuitBreakerOptions = CircuitBreakerOptions;
+type core_DAG<N, E = void> = DAG<N, E>;
+type core_DAGEdge<E = void> = DAGEdge<E>;
+type core_DAGNode<T> = DAGNode<T>;
+type core_EventHandler<T> = EventHandler<T>;
+type core_ManifestRegistry = ManifestRegistry;
+declare const core_ManifestRegistry: typeof ManifestRegistry;
+type core_Registry<K, V> = Registry<K, V>;
+type core_RetryOptions = RetryOptions;
+type core_SDKResult<T, E = Error> = SDKResult<T, E>;
+type core_StoreError = StoreError;
+type core_TypedEventBus<Events extends Record<string, unknown>> = TypedEventBus<Events>;
+type core_Untrusted<T> = Untrusted<T>;
+type core_Validated<T> = Validated<T>;
+declare const core_createCircuitBreaker: typeof createCircuitBreaker;
+declare const core_createDAG: typeof createDAG;
+declare const core_createEventBus: typeof createEventBus;
+declare const core_createRegistry: typeof createRegistry;
+declare const core_err: typeof err;
+declare const core_isErr: typeof isErr;
+declare const core_isOk: typeof isOk;
+declare const core_ok: typeof ok;
+declare const core_registry: typeof registry;
+declare const core_secureValidate: typeof secureValidate;
+declare const core_unbrand: typeof unbrand;
+declare const core_untrusted: typeof untrusted;
+declare const core_validateWithSchema: typeof validateWithSchema;
+declare const core_validated: typeof validated;
+declare const core_withRetry: typeof withRetry;
+declare namespace core {
+  export { type core_CircuitBreakerOptions as CircuitBreakerOptions, type core_DAG as DAG, type core_DAGEdge as DAGEdge, type core_DAGNode as DAGNode, type core_EventHandler as EventHandler, core_ManifestRegistry as ManifestRegistry, type core_Registry as Registry, type core_RetryOptions as RetryOptions, type core_SDKResult as SDKResult, type core_StoreError as StoreError, type core_TypedEventBus as TypedEventBus, type core_Untrusted as Untrusted, type core_Validated as Validated, core_createCircuitBreaker as createCircuitBreaker, core_createDAG as createDAG, core_createEventBus as createEventBus, core_createRegistry as createRegistry, core_err as err, flatMap as flatMapResult, core_isErr as isErr, core_isOk as isOk, map as mapResult, core_ok as ok, core_registry as registry, core_secureValidate as secureValidate, core_unbrand as unbrand, core_untrusted as untrusted, core_validateWithSchema as validateWithSchema, core_validated as validated, core_withRetry as withRetry };
+}
+
+/**
+ * L0 Category Theory Primitives
+ *
+ * Foundational categorical abstractions for cross-layer type mappings.
+ * Provides the mathematical foundation for isomorphisms between AXON layers.
+ *
+ * @license BUSL-1.1
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module core/L0/category
+ */
+/**
+ * A morphism is a structure-preserving transformation between types.
+ * This is the fundamental building block of category theory.
+ */
+type Morphism<A, B> = (a: A) => B;
+/**
+ * Async morphism for transformations that may be asynchronous
+ */
+type AsyncMorphism<A, B> = (a: A) => Promise<B>;
+/**
+ * A Category consists of objects and morphisms between them,
+ * with composition and identity laws.
+ */
+interface Category<Obj, Hom> {
+    /** Identity morphism for each object */
+    identity<A extends Obj>(a: A): Hom;
+    /** Composition of morphisms: g . f = g(f(x)) */
+    compose<A extends Obj, B extends Obj, C extends Obj>(f: Hom, g: Hom): Hom;
+}
+/**
+ * An isomorphism is a bijective morphism with an inverse.
+ * For A and B to be isomorphic, there must exist:
+ * - forward: A → B
+ * - backward: B → A
+ * - such that: backward(forward(a)) = a AND forward(backward(b)) = b
+ */
+interface Iso<A, B> {
+    /** Forward transformation: A → B */
+    forward: Morphism<A, B>;
+    /** Backward transformation: B → A */
+    backward: Morphism<B, A>;
+    /** Optional metadata about the isomorphism */
+    meta?: IsoMeta;
+}
+/**
+ * Metadata about an isomorphism
+ */
+interface IsoMeta {
+    /** Human-readable name */
+    name?: string;
+    /** Description of what this iso does */
+    description?: string;
+    /** Whether this is an exact isomorphism (no information loss) */
+    exact?: boolean;
+    /** Confidence score for derived isomorphisms (0-1) */
+    confidence?: number;
+    /** Source layer (L1-L5) */
+    sourceLayer?: LayerId;
+    /** Target layer (L1-L5) */
+    targetLayer?: LayerId;
+}
+/**
+ * Async isomorphism for transformations that may be asynchronous
+ */
+interface AsyncIso<A, B> {
+    forward: AsyncMorphism<A, B>;
+    backward: AsyncMorphism<B, A>;
+    meta?: IsoMeta;
+}
+/**
+ * An embedding is a one-way structure-preserving transformation.
+ * Unlike isomorphisms, embeddings may not have a full inverse.
+ * The partial inverse extracts as much as possible from the target type.
+ */
+interface Embed<A, B> {
+    /** Embed A into B */
+    embed: Morphism<A, B>;
+    /** Partial extraction from B (may lose information) */
+    extract: Morphism<B, Partial<A>>;
+    /** Whether the embedding is lossless */
+    lossless?: boolean;
+}
+/**
+ * A functor maps objects and morphisms between categories
+ * while preserving identity and composition.
+ */
+interface Functor<F> {
+    /** Map a morphism over the functor */
+    map<A, B>(f: Morphism<A, B>): (fa: F) => F;
+}
+/**
+ * Natural transformation between functors F and G.
+ * For each object A, provides a morphism F(A) → G(A)
+ * such that the naturality square commutes.
+ */
+type NaturalTransformation<F, G> = <A>(fa: F) => G;
+/**
+ * AXON Layer identifiers
+ */
+type LayerId = "L0" | "L1" | "L2" | "L3" | "L4" | "L5";
+/**
+ * Layer metadata
+ */
+interface LayerMeta {
+    id: LayerId;
+    name: string;
+    description: string;
+    color: string;
+}
+/**
+ * AXON Layer definitions
+ */
+declare const LAYERS: Record<LayerId, LayerMeta>;
+/**
+ * Valid layer transitions in the AXON architecture
+ */
+declare const VALID_TRANSITIONS: ReadonlyArray<[LayerId, LayerId]>;
+/**
+ * Product type - categorical product of A and B
+ */
+type Product<A, B> = readonly [A, B];
+/**
+ * Coproduct (sum) type - categorical coproduct of A and B
+ */
+type Coproduct<A, B> = {
+    readonly tag: "left";
+    readonly value: A;
+} | {
+    readonly tag: "right";
+    readonly value: B;
+};
+/**
+ * Create a left-tagged coproduct
+ */
+declare function left<A, B>(value: A): Coproduct<A, B>;
+/**
+ * Create a right-tagged coproduct
+ */
+declare function right<A, B>(value: B): Coproduct<A, B>;
+/**
+ * Fold over a coproduct
+ */
+declare function fold<A, B, C>(onLeft: Morphism<A, C>, onRight: Morphism<B, C>): Morphism<Coproduct<A, B>, C>;
+/**
+ * A proof witness type - represents evidence that P holds
+ */
+type Proof<P> = P extends true ? {
+    readonly _witness: unique symbol;
+} : never;
+/**
+ * A verified value with attached proof
+ */
+interface Verified<T, P> {
+    readonly value: T;
+    readonly proof: Proof<P>;
+}
+/**
+ * Compose two morphisms: g . f
+ */
+declare function compose<A, B, C>(f: Morphism<A, B>, g: Morphism<B, C>): Morphism<A, C>;
+/**
+ * Compose two async morphisms
+ */
+declare function composeAsync<A, B, C>(f: AsyncMorphism<A, B>, g: AsyncMorphism<B, C>): Promise<AsyncMorphism<A, C>>;
+/**
+ * Identity morphism
+ */
+declare function identity<A>(): Morphism<A, A>;
+/**
+ * Compose two isomorphisms
+ */
+declare function composeIso<A, B, C>(iso1: Iso<A, B>, iso2: Iso<B, C>): Iso<A, C>;
+/**
+ * Invert an isomorphism
+ */
+declare function invertIso<A, B>(iso: Iso<A, B>): Iso<B, A>;
+/**
+ * Create an identity isomorphism
+ */
+declare function identityIso<A>(): Iso<A, A>;
+/**
+ * A typed bridge between two layers with verified transition
+ */
+interface LayerBridge<From extends LayerId, To extends LayerId, A, B> {
+    readonly sourceLayer: From;
+    readonly targetLayer: To;
+    readonly iso: Iso<A, B>;
+}
+/**
+ * Check if a layer transition is valid
+ */
+declare function isValidTransition(from: LayerId, to: LayerId): boolean;
+/**
+ * Create a layer bridge (validates transition at runtime)
+ */
+declare function createBridge<From extends LayerId, To extends LayerId, A, B>(from: From, to: To, iso: Iso<A, B>): LayerBridge<From, To, A, B> | null;
+
+/**
+ * L0 Information Theory Primitives
+ *
+ * Provides measures for information preservation, entropy,
+ * and semantic density in cross-layer transformations.
+ *
+ * @module core/L0/information
+ */
+/**
+ * Calculate Shannon entropy for a probability distribution.
+ * H(X) = -Σ p(x) log₂ p(x)
+ *
+ * @param probabilities - Array of probabilities (should sum to 1)
+ * @returns Entropy in bits
+ */
+declare function entropy(probabilities: number[]): number;
+/**
+ * Calculate joint entropy H(X, Y)
+ *
+ * @param jointProbabilities - 2D array of joint probabilities P(X=x, Y=y)
+ * @returns Joint entropy in bits
+ */
+declare function jointEntropy(jointProbabilities: number[][]): number;
+/**
+ * Calculate conditional entropy H(Y|X) = H(X,Y) - H(X)
+ *
+ * @param jointProbabilities - 2D array P(X=x, Y=y)
+ * @returns Conditional entropy in bits
+ */
+declare function conditionalEntropy(jointProbabilities: number[][]): number;
+/**
+ * Calculate mutual information I(X; Y) = H(X) + H(Y) - H(X, Y)
+ * Measures how much knowing one variable reduces uncertainty about the other.
+ *
+ * @param pX - Marginal probability of X
+ * @param pY - Marginal probability of Y
+ * @param pXY - Joint probability P(X, Y) as 2D array
+ * @returns Mutual information in bits
+ */
+declare function mutualInformation(pX: number[], pY: number[], pXY: number[][]): number;
+/**
+ * Metrics for measuring information preservation in transformations
+ */
+interface InformationPreservation {
+    /** Fraction of source information retained (0-1) */
+    retention: number;
+    /** Entropy of the source */
+    sourceEntropy: number;
+    /** Entropy of the target */
+    targetEntropy: number;
+    /** Mutual information between source and target */
+    mutualInfo: number;
+    /** Whether the transformation is lossless */
+    lossless: boolean;
+}
+/**
+ * Measure information preservation between source and transformed representations.
+ * Uses hash-based sampling for large datasets.
+ *
+ * @param source - Original values
+ * @param transformed - Transformed values
+ * @param roundTrip - Optional round-trip values (transformed → source)
+ * @returns Information preservation metrics
+ */
+declare function measurePreservation<S, T>(source: S[], transformed: T[], roundTrip?: S[]): InformationPreservation;
+/**
+ * Semantic density measures bits of meaningful information per token.
+ * Higher density = more information packed into fewer tokens.
+ */
+interface SemanticDensity {
+    /** Total tokens in the representation */
+    tokenCount: number;
+    /** Estimated information content in bits */
+    informationBits: number;
+    /** Bits per token */
+    density: number;
+    /** Compression ratio compared to baseline */
+    compressionRatio: number;
+}
+/**
+ * Calculate semantic density of a representation.
+ *
+ * @param tokens - Array of tokens (strings, symbols, etc.)
+ * @param baselineTokensPerBit - Baseline tokens per bit of information (default: 2)
+ * @returns Semantic density metrics
+ */
+declare function calculateSemanticDensity(tokens: string[], baselineTokensPerBit?: number): SemanticDensity;
+/**
+ * Estimate Kolmogorov complexity via compression.
+ * Lower complexity = more compressible = more structured.
+ *
+ * @param data - String representation of data
+ * @returns Estimated complexity as compression ratio
+ */
+declare function estimateComplexity(data: string): number;
+/**
+ * Calculate KL divergence D_KL(P || Q) = Σ p(x) log(p(x)/q(x))
+ * Measures how much P differs from Q.
+ *
+ * @param p - True distribution
+ * @param q - Approximate distribution
+ * @returns KL divergence (non-negative, 0 = identical)
+ */
+declare function klDivergence(p: number[], q: number[]): number;
+/**
+ * Calculate Jensen-Shannon divergence (symmetric KL variant)
+ * JSD(P, Q) = 0.5 * D_KL(P || M) + 0.5 * D_KL(Q || M) where M = 0.5(P + Q)
+ *
+ * @param p - First distribution
+ * @param q - Second distribution
+ * @returns JS divergence in [0, 1]
+ */
+declare function jsDivergence(p: number[], q: number[]): number;
+/**
+ * Normalize an array to sum to 1 (probability distribution)
+ */
+declare function normalize(values: number[]): number[];
+/**
+ * Calculate cosine similarity between two vectors
+ */
+declare function cosineSimilarity(a: number[], b: number[]): number;
+
+/**
+ * L0 Automatic Isomorphism Derivation
+ *
+ * Automatically derives isomorphisms between compatible types
+ * using structural analysis and field mapping.
+ *
+ * @license BUSL-1.1
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module core/L0/derivation
+ */
+
+/**
+ * Type shape descriptor for structural analysis
+ */
+interface TypeShape {
+    /** Type kind (object, array, primitive, etc.) */
+    kind: "object" | "array" | "primitive" | "null" | "undefined";
+    /** For objects: map of field name to TypeShape */
+    fields?: Record<string, TypeShape>;
+    /** For arrays: element type shape */
+    elementType?: TypeShape;
+    /** For primitives: the primitive type */
+    primitiveType?: "string" | "number" | "boolean" | "bigint" | "symbol";
+    /** Whether the field is optional */
+    optional?: boolean;
+}
+/**
+ * Extract the structural shape of a value at runtime
+ *
+ * @param value - Value to analyze
+ * @returns TypeShape descriptor
+ */
+declare function extractShape(value: unknown): TypeShape;
+/**
+ * Calculate similarity between two type shapes (Jaccard-like)
+ *
+ * @param a - First type shape
+ * @param b - Second type shape
+ * @returns Similarity score (0-1)
+ */
+declare function shapeSimilarity(a: TypeShape, b: TypeShape): number;
+/**
+ * A mapping between fields in source and target types
+ */
+interface FieldMapping {
+    /** Source field name */
+    source: string;
+    /** Target field name */
+    target: string;
+    /** Confidence of the mapping (0-1) */
+    confidence: number;
+    /** Transform function if types differ */
+    transform?: Morphism<unknown, unknown>;
+}
+/**
+ * Derive field mappings between two object shapes
+ *
+ * @param source - Source type shape
+ * @param target - Target type shape
+ * @returns Array of field mappings
+ */
+declare function deriveFieldMappings(source: TypeShape, target: TypeShape): FieldMapping[];
+/**
+ * Result of automatic isomorphism derivation
+ */
+interface DerivedIso<A, B> extends Iso<A, B> {
+    /** Field mappings used */
+    fieldMappings: FieldMapping[];
+    /** Overall confidence score */
+    confidence: number;
+}
+/**
+ * Options for isomorphism derivation
+ */
+interface DerivationOptions {
+    /** Minimum confidence threshold (default: 0.5) */
+    minConfidence?: number;
+    /** Whether to include partial mappings (default: true) */
+    includePartial?: boolean;
+    /** Custom field transforms */
+    customTransforms?: Record<string, Morphism<unknown, unknown>>;
+}
+/**
+ * Automatically derive an isomorphism between two types based on structure
+ *
+ * @param sampleA - Sample value of type A
+ * @param sampleB - Sample value of type B
+ * @param options - Derivation options
+ * @returns Derived isomorphism or null if not derivable
+ */
+declare function deriveIsomorphism<A extends object, B extends object>(sampleA: A, sampleB: B, options?: DerivationOptions): DerivedIso<A, B> | null;
+/**
+ * Verify an isomorphism by testing round-trip on sample values
+ *
+ * @param iso - Isomorphism to verify
+ * @param samples - Sample values to test
+ * @returns True if all round-trips match
+ */
+declare function verifyIsomorphism<A, B>(iso: Iso<A, B>, samples: A[]): boolean;
+/**
+ * Check if two types are structurally compatible for isomorphism
+ *
+ * @param shapeA - Source type shape
+ * @param shapeB - Target type shape
+ * @returns Compatibility score (0-1)
+ */
+declare function checkCompatibility(shapeA: TypeShape, shapeB: TypeShape): number;
+/**
+ * Check if a type can be embedded into another (one-way mapping)
+ *
+ * @param source - Source type shape
+ * @param target - Target type shape
+ * @returns True if source can be fully embedded in target
+ */
+declare function canEmbed(source: TypeShape, target: TypeShape): boolean;
+
+/**
+ * L0 Sematon — The Smallest Meaning-Bearing Unit
+ *
+ * The sematon is the atomic unit of operational meaning in Terminals OS.
+ * It carries a typed payload, convergence witness, p-adic address,
+ * information-theoretic metrics, and a constructor flag that guarantees
+ * the Deutsch-Marletto invariant: after transforming an input, the
+ * sematon retains the ability to transform again.
+ *
+ * The sematon unifies Signal<T>, ContextNode, FractalSnapshot,
+ * ConvergenceWitness, and CombinatorEvent into a single formal type
+ * at the L0 foundation layer.
+ *
+ * Core Engine Primitive.
+ *
+ * @license BUSL-1.1
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module core/L0/sematon
+ */
+/**
+ * Payload kind classification for sematons.
+ * Determines how the payload is interpreted across layers.
+ */
+type SematonKind = "signal" | "context" | "fractal" | "witness" | "combinator" | "interaction" | "custom";
+/**
+ * Convergence witness snapshot embedded in a sematon.
+ * Minimal subset of ConvergenceWitness for portability.
+ */
+interface SematonWitness {
+    /** Kuramoto order parameter R in [0, 1] */
+    R: number;
+    /** Shannon entropy of activation distribution */
+    activationEntropy: number;
+    /** Whether convergence criteria are met */
+    converged: boolean;
+    /** Step at which this witness was taken */
+    step: number;
+}
+/**
+ * The Sematon — smallest meaning-bearing unit with operational consequence.
+ *
+ * Generic over T (the payload type):
+ *   T = Signal payload at signal kind
+ *   T = ContextNode metadata at context kind
+ *   T = FractalSnapshot at fractal kind
+ *   T = arbitrary at custom kind
+ */
+interface Sematon<T = unknown> {
+    /** Unique identifier */
+    readonly id: string;
+    /** Payload kind classification */
+    readonly kind: SematonKind;
+    /** The meaning-bearing payload */
+    readonly payload: T;
+    /** Convergence witness at creation time */
+    readonly witness: SematonWitness;
+    /** p-adic address for hierarchical locality */
+    readonly padicAddress: string;
+    /** Shannon entropy of payload (bits) */
+    readonly entropy: number;
+    /** Semantic density (bits per token) */
+    readonly density: number;
+    /** The resistance to constructive transformation: H / (ρ * R) */
+    readonly impedance: number;
+    /** Deterministic content hash (FNV-1a) */
+    readonly shapeHash: string;
+    /**
+     * Constructor flag: can this sematon participate in further transformations?
+     * True iff: witness has converged AND entropy is finite AND payload is non-empty.
+     * This is the Deutsch-Marletto invariant.
+     */
+    readonly constructive: boolean;
+    /** Creation timestamp */
+    readonly createdAt: number;
+    /** Source layer or surface that produced this sematon */
+    readonly source: string;
+}
+/**
+ * Folded (serializable) representation of a Sematon.
+ * Suitable for JSON serialization, mesh relay, or persistence.
+ */
+interface FoldedSematon {
+    id: string;
+    kind: SematonKind;
+    payload: string;
+    witness: SematonWitness;
+    padicAddress: string;
+    entropy: number;
+    density: number;
+    impedance: number;
+    shapeHash: string;
+    constructive: boolean;
+    createdAt: number;
+    source: string;
+}
+interface SematonConfig<T> {
+    kind: SematonKind;
+    payload: T;
+    witness: SematonWitness;
+    padicAddress?: string;
+    source?: string;
+}
+/**
+ * Create a new Sematon from configuration.
+ */
+declare function createSematon<T>(config: SematonConfig<T>): Sematon<T>;
+/**
+ * Get the Shannon entropy of a sematon's payload.
+ */
+declare function sematonEntropy<T>(sematon: Sematon<T>): number;
+/**
+ * Get the semantic density of a sematon.
+ */
+declare function sematonDensity<T>(sematon: Sematon<T>): number;
+/**
+ * Check if a sematon can participate in further transformations.
+ * This is the Deutsch-Marletto constructor invariant.
+ */
+declare function isRealizable<T>(sematon: Sematon<T>): boolean;
+/**
+ * Compute distance between two sematons using payload cosine similarity
+ * weighted by witness R proximity.
+ *
+ * Distance in [0, 1] where 0 = identical, 1 = maximally different.
+ */
+declare function sematonDistance<T>(a: Sematon<T>, b: Sematon<T>): number;
+/**
+ * Fold a Sematon into a JSON-serializable representation.
+ * HVM γ (construct) — compress for handoff, persistence, or relay.
+ */
+declare function foldSematon<T>(sematon: Sematon<T>): FoldedSematon;
+/**
+ * Unfold a serialized representation back into a Sematon.
+ * HVM δ (duplicate) — expand from handoff, persistence, or relay.
+ */
+declare function unfoldSematon<T>(folded: FoldedSematon): Sematon<T>;
+
+/**
+ * L0 Realizability Trace — Constructor Proof Runtime
+ *
+ * A RealizabilityTrace is an ordered sequence of RealizabilitySteps.
+ * Each step records: input Sematon(s), output Sematon(s), a ConvergenceWitness
+ * snapshot, and information gain.
+ *
+ * verifyTrace() checks three constructor invariants:
+ *   1. Each input was realizable (constructive flag true)
+ *   2. Each witness converged (R above threshold)
+ *   3. Information is non-decreasing across steps
+ *
+ * This is the Deutsch-Marletto constructor invariant made executable:
+ * after transforming inputs, the system retains the ability to transform again.
+ *
+ * @license BUSL-1.1
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module core/L0/realizability
+ */
+
+interface RealizabilityStep {
+    /** Step index in the trace */
+    index: number;
+    /** Input sematons consumed by this step */
+    inputs: Sematon[];
+    /** Output sematons produced by this step */
+    outputs: Sematon[];
+    /** Convergence witness at this step */
+    witness: SematonWitness;
+    /** Total information content of outputs (bits) */
+    informationGain: number;
+    /** Timestamp */
+    timestamp: number;
+}
+interface RealizabilityTrace {
+    /** Unique trace identifier */
+    id: string;
+    /** Ordered sequence of steps */
+    steps: RealizabilityStep[];
+    /** Whether the trace has been verified */
+    verified: boolean;
+    /** Total information gain across all steps */
+    totalInfoGain: number;
+    /** Count of constructive (realizable) steps */
+    constructiveSteps: number;
+    /** Creation timestamp */
+    createdAt: number;
+}
+interface VerificationSuccess {
+    valid: true;
+    totalInfoGain: number;
+    constructiveSteps: number;
+}
+interface VerificationFailure {
+    valid: false;
+    failureStep: number;
+    reason: string;
+}
+type VerificationResult = VerificationSuccess | VerificationFailure;
+/**
+ * Create a single realizability step.
+ * Computes informationGain as the sum of output sematon entropies.
+ */
+declare function createRealizabilityStep(index: number, inputs: Sematon[], outputs: Sematon[], witness: SematonWitness): RealizabilityStep;
+/**
+ * Construct a RealizabilityTrace from an ordered sequence of steps.
+ * Computes totalInfoGain and constructiveSteps.
+ */
+declare function traceRealizability(steps: RealizabilityStep[]): RealizabilityTrace;
+/**
+ * Verify a realizability trace against three constructor invariants:
+ *   1. Each step's inputs must all be realizable
+ *   2. Each step's witness must have converged
+ *   3. Information is non-decreasing across steps
+ *
+ * Returns VerificationSuccess or VerificationFailure with step index and reason.
+ */
+declare function verifyTrace(trace: RealizabilityTrace): VerificationResult;
+/**
+ * Fold a RealizabilityTrace into a JSON string.
+ * Sematons are folded via foldSematon first for portable serialization.
+ */
+declare function foldTrace(trace: RealizabilityTrace): string;
+/**
+ * Unfold a JSON string back into a RealizabilityTrace.
+ * Sematons are unfolded via unfoldSematon.
+ */
+declare function unfoldTrace(json: string): RealizabilityTrace;
+
+/**
+ * L0 Foundation Layer
+ *
+ * Provides categorical foundations and information-theoretic primitives
+ * for cross-layer mappings in the AXON architecture.
+ *
+ * @module core/L0
+ */
+
+type index_AsyncIso<A, B> = AsyncIso<A, B>;
+type index_AsyncMorphism<A, B> = AsyncMorphism<A, B>;
+type index_Category<Obj, Hom> = Category<Obj, Hom>;
+type index_Coproduct<A, B> = Coproduct<A, B>;
+type index_DerivationOptions = DerivationOptions;
+type index_DerivedIso<A, B> = DerivedIso<A, B>;
+type index_Embed<A, B> = Embed<A, B>;
+type index_FieldMapping = FieldMapping;
+type index_FoldedSematon = FoldedSematon;
+type index_Functor<F> = Functor<F>;
+type index_InformationPreservation = InformationPreservation;
+type index_Iso<A, B> = Iso<A, B>;
+type index_IsoMeta = IsoMeta;
+declare const index_LAYERS: typeof LAYERS;
+type index_LayerBridge<From extends LayerId, To extends LayerId, A, B> = LayerBridge<From, To, A, B>;
+type index_LayerId = LayerId;
+type index_LayerMeta = LayerMeta;
+type index_Morphism<A, B> = Morphism<A, B>;
+type index_NaturalTransformation<F, G> = NaturalTransformation<F, G>;
+type index_Product<A, B> = Product<A, B>;
+type index_Proof<P> = Proof<P>;
+type index_RealizabilityStep = RealizabilityStep;
+type index_RealizabilityTrace = RealizabilityTrace;
+type index_SemanticDensity = SemanticDensity;
+type index_Sematon<T = unknown> = Sematon<T>;
+type index_SematonConfig<T> = SematonConfig<T>;
+type index_SematonKind = SematonKind;
+type index_SematonWitness = SematonWitness;
+type index_TypeShape = TypeShape;
+declare const index_VALID_TRANSITIONS: typeof VALID_TRANSITIONS;
+type index_VerificationFailure = VerificationFailure;
+type index_VerificationResult = VerificationResult;
+type index_VerificationSuccess = VerificationSuccess;
+type index_Verified<T, P> = Verified<T, P>;
+declare const index_calculateSemanticDensity: typeof calculateSemanticDensity;
+declare const index_canEmbed: typeof canEmbed;
+declare const index_checkCompatibility: typeof checkCompatibility;
+declare const index_compose: typeof compose;
+declare const index_composeAsync: typeof composeAsync;
+declare const index_composeIso: typeof composeIso;
+declare const index_conditionalEntropy: typeof conditionalEntropy;
+declare const index_cosineSimilarity: typeof cosineSimilarity;
+declare const index_createBridge: typeof createBridge;
+declare const index_createRealizabilityStep: typeof createRealizabilityStep;
+declare const index_createSematon: typeof createSematon;
+declare const index_deriveFieldMappings: typeof deriveFieldMappings;
+declare const index_deriveIsomorphism: typeof deriveIsomorphism;
+declare const index_entropy: typeof entropy;
+declare const index_estimateComplexity: typeof estimateComplexity;
+declare const index_extractShape: typeof extractShape;
+declare const index_fold: typeof fold;
+declare const index_foldSematon: typeof foldSematon;
+declare const index_foldTrace: typeof foldTrace;
+declare const index_identity: typeof identity;
+declare const index_identityIso: typeof identityIso;
+declare const index_invertIso: typeof invertIso;
+declare const index_isRealizable: typeof isRealizable;
+declare const index_isValidTransition: typeof isValidTransition;
+declare const index_jointEntropy: typeof jointEntropy;
+declare const index_jsDivergence: typeof jsDivergence;
+declare const index_klDivergence: typeof klDivergence;
+declare const index_left: typeof left;
+declare const index_measurePreservation: typeof measurePreservation;
+declare const index_mutualInformation: typeof mutualInformation;
+declare const index_normalize: typeof normalize;
+declare const index_right: typeof right;
+declare const index_sematonDensity: typeof sematonDensity;
+declare const index_sematonDistance: typeof sematonDistance;
+declare const index_sematonEntropy: typeof sematonEntropy;
+declare const index_shapeSimilarity: typeof shapeSimilarity;
+declare const index_traceRealizability: typeof traceRealizability;
+declare const index_unfoldSematon: typeof unfoldSematon;
+declare const index_unfoldTrace: typeof unfoldTrace;
+declare const index_verifyIsomorphism: typeof verifyIsomorphism;
+declare const index_verifyTrace: typeof verifyTrace;
+declare namespace index {
+  export { type index_AsyncIso as AsyncIso, type index_AsyncMorphism as AsyncMorphism, type index_Category as Category, type index_Coproduct as Coproduct, type index_DerivationOptions as DerivationOptions, type index_DerivedIso as DerivedIso, type index_Embed as Embed, type index_FieldMapping as FieldMapping, type index_FoldedSematon as FoldedSematon, type index_Functor as Functor, type index_InformationPreservation as InformationPreservation, type index_Iso as Iso, type index_IsoMeta as IsoMeta, index_LAYERS as LAYERS, type index_LayerBridge as LayerBridge, type index_LayerId as LayerId, type index_LayerMeta as LayerMeta, type index_Morphism as Morphism, type index_NaturalTransformation as NaturalTransformation, type index_Product as Product, type index_Proof as Proof, type index_RealizabilityStep as RealizabilityStep, type index_RealizabilityTrace as RealizabilityTrace, type index_SemanticDensity as SemanticDensity, type index_Sematon as Sematon, type index_SematonConfig as SematonConfig, type index_SematonKind as SematonKind, type index_SematonWitness as SematonWitness, type index_TypeShape as TypeShape, index_VALID_TRANSITIONS as VALID_TRANSITIONS, type index_VerificationFailure as VerificationFailure, type index_VerificationResult as VerificationResult, type index_VerificationSuccess as VerificationSuccess, type index_Verified as Verified, index_calculateSemanticDensity as calculateSemanticDensity, index_canEmbed as canEmbed, index_checkCompatibility as checkCompatibility, index_compose as compose, index_composeAsync as composeAsync, index_composeIso as composeIso, index_conditionalEntropy as conditionalEntropy, index_cosineSimilarity as cosineSimilarity, index_createBridge as createBridge, index_createRealizabilityStep as createRealizabilityStep, index_createSematon as createSematon, index_deriveFieldMappings as deriveFieldMappings, index_deriveIsomorphism as deriveIsomorphism, index_entropy as entropy, index_estimateComplexity as estimateComplexity, index_extractShape as extractShape, index_fold as fold, index_foldSematon as foldSematon, index_foldTrace as foldTrace, index_identity as identity, index_identityIso as identityIso, index_invertIso as invertIso, index_isRealizable as isRealizable, index_isValidTransition as isValidTransition, index_jointEntropy as jointEntropy, index_jsDivergence as jsDivergence, index_klDivergence as klDivergence, index_left as left, index_measurePreservation as measurePreservation, index_mutualInformation as mutualInformation, index_normalize as normalize, index_right as right, index_sematonDensity as sematonDensity, index_sematonDistance as sematonDistance, index_sematonEntropy as sematonEntropy, index_shapeSimilarity as shapeSimilarity, index_traceRealizability as traceRealizability, index_unfoldSematon as unfoldSematon, index_unfoldTrace as unfoldTrace, index_verifyIsomorphism as verifyIsomorphism, index_verifyTrace as verifyTrace };
+}
+
+/**
+ * Action Algebra — Input-Agnostic Action Types
+ *
+ * All input surfaces (keyboard, gamepad, voice, touch) compile down to this algebra.
+ * All executors interpret this algebra into effects.
+ *
+ * @module core/primitives/action
+ */
+
+type NavigationTarget = {
+    kind: "surface";
+    surface: SurfaceId;
+} | {
+    kind: "tab";
+    tab: string;
+} | {
+    kind: "route";
+    path: string;
+    params?: Record<string, string>;
+} | {
+    kind: "focus";
+    elementId: string;
+} | {
+    kind: "relative";
+    direction: "up" | "down" | "left" | "right";
+};
+type SkillRef = {
+    kind: "slug";
+    slug: string;
+} | {
+    kind: "id";
+    id: string;
+} | {
+    kind: "command";
+    commandId: string;
+};
+interface ComposeEdge {
+    sourceId: string;
+    targetId: string;
+    port?: string;
+}
+type ObserveTarget = {
+    kind: "metric";
+    metricId: string;
+} | {
+    kind: "panel";
+    panelId: string;
+} | {
+    kind: "surface";
+    surface: SurfaceId;
+};
+interface DelegateAssignment {
+    agentId: string;
+    taskDescription: string;
+    context?: Record<string, unknown>;
+}
+type Action = {
+    verb: "navigate";
+    target: NavigationTarget;
+} | {
+    verb: "execute";
+    skill: SkillRef;
+    args?: Record<string, unknown>;
+} | {
+    verb: "compose";
+    edge: ComposeEdge;
+} | {
+    verb: "observe";
+    target: ObserveTarget;
+    zoom?: number;
+} | {
+    verb: "delegate";
+    assignment: DelegateAssignment;
+} | {
+    verb: "palette";
+    query?: string;
+} | {
+    verb: "cancel";
+} | {
+    verb: "undo";
+} | {
+    verb: "redo";
+} | {
+    verb: "sequence";
+    actions: Action[];
+};
+type InputSurface = "keyboard" | "gamepad" | "voice" | "touch" | "command_palette";
+interface ActionEvent {
+    action: Action;
+    source: InputSurface;
+    timestamp: number;
+    inputTrace?: string[];
+}
+interface ActionContext {
+    activeSurface: SurfaceId;
+    activeTab: string;
+    selection: string[];
+    isTextFocused: boolean;
+    isModalOpen: boolean;
+}
+type ActionPredicate = (ctx: ActionContext) => boolean;
+interface KeyboardTrigger {
+    type: "chord" | "key" | "sequence";
+    keys: string[];
+    timeout?: number;
+}
+type GamepadButton = "a" | "b" | "x" | "y" | "lb" | "rb" | "lt" | "rt" | "back" | "start" | "ls" | "rs" | "dpad_up" | "dpad_down" | "dpad_left" | "dpad_right";
+interface GamepadTrigger {
+    type: "button" | "combo" | "axis";
+    buttons?: GamepadButton[];
+    sequence?: {
+        button: GamepadButton;
+        holdMs?: number;
+    }[];
+    axis?: {
+        stick: "left" | "right";
+        direction: "up" | "down" | "left" | "right";
+        threshold?: number;
+    };
+}
+interface VoiceTrigger {
+    type: "intent";
+    patterns: string[];
+    confidenceThreshold?: number;
+}
+interface TouchTrigger {
+    type: "gesture";
+    gesture: "swipe_left" | "swipe_right" | "swipe_up" | "swipe_down" | "pinch_in" | "pinch_out" | "long_press" | "double_tap" | "three_finger_swipe";
+}
+type InputTrigger = KeyboardTrigger | GamepadTrigger | VoiceTrigger | TouchTrigger;
+interface ActionBinding {
+    id: string;
+    action: Action;
+    label: string;
+    category: string;
+    when: ActionPredicate;
+    trigger: InputTrigger;
+    surface: InputSurface;
+}
+/** Sequence two actions (flattens nested sequences) */
+declare function seq(a: Action, b: Action): Action;
+/** Navigate then execute */
+declare function goAndRun(target: NavigationTarget, skill: SkillRef): Action;
+/** Delegate then observe */
+declare function delegateAndWatch(assignment: DelegateAssignment, metric: ObserveTarget): Action;
+
+/**
+ * ActionBus — Singleton event bus for the Action Algebra
+ *
+ * All input surfaces publish ActionEvents here.
+ * The executor and any observers subscribe here.
+ *
+ * @module core/primitives/action-bus
+ */
+
+type ActionBusEvents = {
+    "action:dispatched": ActionEvent;
+    "action:executed": ActionEvent & {
+        result: "success" | "error";
+        error?: string;
+    };
+    "action:cancelled": {
+        reason: string;
+        timestamp: number;
+    };
+    "context:changed": ActionContext;
+};
+declare function getActionBus(): TypedEventBus<ActionBusEvents>;
+declare function dispatchAction(event: ActionEvent): void;
+declare function onAction(handler: (event: ActionEvent) => void): () => void;
+
+/**
+ * Mesh SDK — Event emission, subscription, and query
+ *
+ * Cross-layer communication via signals and the action bus.
+ * Hides Interaction primitive internals, SDKMessage, AXON internals.
+ *
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module sdk/mesh
+ */
+
+type mesh_Action = Action;
+type mesh_ActionBinding = ActionBinding;
+type mesh_ActionBusEvents = ActionBusEvents;
+type mesh_ActionContext = ActionContext;
+type mesh_ActionEvent = ActionEvent;
+type mesh_InputSurface = InputSurface;
+type mesh_Signal<T = unknown> = Signal<T>;
+type mesh_SignalBus = SignalBus;
+type mesh_SignalHandler<T = unknown> = SignalHandler<T>;
+type mesh_SignalType = SignalType;
+declare const mesh_createSignalBus: typeof createSignalBus;
+declare const mesh_delegateAndWatch: typeof delegateAndWatch;
+declare const mesh_dispatchAction: typeof dispatchAction;
+declare const mesh_emitSignal: typeof emitSignal;
+declare const mesh_getActionBus: typeof getActionBus;
+declare const mesh_getSignalBus: typeof getSignalBus;
+declare const mesh_goAndRun: typeof goAndRun;
+declare const mesh_onAction: typeof onAction;
+declare const mesh_seq: typeof seq;
+declare const mesh_subscribeToSignals: typeof subscribeToSignals;
+declare namespace mesh {
+  export { type mesh_Action as Action, type mesh_ActionBinding as ActionBinding, type mesh_ActionBusEvents as ActionBusEvents, type mesh_ActionContext as ActionContext, type mesh_ActionEvent as ActionEvent, type mesh_InputSurface as InputSurface, type mesh_Signal as Signal, type mesh_SignalBus as SignalBus, type mesh_SignalHandler as SignalHandler, type mesh_SignalType as SignalType, mesh_createSignalBus as createSignalBus, mesh_delegateAndWatch as delegateAndWatch, mesh_dispatchAction as dispatchAction, mesh_emitSignal as emitSignal, mesh_getActionBus as getActionBus, mesh_getSignalBus as getSignalBus, mesh_goAndRun as goAndRun, mesh_onAction as onAction, mesh_seq as seq, mesh_subscribeToSignals as subscribeToSignals };
+}
+
+type brain_CoherenceConfig = CoherenceConfig;
+type brain_CoherenceInput = CoherenceInput;
+type brain_CoherenceMetrics = CoherenceMetrics;
+type brain_CoherenceResult = CoherenceResult;
+type brain_KuramotoStepOptions = KuramotoStepOptions;
+type brain_OrderParameter = OrderParameter;
+declare const brain_calculateCoherence: typeof calculateCoherence;
+declare const brain_calculateCoherenceWithExplanations: typeof calculateCoherenceWithExplanations;
+declare const brain_getCoherenceSuggestions: typeof getCoherenceSuggestions;
+declare const brain_isCoherent: typeof isCoherent;
+declare const brain_kuramotoStep: typeof kuramotoStep;
+declare const brain_orderParameter: typeof orderParameter;
+declare const brain_phaseLockingValue: typeof phaseLockingValue;
+declare const brain_wrapTo2Pi: typeof wrapTo2Pi;
+declare const brain_wrapToPi: typeof wrapToPi;
+declare namespace brain {
+  export { type brain_CoherenceConfig as CoherenceConfig, type brain_CoherenceInput as CoherenceInput, type brain_CoherenceMetrics as CoherenceMetrics, type brain_CoherenceResult as CoherenceResult, type brain_KuramotoStepOptions as KuramotoStepOptions, type brain_OrderParameter as OrderParameter, brain_calculateCoherence as calculateCoherence, brain_calculateCoherenceWithExplanations as calculateCoherenceWithExplanations, brain_getCoherenceSuggestions as getCoherenceSuggestions, brain_isCoherent as isCoherent, brain_kuramotoStep as kuramotoStep, brain_orderParameter as orderParameter, brain_phaseLockingValue as phaseLockingValue, brain_wrapTo2Pi as wrapTo2Pi, brain_wrapToPi as wrapToPi };
+}
+
+/**
+ * Agent Communication Bus — in-memory message passing for skill agents.
+ *
+ * Scoped per skill run. Agents publish findings, review requests, and
+ * delegation requests. Downstream agents receive accumulated context
+ * via their system prompt.
+ *
+ * @module skills/agent-bus
+ */
+type AgentMessageType = "finding" | "question" | "review_request" | "review_response" | "delegation_request" | "delegation_response";
+interface AgentMessage {
+    fromAgent: string;
+    toAgent?: string;
+    type: AgentMessageType;
+    payload: string;
+    timestamp: number;
+    runId: string;
+}
+type MessageHandler = (msg: AgentMessage) => void;
+interface AgentBus {
+    publish(msg: AgentMessage): void;
+    query(filter: {
+        fromAgent?: string;
+        type?: string;
+    }): AgentMessage[];
+    subscribe(agentId: string, handler: MessageHandler): () => void;
+    getAll(): AgentMessage[];
+}
+/**
+ * Create an AgentBus scoped to a single skill run.
+ * Messages are stored in-memory (array). No persistence needed —
+ * the bus lifetime matches the SkillRunner instance.
+ */
+declare function createAgentBus(runId: string): AgentBus;
+
+/**
+ * Protocol SDK — MCP and A2A protocol connections
+ *
+ * Delegation primitives and agent communication types.
+ * Hides MCP client lifecycle, A2A internals.
+ *
+ * @copyright © 2026 Intuition Labs LLC. All rights reserved. Patent Pending.
+ * @module sdk/protocol
+ */
+
+type protocol_AgentBus = AgentBus;
+type protocol_AgentMessage = AgentMessage;
+type protocol_AgentMessageType = AgentMessageType;
+type protocol_DelegationChain = DelegationChain;
+type protocol_DelegationEdge<S = SurfaceId, T = SurfaceId> = DelegationEdge<S, T>;
+type protocol_DelegationEdgeInput<S = SurfaceId, T = SurfaceId> = DelegationEdgeInput<S, T>;
+type protocol_DelegationEndpoint<S = SurfaceId> = DelegationEndpoint<S>;
+declare const protocol_createAgentBus: typeof createAgentBus;
+declare const protocol_createDelegationChain: typeof createDelegationChain;
+declare const protocol_createDelegationEdge: typeof createDelegationEdge;
+declare const protocol_isValidSurfaceId: typeof isValidSurfaceId;
+declare namespace protocol {
+  export { type protocol_AgentBus as AgentBus, type protocol_AgentMessage as AgentMessage, type protocol_AgentMessageType as AgentMessageType, type protocol_DelegationChain as DelegationChain, type protocol_DelegationEdge as DelegationEdge, type protocol_DelegationEdgeInput as DelegationEdgeInput, type protocol_DelegationEndpoint as DelegationEndpoint, protocol_createAgentBus as createAgentBus, protocol_createDelegationChain as createDelegationChain, protocol_createDelegationEdge as createDelegationEdge, protocol_isValidSurfaceId as isValidSurfaceId };
+}
+
+/**
+ * MCP Sampling Support (MCP Specification 2025-11-25)
+ *
+ * Enables MCP servers to request LLM completions from clients.
+ * This allows servers to execute agentic loops using the user's tokens
+ * while maintaining user control over model interactions.
+ *
+ * @specification MCP 2025-11-25
+ * @see https://modelcontextprotocol.io/specification/2025-11-25/client/sampling
+ */
+interface MCPSamplingCapabilities {
+    /** Whether sampling is enabled */
+    enabled: boolean;
+    /** Available models for sampling */
+    models?: string[];
+    /** Maximum tokens per request */
+    maxTokens?: number;
+    /** Supported sampling parameters */
+    supportedParams?: string[];
+}
+
+/** JSON Schema type for tool input/output definitions */
+type JSONSchemaType = Record<string, unknown>;
+/** Metadata record for MCP requests/responses */
+type MCPMetadata = Record<string, unknown>;
+/** Server process reference type - can be ChildProcess or any spawned process */
+type MCPServerProcess = {
+    kill: () => void;
+    stdin?: unknown;
+    stdout?: unknown;
+    stderr?: unknown;
+};
+interface MCPServer {
+    id: string;
+    name: string;
+    package: string;
+    status: "disconnected" | "starting" | "connected" | "error";
+    client?: Client;
+    transport?: StdioClientTransport;
+    tools?: MCPTool[];
+    resources?: MCPResource[];
+    prompts?: MCPPrompt[];
+    lastError?: string;
+    process?: MCPServerProcess;
+    command?: string;
+    args?: string[];
+    protocolVersion?: string;
+    capabilities?: MCPServerCapabilities;
+    oauth?: MCPOAuthConfig;
+}
+interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: JSONSchemaType;
+    outputSchema?: JSONSchemaType;
+    serverId: string;
+    serverName: string;
+    icon?: string;
+    category?: string;
+    _meta?: MCPMetadata;
+}
+interface MCPResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+    icon?: string;
+    _meta?: MCPMetadata;
+}
+/** Prompt argument definition */
+interface MCPPromptArgument {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+interface MCPPrompt {
+    name: string;
+    description?: string;
+    arguments?: MCPPromptArgument[];
+    icon?: string;
+    _meta?: MCPMetadata;
+}
+interface MCPServerCapabilities {
+    experimental?: Record<string, unknown>;
+    elicitation?: boolean;
+    structuredContent?: boolean;
+    resourceLinks?: boolean;
+    sampling?: boolean | MCPSamplingCapabilities;
+    roots?: boolean;
+    tasks?: boolean;
+}
+interface MCPOAuthConfig {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    clientId?: string;
+    scopes?: string[];
+    resourceServer?: boolean;
+    resourceIndicators?: string[];
+}
+
+/**
+ * A2A Protocol Module (v0.3+)
+ * Agent-to-Agent communication protocol (Linux Foundation AAIF standard)
+ *
+ * This module provides a comprehensive implementation of the A2A protocol for
+ * inter-agent communication within Terminals.tech.
+ *
+ * **Features:**
+ * - Agent card registration and discovery
+ * - Capability-based agent lookup
+ * - Message validation against agent capabilities
+ * - gRPC transport support (v0.3)
+ * - Streaming via SSE (v0.3)
+ * - Push notifications (v0.3)
+ * - Extensions mechanism (v0.3)
+ * - Security card signing (v0.3)
+ * - QuerySkill() dynamic discovery (Q1 2026)
+ *
+ * **Reference:** https://github.com/google-a2a/A2A
+ * @module a2a
+ * @version 0.3+
+ */
+/**
+ * Agent card describing capabilities and endpoints (v0.3+)
+ */
+interface A2AAgentCard {
+    /** Unique agent identifier */
+    id: string;
+    /** Human-readable agent name */
+    name: string;
+    /** Agent description */
+    description: string;
+    /** List of agent capabilities */
+    capabilities: A2ACapability[];
+    /** Communication endpoints */
+    endpoints: A2AEndpoint[];
+    /** Agent version */
+    version: string;
+    /** Protocol version */
+    protocol: "a2a/1.0" | "a2a/0.3";
+    /** Extended capabilities (v0.3+) */
+    extendedCapabilities?: {
+        streaming: boolean;
+        pushNotifications: boolean;
+        stateTransitionHistory: boolean;
+    };
+    /** Supported extensions (v0.3+) */
+    extensions?: A2AExtension[];
+    /** Push notification endpoint (v0.3+) */
+    pushNotificationEndpoint?: string;
+    /** Security signature (v0.3+) */
+    signature?: string;
+    signedAt?: number;
+    publicKey?: string;
+}
+/**
+ * Agent capability definition
+ */
+interface A2ACapability {
+    /** Capability name */
+    name: string;
+    /** Capability description */
+    description: string;
+    /** Optional JSON schema for inputs */
+    inputSchema?: Record<string, unknown>;
+    /** Optional JSON schema for outputs */
+    outputSchema?: Record<string, unknown>;
+}
+/**
+ * Agent communication endpoint (v0.3+ with gRPC)
+ */
+interface A2AEndpoint {
+    /** Endpoint protocol type */
+    type: "http" | "ws" | "grpc";
+    /** Endpoint URL */
+    url: string;
+    /** Optional authentication configuration */
+    authentication?: A2AAuth;
+    /** gRPC service definition (for grpc type) */
+    protoFile?: string;
+    /** gRPC package name */
+    packageName?: string;
+    /** gRPC service name */
+    serviceName?: string;
+}
+/**
+ * Authentication configuration for endpoints
+ */
+interface A2AAuth {
+    /** Authentication type */
+    type: "bearer" | "api-key" | "oauth2" | "none";
+    /** Optional authentication configuration */
+    config?: Record<string, unknown>;
+}
+/**
+ * A2A protocol message
+ */
+interface A2AMessage {
+    /** Unique message identifier */
+    id: string;
+    /** Source agent ID */
+    from: string;
+    /** Target agent ID */
+    to: string;
+    /** Message type */
+    type: "request" | "response" | "notification" | "error";
+    /** Capability being invoked */
+    capability: string;
+    /** Message payload */
+    payload: unknown;
+    /** Message timestamp (milliseconds since epoch) */
+    timestamp: number;
+    /** Optional correlation ID for request-response pairing */
+    correlationId?: string;
+    /** Optional additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * A2A Extension (v0.3+)
+ *
+ * Extensions allow agents to declare support for custom capabilities
+ * beyond the base protocol.
+ */
+interface A2AExtension {
+    /** Extension name */
+    name: string;
+    /** Extension version */
+    version: string;
+    /** Extension description */
+    description?: string;
+    /** Extension methods */
+    methods: Array<{
+        name: string;
+        description?: string;
+        inputSchema: Record<string, unknown>;
+        outputSchema: Record<string, unknown>;
+    }>;
+}
+
+/**
+ * String literal type for high-level message types
+ */
+type AxonMessageTypeString = "command" | "event" | "query" | "response";
+/**
+ * Protocol type for message routing
+ */
+type AxonProtocolType = "mcp" | "a2a" | "internal";
+/**
+ * High-level AXON message for JSON-based protocol communication.
+ *
+ * @deprecated Use `SDKMessage` from `../core/primitives/message` instead.
+ * This type is maintained for backward compatibility with existing code.
+ * SDKMessage is the canonical message type across all SDK layers.
+ *
+ * Migration path:
+ * - Replace `HighLevelAxonMessage` imports with `SDKMessage`
+ * - Use `createMessage()` or helpers from message.ts
+ * - For source/target, use `SDKAddress` instead of plain strings
+ *
+ * For binary/low-level communication, use AxonMessage instead.
+ */
+interface HighLevelAxonMessage {
+    id: string;
+    type: AxonMessageTypeString;
+    source: string;
+    target: string;
+    payload: unknown;
+    meta: {
+        timestamp: number;
+        traceId: string;
+        priority?: number;
+        /** @deprecated Use SDKMessage.meta.correlationId */
+        correlationId?: string;
+        /** @deprecated Use SDKMessage.meta.ttl */
+        ttl?: number;
+        /** @deprecated Use SDKMessage.meta.sessionId */
+        sessionId?: string;
+        /** @deprecated Use SDKMessage.meta.interactionId */
+        interactionId?: string;
+    };
+    protocol?: {
+        type: AxonProtocolType;
+        version: string;
+        originalMessage?: unknown;
+    };
+    /**
+     * Optional capability identifier for L5 protocol compatibility.
+     * @deprecated Use SDKMessage.capability instead
+     */
+    capability?: string;
+}
+
+/**
+ * Protocol Bridge for MCP and A2A
+ *
+ * Unified bridge layer that enables interoperability between MCP servers
+ * and A2A agents, routing messages through the AXON message bus.
+ *
+ * This bridge allows:
+ * - MCP tools to be exposed as A2A capabilities
+ * - A2A agents to be accessed as MCP servers
+ * - Seamless protocol translation
+ * - Unified routing through AXON
+ */
+
+/**
+ * Re-export HighLevelAxonMessage as AxonMessage for backward compatibility.
+ *
+ * @deprecated Use SDKMessage from '../core/primitives/message' instead.
+ * This alias will be removed in a future version.
+ */
+type AxonMessage = HighLevelAxonMessage;
+/** MCP message structure */
+interface MCPMessage {
+    method?: string;
+    params?: Record<string, unknown>;
+    id?: string;
+}
+/**
+ * Protocol Bridge
+ *
+ * Translates between MCP, A2A, and AXON protocols
+ */
+declare class ProtocolBridge {
+    private mcpToA2AMap;
+    private a2aToMCPMap;
+    private axonBus?;
+    constructor(axonBus?: AxonMessageBus);
+    /**
+     * Set AXON message bus
+     */
+    setAxonBus(bus: AxonMessageBus): void;
+    /**
+     * Convert MCP tool to A2A capability
+     */
+    mcpToolToA2ACapability(tool: MCPTool): A2ACapability;
+    /**
+     * Convert MCP server to A2A agent card
+     */
+    mcpServerToA2AAgent(server: MCPServer): A2AAgentCard;
+    /**
+     * Convert A2A capability to MCP tool
+     */
+    a2aCapabilityToMCPTool(capability: A2ACapability, agentId: string, agentName: string): MCPTool;
+    /**
+     * Convert A2A agent to MCP server facade
+     */
+    a2aAgentToMCPServer(agent: A2AAgentCard): MCPServer;
+    /**
+     * Register an MCP server facade
+     */
+    registerMCPServer(server: MCPServer): void;
+    /**
+     * Register an A2A agent facade
+     */
+    registerA2AAgent(agent: A2AAgentCard): void;
+    /**
+     * Route message through AXON
+     * @returns true if message was routed, false if rejected due to validation failure
+     */
+    route(message: AxonMessage): Promise<boolean>;
+    /**
+     * Convert MCP message to AXON message
+     */
+    mcpMessageToAxon(mcpMessage: MCPMessage, source: string, target: string): AxonMessage;
+    /**
+     * Convert A2A message to AXON message
+     */
+    a2aMessageToAxon(a2aMessage: A2AMessage): AxonMessage;
+    /**
+     * Convert AXON message to MCP message
+     *
+     * SECURITY: Uses secureValidate to prevent unsafe type assertions at protocol boundaries.
+     * All external data is validated before use.
+     */
+    axonToMCPMessage(axonMessage: AxonMessage): MCPMessage;
+    /**
+     * Convert AXON message to A2A message
+     *
+     * SECURITY: Uses secureValidate to prevent unsafe type assertions at protocol boundaries.
+     * All external data is validated before use.
+     */
+    axonToA2AMessage(axonMessage: AxonMessage): A2AMessage;
+    /**
+     * Get mapping from MCP server ID to A2A agent ID
+     */
+    getMCPToA2AMapping(mcpServerId: string): string | undefined;
+    /**
+     * Get mapping from A2A agent ID to MCP server ID
+     */
+    getA2AToMCPMapping(a2aAgentId: string): string | undefined;
+    /**
+     * Clear all mappings
+     */
+    clearMappings(): void;
+    private routeMCPMessage;
+    private routeA2AMessage;
+    private mapA2ATypeToAxon;
+    private mapAxonTypeToA2A;
+}
+/**
+ * AXON Message Bus Interface
+ *
+ * Simplified interface for message bus integration.
+ * Supports both legacy AxonMessage and canonical SDKMessage formats.
+ */
+interface AxonMessageBus {
+    /**
+     * @deprecated Use publishSDK for canonical SDKMessage support
+     */
+    publish(message: AxonMessage): Promise<void>;
+    /**
+     * @deprecated Use subscribeSDK for canonical SDKMessage support
+     */
+    subscribe(topic: string, handler: (message: AxonMessage) => Promise<void>): () => void;
+    unsubscribe(topic: string): void;
+}
+/**
+ * Extended AXON Message Bus Interface with SDKMessage support
+ *
+ * Provides first-class support for the canonical SDKMessage type
+ * while maintaining backward compatibility with AxonMessage.
+ */
+interface SDKMessageBus extends AxonMessageBus {
+    /** Publish a canonical SDKMessage */
+    publishSDK<P = unknown>(message: SDKMessage<P>): Promise<void>;
+    /** Subscribe to SDKMessage events */
+    subscribeSDK<P = unknown>(topic: string, handler: (message: SDKMessage<P>) => Promise<void>): () => void;
+}
+/**
+ * Simple in-memory AXON message bus implementation
+ *
+ * Implements both AxonMessageBus (legacy) and SDKMessageBus (canonical) interfaces.
+ * Internally stores SDKMessage and converts as needed for legacy handlers.
+ */
+declare class InMemoryAxonBus implements SDKMessageBus {
+    private subscribers;
+    private sdkSubscribers;
+    /**
+     * Publish a legacy AxonMessage
+     * @deprecated Use publishSDK for canonical SDKMessage support
+     */
+    publish(message: AxonMessage): Promise<void>;
+    /**
+     * Publish a canonical SDKMessage
+     */
+    publishSDK<P = unknown>(message: SDKMessage<P>): Promise<void>;
+    /**
+     * Subscribe to legacy AxonMessage events
+     * @deprecated Use subscribeSDK for canonical SDKMessage support
+     */
+    subscribe(topic: string, handler: (message: AxonMessage) => Promise<void>): () => void;
+    /**
+     * Subscribe to canonical SDKMessage events
+     */
+    subscribeSDK<P = unknown>(topic: string, handler: (message: SDKMessage<P>) => Promise<void>): () => void;
+    unsubscribe(topic: string): void;
+    private publishToTopic;
+    private publishSDKToTopic;
+    getStats(): {
+        topics: number;
+        totalHandlers: number;
+        sdkHandlers: number;
+    };
+}
+/**
+ * Create a protocol bridge instance
+ */
+declare function createProtocolBridge(axonBus?: AxonMessageBus): ProtocolBridge;
+/**
+ * Create an in-memory AXON bus
+ */
+declare function createAxonBus(): InMemoryAxonBus;
+
+/**
+ * @terminals-tech/sdk
+ *
+ * Curated package facade for the npm package.
+ */
+declare const SDK_VERSION = "1.0.0-rc.1";
+
+export { type AxonMessage, type AxonMessageBus, brain as Brain, type CoherenceConfig, type CoherenceInput, type CoherenceMetrics, type CoherenceResult, core as Core, InMemoryAxonBus, type KuramotoStepOptions, index as L0, mesh as Mesh, type OrderParameter, protocol as Protocol, ProtocolBridge, SDK_VERSION, terminal as Terminal, calculateCoherence, calculateCoherenceWithExplanations, createAxonBus, createProtocolBridge, getCoherenceSuggestions, isCoherent, kuramotoStep, orderParameter, phaseLockingValue, wrapTo2Pi, wrapToPi };