@a0n/aeon 5.0.1

package/dist/index.d.ts

@@ -0,0 +1,1953 @@
+export { BandwidthProfile, CRDTOperation, ConflictDetectionResult, EventCallback, EventUnsubscribe, IEventEmitter, NetworkState, Operation, OperationPriority, OperationStatus, OperationType, PresenceEmotion, PresenceInfo, PresenceInputState, PresenceScroll, PresenceSelection, PresenceTyping, PresenceViewport, ResolutionStrategy, SyncBatch, SyncCoordinatorConfig, SyncResult, VectorClock } from './core/index.js';
+export { Logger, createNamespacedLogger, disableLogging, getLogger, logger, resetLogger, setLogger } from './utils/index.js';
+export { DashStorageAdapter, DashStorageAdapterHooks, DashStorageAdapterOptions, DashStorageBackend, DashStorageChange, DashSyncClient, DashSyncRule, DashSyncRules, DashSyncUrgency, InMemoryStorageAdapter } from './persistence/index.js';
+export { P as PersistedEnvelope, a as PersistenceDeserializer, b as PersistenceSerializer, S as StorageAdapter } from './types-CMxO7QF0.js';
+export { CompatibilityRule, DataTransformer, FieldTransformer, Migration, MigrationEngine, MigrationIntegrityEntry, MigrationRecord, MigrationResult, MigrationState, MigrationTracker, MigrationTrackerOptions, MigrationTrackerPersistenceConfig, MigrationTrackerPersistenceData, RollbackPath, SchemaVersion, SchemaVersionManager, TransformationResult, TransformationRule, VersionMetadata } from './versioning/index.js';
+export { Handshake, MergeStrategy, ProtocolError, ReconciliationResult, RecordPathObservationInput, RecordShardObservationInput, RecoveryConflict, RecoveryLedger, RecoveryLedgerConfig, RecoveryLedgerSnapshot, RecoveryPathObservation, RecoveryPathStatus, RecoveryShardObservation, RecoveryShardRole, RecoveryStatus, Replica, ReplicationEvent, ReplicationManager, ReplicationManagerOptions, ReplicationPersistenceConfig, ReplicationPersistenceData, ReplicationPolicy, StateDiff, StateReconciler, StateVersion, SyncCoordinator, SyncEvent, SyncMessage, SyncNode, SyncProtocol, SyncProtocolOptions, SyncProtocolPersistenceConfig, SyncProtocolPersistenceData, SyncRequest, SyncResponse, SyncSession } from './distributed/index.js';
+export { OfflineOperation, OfflineOperationQueue, OfflineOperationQueueOptions, OfflineQueueEvents, OfflineQueuePersistenceConfig, OfflineQueueStats, getOfflineOperationQueue, resetOfflineOperationQueue } from './offline/index.js';
+export { BUILTIN_CODECS, BrotliCodec, ChunkResult, CompressedBatch, CompressedChunk, CompressionCodec, CompressionEngine, CompressionStats, DeltaBatch, DeltaCodec, DeltaOperation, DeltaStats, DeltaSyncOptimizer, DictionaryCodec, GzipCodec, HuffmanCodec, LZ77Codec, PURE_JS_CODECS, RLECodec, RawCodec, TopologicalCompressionResult, TopologicalCompressor, TopologicalCompressorConfig, getCodecById, getCompressionEngine, getDeltaSyncOptimizer, resetCompressionEngine, resetDeltaSyncOptimizer } from './compression/index.js';
+export { ActivityPattern, AdaptiveCompressionOptimizer, AdaptiveStats, BatchTimingOptimizer, BatchTimingStats, CompressionRecommendation, DeviceProfile, NetworkProfile, NetworkWindow, OperationPattern, OperationPrediction, PrefetchedBatch, PrefetchingEngine, PrefetchingStats, SchedulingDecision, getAdaptiveCompressionOptimizer, getBatchTimingOptimizer, getPrefetchingEngine, resetAdaptiveCompressionOptimizer, resetBatchTimingOptimizer, resetPrefetchingEngine } from './optimization/index.js';
+export { AgentEmotionState, AgentInputState, AgentPresence, AgentPresenceManager, AgentScrollState, AgentSelectionRange, AgentTypingState, AgentViewportState, PresenceEvents, PresenceUpdate, clearAgentPresenceManager, getAgentPresenceManager } from './presence/index.js';
+export { A as AEON_CAPABILITIES, a as AeonCapability, b as AeonCapabilityResult, c as AeonCryptoConfig, d as AeonEncryptionMode, e as AuthenticatedMessageFields, C as Capability, D as DEFAULT_CRYPTO_CONFIG, f as DID, g as DecryptionResult, h as DomainCategory, E as ECKeyPair, i as EncryptedPayload, j as EncryptionAlgorithm, I as ICryptoProvider, k as Identity, K as KeyPair, N as NullCryptoProvider, S as SecureNodeInfo, l as SecureSyncSession, m as SignedSyncData, n as SigningAlgorithm, U as UCANPayload, o as UCANToken, V as VerificationResult } from './CryptoProvider-SLWjqByk.js';
+export { ITransactionSigner, NullTransactionSigner, TransactionSignerErrorCode, TransactionSignerExecuteRequest, TransactionSignerExecuteResponse, TransactionSignerHealth, TransactionSignerMetadata, TransactionSignerPayloadMap, createTransactionSignerAdapter } from './crypto/index.js';
+import 'eventemitter3';
+
+/**
+ * Aeon Flow Protocol — Type Definitions
+ *
+ * The Aeon Flow Protocol extracts the fork/race/fold primitive that
+ * appears independently across the entire stack (inference, ESI, sync,
+ * shell, frontend) into a unified, protocol-level abstraction with a
+ * pure binary wire format.
+ *
+ * @see docs/ebooks/145-log-rolling-pipelined-prefill/ch14-aeon-flow-protocol.md
+ */
+/** Fork: opens child streams from a parent */
+declare const FORK = 1;
+/** Race: marks streams as racing — first to complete wins */
+declare const RACE = 2;
+/** Fold: merge results from multiple streams into one */
+declare const FOLD = 4;
+/** Vent: NaN propagation, error, or cancellation */
+declare const VENT = 8;
+/** Fin: stream is complete, no more frames will be sent */
+declare const FIN = 16;
+/** Poison: stream is terminated due to error or cancellation */
+declare const POISON = 32;
+/**
+ * A single frame on the wire.
+ *
+ * FlowFrame {
+ *   stream_id: u16      // multiplexed stream identifier
+ *   sequence:  u32      // position within stream
+ *   flags:     u8       // FORK | RACE | FOLD | VENT | FIN
+ *   length:    u24      // payload length (up to 16MB)
+ *   payload:   [u8]     // raw bytes
+ * }
+ *
+ * Total header: 10 bytes.
+ */
+interface FlowFrame {
+    /** Multiplexed stream identifier (u16, 0–65535) */
+    streamId: number;
+    /** Sequence number within the stream (u32) */
+    sequence: number;
+    /** Bitfield of frame flags (FORK, RACE, FOLD, VENT, FIN) */
+    flags: number;
+    /** Raw payload bytes */
+    payload: Uint8Array;
+}
+/** Stream lifecycle states */
+type FlowStreamState = 'open' | 'racing' | 'folding' | 'closed' | 'vented';
+/**
+ * A logical stream within the protocol.
+ *
+ * Streams form a tree: fork() creates children, race()/fold()
+ * operate on sibling streams, vent() propagates down the tree.
+ */
+interface FlowStream {
+    /** Stream identifier (even = client-initiated, odd = server-initiated) */
+    id: number;
+    /** Current lifecycle state */
+    state: FlowStreamState;
+    /** Parent stream that forked this one (undefined for root streams) */
+    parent?: number;
+    /** Child streams forked from this one */
+    children: number[];
+    /** Next sequence number to assign */
+    nextSequence: number;
+    /** Number of frames buffered (for backpressure) */
+    bufferedFrames: number;
+    /** Accumulated result frames (for race/fold) */
+    results: Uint8Array[];
+}
+/**
+ * Transport-agnostic interface for sending/receiving binary data.
+ *
+ * Implementations exist for WebSocket, TCP, WebRTC DataChannel, IPC,
+ * and in-memory (for testing).
+ */
+interface FlowTransport {
+    /** Send binary data over the transport */
+    send(data: Uint8Array): void;
+    /** Register a handler for incoming data */
+    onReceive(handler: (data: Uint8Array) => void): void;
+    /** Close the transport */
+    close(): void;
+}
+/**
+ * Configuration for the Aeon Flow Protocol.
+ */
+interface FlowProtocolConfig {
+    /**
+     * Per-stream high-water mark for backpressure.
+     * When a stream has this many unacknowledged frames buffered,
+     * sends are paused until the remote drains.
+     * @default 64
+     */
+    highWaterMark: number;
+    /**
+     * Whether this side initiates even-numbered streams (client)
+     * or odd-numbered streams (server). Like HTTP/2.
+     * @default 'client'
+     */
+    role: 'client' | 'server';
+    /**
+     * Maximum number of concurrent open streams.
+     * @default 256
+     */
+    maxConcurrentStreams: number;
+}
+/**
+ * Default protocol configuration.
+ */
+declare const DEFAULT_FLOW_CONFIG: FlowProtocolConfig;
+/**
+ * Events emitted by the protocol.
+ */
+interface FlowProtocolEvents {
+    /** A new frame arrived on a stream */
+    frame: {
+        streamId: number;
+        frame: FlowFrame;
+    };
+    /** A stream reached the FIN state */
+    streamEnd: {
+        streamId: number;
+    };
+    /** A stream was vented */
+    streamVented: {
+        streamId: number;
+    };
+    /** Backpressure: stream is paused */
+    streamPaused: {
+        streamId: number;
+    };
+    /** Backpressure: stream is resumed */
+    streamResumed: {
+        streamId: number;
+    };
+}
+
+/**
+ * Aeon Flow Protocol — Stream Multiplexing with Fork/Race/Fold
+ *
+ * The Flow Layer sits between the Frame Layer (FlowCodec) and the
+ * Application Layer (inference, ESI, sync, shell, speculate). It manages
+ * multiplexed streams with three protocol-level primitives:
+ *
+ * - **Fork**: Create N child streams from a parent stream. Each child
+ *   runs independently. Used for parallel pipelines, fragment fetching,
+ *   reality branching.
+ *
+ * - **Race**: Mark streams as racing. The first to send a FIN frame wins.
+ *   Losers are automatically vented. Used for speculative decoding,
+ *   cache races, A/B testing.
+ *
+ * - **Fold**: Wait for all streams to complete (or vent), then
+ *   merge their results via a caller-provided function. Used for shard
+ *   assembly, fragment stitching, branch reconciliation.
+ *
+ * Stream IDs: even = client-initiated, odd = server-initiated (like HTTP/2).
+ * Backpressure via per-stream high-water mark (configurable, default 64).
+ * Vent propagates from parent to all descendants.
+ *
+ * @see docs/ebooks/145-log-rolling-pipelined-prefill/ch14-aeon-flow-protocol.md
+ */
+
+type FrameHandler = (frame: FlowFrame) => void;
+type VoidHandler = () => void;
+/**
+ * AeonFlowProtocol
+ *
+ * Manages multiplexed binary streams over a transport with
+ * fork/race/fold semantics.
+ */
+declare class AeonFlowProtocol {
+    private streams;
+    private nextEvenId;
+    private nextOddId;
+    private codec;
+    private transport;
+    private config;
+    private frameHandlers;
+    private endHandlers;
+    private ventHandlers;
+    private raceGroups;
+    private foldGroups;
+    constructor(transport: FlowTransport, config?: Partial<FlowProtocolConfig>);
+    /**
+     * Open a new root stream (no parent).
+     *
+     * Client-initiated streams get even IDs; server-initiated get odd IDs.
+     */
+    openStream(): number;
+    /**
+     * Get the current state of a stream.
+     */
+    getStream(streamId: number): FlowStream | undefined;
+    /**
+     * Get all active streams.
+     */
+    getActiveStreams(): FlowStream[];
+    /**
+     * Fork a parent stream into N child streams.
+     *
+     * Each child stream is independent and can send/receive frames.
+     * The parent tracks all children. Venting the parent vents all children.
+     *
+     * @param parentStreamId The stream to fork from
+     * @param count Number of child streams to create
+     * @returns Array of child stream IDs
+     */
+    fork(parentStreamId: number, count: number): number[];
+    /**
+     * Race multiple streams. The first to send a FIN frame wins.
+     * All other streams in the race are automatically vented.
+     *
+     * @param streamIds Streams to race (must all be open)
+     * @returns Promise resolving with the winner's stream ID and final payload
+     */
+    race(streamIds: number[]): Promise<{
+        winner: number;
+        result: Uint8Array;
+    }>;
+    /**
+     * Fold multiple streams: wait for all to complete (or vent),
+     * then merge their results.
+     *
+     * @param streamIds Streams to fold
+     * @param merger Function that merges results from all streams
+     * @returns Promise resolving with the merged result
+     */
+    fold(streamIds: number[], merger: (results: Map<number, Uint8Array>) => Uint8Array): Promise<Uint8Array>;
+    /**
+     * Send a payload on a stream.
+     */
+    send(streamId: number, payload: Uint8Array, flags?: number): void;
+    /**
+     * Finish a stream. Sends a FIN frame and transitions to 'closed'.
+     *
+     * @param streamId Stream to finish
+     * @param finalPayload Optional final payload to include with the FIN
+     */
+    finish(streamId: number, finalPayload?: Uint8Array): void;
+    /**
+     * Vent a stream. Sends a VENT frame and propagates to all descendants.
+     *
+     * Venting is the protocol-level equivalent of NaN propagation,
+     * AbortSignal cancellation, or error cascading.
+     */
+    vent(streamId: number): void;
+    /**
+     * Register a handler for frames arriving on a specific stream.
+     */
+    onFrame(streamId: number, handler: FrameHandler): () => void;
+    /**
+     * Register a handler for when a stream ends (FIN received).
+     */
+    onStreamEnd(streamId: number, handler: VoidHandler): () => void;
+    /**
+     * Register a handler for when a stream is vented.
+     */
+    onStreamVented(streamId: number, handler: VoidHandler): () => void;
+    /**
+     * Close the protocol and underlying transport.
+     * Vents all open streams first.
+     */
+    destroy(): void;
+    private handleIncoming;
+    private handleFrame;
+    private settleRace;
+    private settleFold;
+    private allocateStreamId;
+    private createStream;
+    private requireStream;
+    private sendFrame;
+    private concatenateResults;
+    /**
+     * Attempt to upgrade to WASM codec without delaying protocol startup.
+     * JS codec remains the correctness path if WASM is unavailable.
+     */
+    private upgradeCodecInBackground;
+}
+
+/**
+ * Aeon Flow Codec — Binary Frame Layer
+ *
+ * Encodes and decodes FlowFrames into a compact 10-byte header + payload
+ * binary wire format. Optionally accelerated by WASM; falls back to pure JS.
+ *
+ * Wire format (10 bytes header):
+ *   [0..1]  stream_id  u16 big-endian
+ *   [2..5]  sequence   u32 big-endian
+ *   [6]     flags      u8
+ *   [7..9]  length     u24 big-endian (payload bytes, max 16 MB)
+ *
+ * The codec is zerocopy where possible: decode returns a Uint8Array view
+ * into the original buffer rather than copying payload bytes.
+ *
+ * @see docs/ebooks/145-log-rolling-pipelined-prefill/ch14-aeon-flow-protocol.md
+ */
+
+/** Header size in bytes */
+declare const HEADER_SIZE = 10;
+/** Maximum payload length (2^24 - 1 = 16,777,215 bytes ≈ 16 MB) */
+declare const MAX_PAYLOAD_LENGTH = 16777215;
+type WasmMode = 'auto' | 'off' | 'force';
+type WasmModuleInput = WebAssembly.Module | BufferSource;
+interface FlowCodecCreateOptions {
+    /**
+     * WASM mode:
+     * - auto: try WASM, fallback to JS on any failure (default)
+     * - off: force JS path
+     * - force: require WASM, throw if unavailable
+     */
+    wasmMode?: WasmMode;
+    /**
+     * Optional caller-supplied WASM module or bytes.
+     * Useful in Node/Bun where the caller controls file loading.
+     */
+    wasmModule?: WasmModuleInput;
+}
+/**
+ * FlowCodec — binary encoder/decoder for FlowFrames.
+ *
+ * Create via `FlowCodec.create()` which attempts WASM acceleration,
+ * falling back to the pure JS path (which is always available).
+ */
+declare class FlowCodec {
+    private wasmInstance;
+    private wasmState;
+    private constructor();
+    /**
+     * Create a FlowCodec. Tries WASM acceleration, falls back to JS.
+     * The JS path is always correct — WASM is a performance optimization only.
+     */
+    static create(options?: FlowCodecCreateOptions): Promise<FlowCodec>;
+    /**
+     * Create a FlowCodec synchronously (JS-only, no WASM attempt).
+     */
+    static createSync(): FlowCodec;
+    /**
+     * Whether WASM acceleration is active.
+     */
+    get isWasmAccelerated(): boolean;
+    /**
+     * Encode a single FlowFrame into a binary buffer.
+     *
+     * Returns a new Uint8Array containing the 10-byte header followed by
+     * the payload bytes.
+     */
+    encode(frame: FlowFrame): Uint8Array;
+    /**
+     * Decode a single FlowFrame from a buffer at the given offset.
+     *
+     * The returned frame's `payload` is a zerocopy view into the original
+     * buffer — no data is copied. Callers who need the payload to outlive
+     * the original buffer should `.slice()` it.
+     *
+     * @returns The decoded frame and the number of bytes consumed.
+     */
+    decode(buffer: Uint8Array, offset?: number): {
+        frame: FlowFrame;
+        bytesRead: number;
+    };
+    /**
+     * Encode multiple frames into a single contiguous buffer.
+     *
+     * Frames are laid out sequentially: [header+payload][header+payload]...
+     */
+    encodeBatch(frames: FlowFrame[]): Uint8Array;
+    /**
+     * Decode all frames from a contiguous buffer.
+     *
+     * Payloads are zerocopy views into the original buffer.
+     */
+    decodeBatch(buffer: Uint8Array): FlowFrame[];
+    private decodeHeader;
+    private decodeHeaderInJavaScript;
+    private decodeHeaderWithWasm;
+    private refreshWasmViews;
+    private static createWasmState;
+    private static instantiateWasm;
+    private static toUint8Array;
+    private static loadDefaultWasmModule;
+}
+
+/**
+ * Frame Reassembler — Out-of-Order Frame Reconstruction
+ *
+ * Over TCP/WebSocket, frames arrive in order. Over UDP, they don't.
+ * The flow header's stream_id (u16) + sequence (u32) already carry
+ * the information needed to reassemble — this module uses it.
+ *
+ * Per-stream reorder buffer with configurable window. Frames arriving
+ * out of order are buffered until the gap fills. Frames arriving
+ * beyond the window are dropped (assumed lost, will be retransmitted).
+ *
+ * This is the same insight as QUIC: per-stream ordering eliminates
+ * head-of-line blocking across streams. Stream A's lost packet doesn't
+ * block Stream B. Only Stream A waits for its own retransmission.
+ */
+
+interface ReassemblerConfig {
+    /**
+     * Maximum number of frames to buffer per stream while waiting
+     * for gaps to fill. Frames beyond this are dropped.
+     * @default 256
+     */
+    maxBufferPerStream: number;
+    /**
+     * Maximum number of tracked streams. Oldest streams are evicted
+     * when this limit is reached.
+     * @default 1024
+     */
+    maxStreams: number;
+    /**
+     * Maximum gap in sequence numbers before declaring frames lost.
+     * If we receive seq 10 but are expecting seq 3, and gap > maxGap,
+     * we skip ahead and emit what we have.
+     * @default 64
+     */
+    maxGap: number;
+}
+interface ReassemblerStats {
+    /** Total frames received */
+    framesReceived: number;
+    /** Frames delivered in order */
+    framesDelivered: number;
+    /** Frames currently buffered (waiting for gaps) */
+    framesBuffered: number;
+    /** Frames dropped (duplicates or beyond window) */
+    framesDropped: number;
+    /** Frames reordered (delivered from buffer after gap fill) */
+    framesReordered: number;
+    /** Active streams being tracked */
+    activeStreams: number;
+}
+declare class FrameReassembler {
+    private config;
+    private streams;
+    private stats;
+    constructor(config?: Partial<ReassemblerConfig>);
+    /**
+     * Process an incoming frame. Returns an array of frames that are
+     * now deliverable in order. May return 0 frames (buffered), 1 frame
+     * (in order), or multiple frames (gap was filled, releasing buffered).
+     *
+     * This is the core reassembly operation:
+     *   - In-order frame → deliver immediately + flush any buffered followers
+     *   - Out-of-order frame → buffer until gap fills
+     *   - Duplicate → drop
+     *   - Beyond window → drop
+     */
+    push(frame: FlowFrame): FlowFrame[];
+    /**
+     * Get the sequence numbers that are missing (gaps) for a stream.
+     * Used by the reliability layer to request retransmission.
+     */
+    getMissingSequences(streamId: number): number[];
+    /**
+     * Clean up a stream's reassembly state.
+     * Call when a stream is closed or vented.
+     */
+    closeStream(streamId: number): void;
+    /**
+     * Get current reassembly statistics.
+     */
+    getStats(): Readonly<ReassemblerStats>;
+    /**
+     * Reset all state.
+     */
+    reset(): void;
+    /**
+     * Deliver a frame and flush any consecutively-buffered followers.
+     */
+    private deliverAndFlush;
+    /**
+     * Evict the least-recently-active stream to make room.
+     */
+    private evictOldestStream;
+}
+
+/** Safe MTU for UDP datagrams (1500 Ethernet - 20 IP - 8 UDP) */
+declare const UDP_MTU = 1472;
+/** Fragment header size: [frame_id:u16][frag_index:u8][frag_total:u8] */
+declare const FRAGMENT_HEADER_SIZE = 4;
+/** Max payload per UDP datagram after fragment header */
+declare const MAX_FRAGMENT_PAYLOAD: number;
+/** ACK frame flag — not a real flow flag, internal to UDP transport */
+declare const ACK_FLAG = 128;
+interface UDPFlowTransportConfig {
+    /** Local bind address */
+    host: string;
+    /** Local bind port */
+    port: number;
+    /** Remote host (for client mode) */
+    remoteHost?: string;
+    /** Remote port (for client mode) */
+    remotePort?: number;
+    /** MTU override (default: 1472) */
+    mtu?: number;
+    /** Enable reliability (ACKs + retransmit). Default: true */
+    reliable?: boolean;
+    /** Reassembler config overrides */
+    reassembler?: {
+        maxBufferPerStream?: number;
+        maxStreams?: number;
+        maxGap?: number;
+    };
+}
+/**
+ * UDP-based FlowTransport implementation.
+ *
+ * Implements the FlowTransport interface over UDP datagrams with:
+ *   - MTU-safe fragmentation/reassembly
+ *   - Out-of-order frame reassembly (via FrameReassembler)
+ *   - Optional reliability (ACK bitmaps + selective retransmit)
+ *   - Simple AIMD congestion control
+ *
+ * The same AeonFlowProtocol instance works unchanged — it just sees
+ * frames arriving (possibly out of order, which the reassembler fixes).
+ */
+declare class UDPFlowTransport implements FlowTransport {
+    private config;
+    private receiveHandler;
+    private closed;
+    private socket;
+    private reassembler;
+    private fragmentGroups;
+    private nextFrameId;
+    private inflight;
+    private receivedPerStream;
+    private ackTimer;
+    private retransmitTimer;
+    private cwnd;
+    private inflightCount;
+    private codec;
+    constructor(config: UDPFlowTransportConfig);
+    /**
+     * Bind and start the UDP transport.
+     *
+     * In server mode (no remoteHost), listens for incoming datagrams.
+     * In client mode, binds and sets the remote endpoint.
+     */
+    bind(): Promise<void>;
+    send(data: Uint8Array): void;
+    onReceive(handler: (data: Uint8Array) => void): void;
+    close(): void;
+    /**
+     * Attempt to upgrade to WASM codec without delaying transport readiness.
+     */
+    private upgradeCodecInBackground;
+    /** Get reassembly statistics */
+    getReassemblerStats(): Readonly<ReassemblerStats>;
+    /** Current congestion window size */
+    get congestionWindow(): number;
+    /** Number of frames in flight (unacked) */
+    get framesInFlight(): number;
+    /**
+     * Handle an incoming UDP datagram.
+     *
+     * Datagram format:
+     *   [frame_id:u16][frag_index:u8][frag_total:u8][payload...]
+     */
+    private handleDatagram;
+    /**
+     * Handle a fragment of a multi-datagram flow frame.
+     */
+    private handleFragment;
+    /**
+     * Handle a complete (reassembled) flow frame.
+     * This is where we do out-of-order reassembly using the stream_id + sequence.
+     */
+    private handleReassembledFrame;
+    /**
+     * Wrap a flow frame chunk in a fragment header.
+     */
+    private wrapFragment;
+    /**
+     * Send a UDP datagram to the remote endpoint.
+     */
+    private sendDatagram;
+    /**
+     * Track a sent frame for potential retransmission.
+     */
+    private trackInflight;
+    /**
+     * Handle an incoming ACK frame.
+     *
+     * ACK payload format:
+     *   [stream_id:u16][base_seq:u32][bitmap_hi:u32][bitmap_lo:u32]
+     *   (can repeat for multiple streams)
+     */
+    private handleAck;
+    /**
+     * Send ACK bitmaps for all received sequences.
+     */
+    private sendAcks;
+    /**
+     * Retransmit frames that haven't been ACKed.
+     */
+    private retransmitLost;
+}
+/**
+ * WebTransport-based FlowTransport for browsers.
+ *
+ * WebTransport (HTTP/3) provides unreliable datagrams — essentially UDP
+ * from the browser. This adapter wraps WebTransport's datagram API with
+ * the same fragmentation and reassembly used by UDPFlowTransport.
+ *
+ * Usage:
+ *   const transport = await WebTransportFlowTransport.connect(
+ *     'https://site.example.com/.aeon/udp'
+ *   );
+ *   const protocol = new AeonFlowProtocol(transport, { role: 'client' });
+ */
+declare class WebTransportFlowTransport implements FlowTransport {
+    private wt;
+    private writer;
+    private receiveHandler;
+    private closed;
+    private reassembler;
+    private fragmentGroups;
+    private nextFrameId;
+    private codec;
+    private constructor();
+    /**
+     * Connect to a WebTransport endpoint and return a FlowTransport.
+     */
+    static connect(url: string): Promise<WebTransportFlowTransport>;
+    send(data: Uint8Array): void;
+    onReceive(handler: (data: Uint8Array) => void): void;
+    close(): void;
+    private readLoop;
+    /**
+     * Attempt to upgrade to WASM codec without delaying transport startup.
+     */
+    private upgradeCodecInBackground;
+}
+
+/**
+ * TopologyAnalyzer — Compute Betti numbers and topological deficit for DAGs
+ *
+ * Given a computation graph (nodes + edges), computes:
+ *   β₀ = connected components (independent computations)
+ *   β₁ = independent cycles / parallel paths (parallelism)
+ *   β₂ = voids (unreachable states)
+ *
+ * Then compares actual β₁ to the problem's intrinsic β₁* to produce
+ * the topological deficit Δβ — a quantitative measure of wasted parallelism.
+ *
+ * Zero dependencies. Works everywhere.
+ */
+/** A node in the computation graph */
+interface ComputationNode {
+    /** Unique identifier */
+    id: string;
+    /** Optional label for diagnostics */
+    label?: string;
+    /** Node type for structural analysis */
+    type?: 'source' | 'sink' | 'fork' | 'join' | 'process';
+}
+/** A directed edge in the computation graph */
+interface ComputationEdge {
+    /** Source node ID */
+    from: string;
+    /** Target node ID */
+    to: string;
+    /** Optional label */
+    label?: string;
+}
+/** The computation graph to analyze */
+interface ComputationGraph {
+    nodes: ComputationNode[];
+    edges: ComputationEdge[];
+    /** The problem's intrinsic Betti number — how parallel the problem COULD be */
+    intrinsicBeta1?: number;
+}
+/** Betti numbers of a computation graph */
+interface BettiNumbers {
+    /** β₀: connected components (independent computations) */
+    beta0: number;
+    /** β₁: independent cycles (parallel paths through fork/join pairs) */
+    beta1: number;
+    /** β₂: voids (estimated from unreachable states in the DAG) */
+    beta2: number;
+}
+/** A detected fork/join pair in the graph */
+interface ForkJoinPair {
+    /** The fork node (where paths diverge) */
+    forkNode: string;
+    /** The join node (where paths converge) */
+    joinNode: string;
+    /** Number of parallel paths between fork and join */
+    parallelPaths: number;
+    /** Contribution to β₁ (parallelPaths - 1) */
+    beta1Contribution: number;
+}
+/** Report on topological deficit */
+interface DeficitReport {
+    /** The problem's intrinsic β₁* */
+    intrinsicBeta1: number;
+    /** The implementation's actual β₁ */
+    actualBeta1: number;
+    /** Δβ = β₁* - β₁ (0 = optimal, >0 = wasted parallelism). Measured in Bules. */
+    deficit: number;
+    /** Utilization ratio: β₁ / β₁* (1.0 = fully utilizing natural parallelism) */
+    utilization: number;
+    /** Human-readable assessment */
+    assessment: string;
+}
+/** Complete topology report */
+interface TopologyReport {
+    /** Betti numbers */
+    betti: BettiNumbers;
+    /** Detected fork/join pairs */
+    forkJoinPairs: ForkJoinPair[];
+    /** Topological deficit (only if intrinsicBeta1 was provided) */
+    deficit?: DeficitReport;
+    /** Node count */
+    nodeCount: number;
+    /** Edge count */
+    edgeCount: number;
+    /** Is the graph a DAG? */
+    isDAG: boolean;
+    /** Pipeline Reynolds number estimate (stages / chunks) */
+    reynoldsEstimate?: number;
+}
+declare class TopologyAnalyzer {
+    /**
+     * Analyze a computation graph and produce a full topology report.
+     */
+    static analyze(graph: ComputationGraph): TopologyReport;
+    /**
+     * Quick deficit check — just the number, in Bules.
+     * Returns Δβ = intrinsicBeta1 - actualBeta1.
+     * 0 Bules = topology-matched. >0 Bules = wasted parallelism.
+     * Negative means the system has MORE parallelism than needed (over-forking).
+     */
+    static deficit(graph: ComputationGraph, intrinsicBeta1: number): number;
+    /**
+     * Build a computation graph from a fork/race/fold description.
+     * Convenience for common patterns.
+     */
+    static fromForkRaceFold(config: {
+        /** Number of forked paths */
+        forkWidth: number;
+        /** Number of pipeline stages per path */
+        stagesPerPath?: number;
+        /** The problem's intrinsic β₁* */
+        intrinsicBeta1?: number;
+    }): ComputationGraph;
+    /**
+     * Build a sequential pipeline graph (β₁ = 0).
+     * The degenerate case — Ford's assembly line.
+     */
+    static sequential(stages: number, intrinsicBeta1?: number): ComputationGraph;
+}
+
+/**
+ * TopologySampler — Runtime sampling of topological deficit
+ *
+ * Instruments a live system by recording fork/race/fold/vent events
+ * and periodically computing the topological deficit. Produces a
+ * time-series of Betti numbers and deficit measurements.
+ *
+ * Usage:
+ *   const sampler = new TopologySampler({ intrinsicBeta1: 7 });
+ *   sampler.fork('request-1', ['path-a', 'path-b', 'path-c']);
+ *   sampler.race('request-1', 'path-a');  // path-a won
+ *   sampler.vent('request-1', 'path-b');
+ *   sampler.vent('request-1', 'path-c');
+ *   sampler.fold('request-1');
+ *   const report = sampler.report();
+ *
+ * Zero dependencies. Works everywhere.
+ */
+interface SamplerConfig {
+    /** The problem's intrinsic β₁* */
+    intrinsicBeta1: number;
+    /** Maximum number of samples to retain (ring buffer). Default: 1000 */
+    maxSamples?: number;
+}
+/** A single point-in-time sample */
+interface Sample {
+    /** Timestamp (ms since epoch) */
+    timestamp: number;
+    /** Number of active forks at this moment */
+    activeForks: number;
+    /** Total parallel paths across all active forks */
+    activeParallelPaths: number;
+    /** Instantaneous β₁ (sum of parallelPaths - 1 per active fork) */
+    beta1: number;
+    /** Instantaneous deficit: β₁* - β₁ */
+    deficit: number;
+    /** Instantaneous utilization: β₁ / β₁* */
+    utilization: number;
+    /** Cumulative forks emitted */
+    totalForks: number;
+    /** Cumulative folds completed */
+    totalFolds: number;
+    /** Cumulative vents */
+    totalVents: number;
+    /** Cumulative races won */
+    totalRaces: number;
+}
+/** Aggregate report over all samples */
+interface SamplerReport {
+    /** Problem's intrinsic β₁* */
+    intrinsicBeta1: number;
+    /** Number of samples collected */
+    sampleCount: number;
+    /** Time-weighted average β₁ */
+    meanBeta1: number;
+    /** Peak β₁ observed */
+    peakBeta1: number;
+    /** Time-weighted average deficit */
+    meanDeficit: number;
+    /** Time-weighted average utilization (0–1) */
+    meanUtilization: number;
+    /** Peak utilization observed */
+    peakUtilization: number;
+    /** Total forks / folds / vents / races */
+    totals: {
+        forks: number;
+        folds: number;
+        vents: number;
+        races: number;
+    };
+    /** Vent ratio: vents / (vents + races). Higher = more exploration, lower = more exploitation */
+    ventRatio: number;
+    /** Thermodynamic efficiency estimate: races / (races + vents) ≈ W / (W + Q) */
+    efficiency: number;
+    /** Human-readable assessment */
+    assessment: string;
+    /** All retained samples (for plotting) */
+    samples: Sample[];
+}
+declare class TopologySampler {
+    private readonly config;
+    private readonly activeForks;
+    private readonly samples;
+    private totalForks;
+    private totalFolds;
+    private totalVents;
+    private totalRaces;
+    constructor(config: SamplerConfig);
+    /**
+     * Record a fork event: one computation splits into N parallel paths.
+     */
+    fork(id: string, paths: string[]): void;
+    /**
+     * Record a race result: one path won.
+     */
+    race(id: string, winnerPath: string): void;
+    /**
+     * Record a vent: a path was released (didn't win, errored, timed out).
+     */
+    vent(id: string, path: string): void;
+    /**
+     * Record a fold: computation merged to a single result.
+     */
+    fold(id: string): void;
+    /**
+     * Take a snapshot without recording an event (for periodic sampling).
+     */
+    sample(): Sample;
+    /**
+     * Get the current instantaneous deficit.
+     */
+    currentDeficit(): number;
+    /**
+     * Get the current instantaneous β₁.
+     */
+    currentBeta1(): number;
+    /**
+     * Generate the aggregate report.
+     */
+    report(): SamplerReport;
+    /**
+     * Reset all state.
+     */
+    reset(): void;
+    private recordSample;
+}
+
+interface WorthingtonWhipResult {
+    readonly shards: number;
+    readonly numerator: number;
+    readonly denominator: number;
+    readonly savingsFraction: number;
+}
+interface SpeculativeTreeResult {
+    readonly alpha: number;
+    readonly depth: number;
+    readonly expectedAccepted: number;
+    readonly denominator: number;
+}
+interface TurbulentIdleResult {
+    readonly stageCount: number;
+    readonly chunkCount: number;
+    readonly numerator: number;
+    readonly denominator: number;
+    readonly idleFraction: number;
+}
+interface FrontierFillResult {
+    readonly frontierByLayer: readonly number[];
+    readonly layerCount: number;
+    readonly frontierArea: number;
+    readonly peakFrontier: number;
+    readonly envelopeArea: number;
+    readonly frontierFill: number;
+    readonly wallaceNumber: number;
+    readonly wally: number;
+    readonly frontierDeficit: number;
+}
+interface PipelineOccupancyResult {
+    readonly stageCount: number;
+    readonly chunkCount: number;
+    readonly frontierArea: number;
+    readonly capacityArea: number;
+    readonly frontierFill: number;
+    readonly occupancyDeficit: number;
+}
+type PipelineRegime = 'laminar' | 'transitional' | 'turbulent';
+type ParallelismAction = 'expand' | 'staggered-expand' | 'hold' | 'multiplex' | 'constrain';
+interface AdaptiveParallelismPolicyResult {
+    readonly intrinsicBeta1: number;
+    readonly actualBeta1: number;
+    readonly topologyDeficit: number;
+    readonly stageCount: number;
+    readonly chunkCount: number;
+    readonly reynoldsEstimate: number;
+    readonly regime: PipelineRegime;
+    readonly frontierFill: number;
+    readonly occupancyDeficit: number;
+    readonly highOccupancyDeficit: boolean;
+    readonly action: ParallelismAction;
+    readonly rationale: string;
+}
+interface QuantumDeficitResult {
+    readonly sqrtN: number;
+    readonly searchSize: number;
+    readonly classicalDeficit: number;
+    readonly quantumDeficit: number;
+    readonly speedup: number;
+}
+interface ProtocolDeficitResult {
+    readonly streamCount: number;
+    readonly intrinsicBeta1: number;
+    readonly tcpDeficit: number;
+    readonly quicDeficit: number;
+    readonly flowDeficit: number;
+}
+interface SettlementDeficitResult {
+    readonly intrinsicBeta1: number;
+    readonly sequentialDeficit: number;
+    readonly parallelDeficit: number;
+}
+declare function worthingtonWhipSavings(shards: number): WorthingtonWhipResult;
+declare function speculativeTreeExpectedAccepted(alpha: number, depth: number): SpeculativeTreeResult;
+declare function turbulentIdleFraction(stageCount: number, chunkCount: number): TurbulentIdleResult;
+declare function frontierFill(frontierByLayer: readonly number[]): FrontierFillResult;
+declare function pipelineOccupancy(stageCount: number, chunkCount: number): PipelineOccupancyResult;
+declare function classifyPipelineRegime(stageCount: number, chunkCount: number): PipelineRegime;
+declare function adaptiveParallelismPolicy(config: {
+    intrinsicBeta1: number;
+    actualBeta1: number;
+    stageCount: number;
+    chunkCount: number;
+}): AdaptiveParallelismPolicyResult;
+declare function quantumDeficitIdentity(sqrtN: number): QuantumDeficitResult;
+declare function protocolDeficits(streamCount: number): ProtocolDeficitResult;
+declare function settlementDeficits(): SettlementDeficitResult;
+declare function beta2FromBandGap(forbiddenEnergyCount: number): number;
+declare function firstLawConserved(forkEnergy: number, foldWork: number, ventEnergy: number, tolerance?: number): boolean;
+
+type GnosisImpossibleSystemId = 'edge-pipeline-parallelism' | 'audio-token-privacy' | 'crdt-split-brain-prevention' | 'webgpu-graph-flattening';
+interface GnosisImpossibleSystemTopology {
+    readonly id: GnosisImpossibleSystemId;
+    readonly title: string;
+    readonly aeonSurface: 'flow' | 'topology' | 'federation';
+    readonly gnosisExamplePath: string;
+    readonly gnosisTestPath: string;
+    readonly summary: string;
+    readonly invariants: readonly string[];
+}
+declare const GNOSIS_IMPOSSIBLE_SYSTEM_TOPOLOGIES: readonly [{
+    readonly id: "edge-pipeline-parallelism";
+    readonly title: "Edge Pipeline Parallelism";
+    readonly aeonSurface: "federation";
+    readonly gnosisExamplePath: "open-source/gnosis/examples/edge-pipeline-parallelism.gg";
+    readonly gnosisTestPath: "open-source/gnosis/examples/impossible-systems.test.gg";
+    readonly summary: "Models a 13B request folding across layer-sharded workers that relay quantized hidden state and race a warm standby for failover.";
+    readonly invariants: readonly ["no single worker shard exceeds its annotated capacity", "the request still reaches a folded response under warm-standby failover"];
+}, {
+    readonly id: "audio-token-privacy";
+    readonly title: "Audio Token Privacy";
+    readonly aeonSurface: "flow";
+    readonly gnosisExamplePath: "open-source/gnosis/examples/audio-token-privacy.gg";
+    readonly gnosisTestPath: "open-source/gnosis/examples/impossible-systems.test.gg";
+    readonly summary: "Models semantic, prosodic, and biometric token lanes, injecting noise into identity-bearing RVQ layers before anything is folded into the public mesh.";
+    readonly invariants: readonly ["identity-bearing layers are noised before the public fold", "semantic and prosodic lanes remain part of the folded output"];
+}, {
+    readonly id: "crdt-split-brain-prevention";
+    readonly title: "CRDT Split-Brain Prevention";
+    readonly aeonSurface: "topology";
+    readonly gnosisExamplePath: "open-source/gnosis/examples/crdt-split-brain-prevention.gg";
+    readonly gnosisTestPath: "open-source/gnosis/examples/impossible-systems.test.gg";
+    readonly summary: "Models geographically separated replicas, nonce-scoped replay guards, and deterministic CRDT observation collapsing to one canonical state.";
+    readonly invariants: readonly ["replica writes carry distinct nonce identities", "deterministic CRDT observation collapses to one canonical state"];
+}, {
+    readonly id: "webgpu-graph-flattening";
+    readonly title: "WebGPU Graph Flattening";
+    readonly aeonSurface: "topology";
+    readonly gnosisExamplePath: "open-source/gnosis/examples/webgpu-graph-flattening.gg";
+    readonly gnosisTestPath: "open-source/gnosis/examples/impossible-systems.test.gg";
+    readonly summary: "Models flattening a pointer-chasing object graph into a contiguous Float32Array path that races a scattered CPU walk.";
+    readonly invariants: readonly ["the flattened buffer is contiguous Float32Array state", "the packed GPU path is explicit in the topology and races the scattered walk"];
+}];
+declare function getGnosisImpossibleSystemTopology(id: GnosisImpossibleSystemId): GnosisImpossibleSystemTopology | undefined;
+
+/**
+ * DashRelay Flow Transport
+ *
+ * FlowTransport adapter for DashRelay WebSocket relay.
+ * THE backbone transport — all Aeon data flows through DashRelay.
+ *
+ * DashRelay provides:
+ *   - Room-based pub/sub (peers join rooms by name)
+ *   - Binary broadcast to all peers in a room
+ *   - Peer discovery (join/leave events)
+ *   - Auth via API key or UCAN token
+ *   - Automatic reconnection with exponential backoff
+ *
+ * This transport wraps DashRelay's broadcast/message system as a
+ * FlowTransport interface, enabling flow protocol (fork/race/fold)
+ * over the relay mesh. Every app in the stack — forge sites, shell,
+ * inference, presence, CRDT sync — speaks Aeon flow protocol over
+ * DashRelay internally. HTTP is just the normie projection.
+ *
+ * Two modes:
+ *   1. **Room broadcast**: All peers in the room receive all flow frames.
+ *      Good for mesh networking, federated inference, presence.
+ *   2. **Directed**: Flow frames include a target peer ID header.
+ *      Good for point-to-point within a room (shell ↔ specific forge site).
+ *
+ * The transport is DashRelay-client agnostic — it takes a minimal
+ * interface so it works with any DashRelay client implementation.
+ */
+
+/**
+ * Minimal DashRelay client interface.
+ * Works with @dashrelay/client or any compatible implementation.
+ */
+interface DashRelayLike {
+    /** Broadcast binary data to all peers in the room */
+    broadcast(payload: Uint8Array): void;
+    /** Register handler for incoming messages */
+    on(event: 'message', handler: (senderId: string, payload: Uint8Array) => void): void;
+    /** Unregister handler */
+    off(event: 'message', handler: (senderId: string, payload: Uint8Array) => void): void;
+    /** Peer events */
+    on(event: 'peerJoined', handler: (peerId: string) => void): void;
+    on(event: 'peerLeft', handler: (peerId: string) => void): void;
+    off(event: 'peerJoined', handler: (peerId: string) => void): void;
+    off(event: 'peerLeft', handler: (peerId: string) => void): void;
+    /** Connection events */
+    on(event: 'connected', handler: () => void): void;
+    on(event: 'disconnected', handler: () => void): void;
+    off(event: 'connected', handler: () => void): void;
+    off(event: 'disconnected', handler: () => void): void;
+}
+interface DashRelayFlowConfig {
+    /** Target specific peer (directed mode) or broadcast to all (default) */
+    targetPeerId?: string;
+    /** This peer's ID (for filtering own messages) */
+    localPeerId?: string;
+    /** Channel tag for multiplexing multiple flow protocols in one room */
+    channel?: string;
+}
+/**
+ * FlowTransport over DashRelay broadcast.
+ *
+ * All peers in a DashRelay room receive flow frames.
+ * In directed mode, frames include a target peer ID and
+ * non-target peers ignore them.
+ *
+ * This is the primary transport for the Aeon stack.
+ * Everything talks Aeon internally over DashRelay.
+ */
+declare class DashRelayFlowTransport implements FlowTransport {
+    private relay;
+    private receiveHandler;
+    private closed;
+    private config;
+    private peerHandler;
+    /** Connected peers observed via relay events */
+    private peers;
+    private peerJoinHandler;
+    private peerLeaveHandler;
+    /** Optional handlers for peer lifecycle events */
+    onPeerJoin: ((peerId: string) => void) | null;
+    onPeerLeave: ((peerId: string) => void) | null;
+    constructor(relay: DashRelayLike, config?: DashRelayFlowConfig);
+    send(data: Uint8Array): void;
+    onReceive(handler: (data: Uint8Array) => void): void;
+    close(): void;
+    /** Get all known peers in the room */
+    getPeers(): string[];
+    /** Number of peers in the room */
+    get peerCount(): number;
+    /** Whether the transport is still open */
+    get isOpen(): boolean;
+    /** Send to a specific peer (overrides config.targetPeerId for this call) */
+    sendTo(peerId: string, data: Uint8Array): void;
+}
+/**
+ * Create a FlowTransport connected to a DashRelay room.
+ *
+ * This is the standard way to establish Aeon flow protocol
+ * over the relay mesh. Use channels to multiplex different
+ * flow protocols within the same room.
+ *
+ * @param relay - Connected DashRelay client instance
+ * @param channel - Optional channel tag for multiplexing
+ * @param config - Optional transport configuration
+ */
+declare function createDashRelayFlow(relay: DashRelayLike, channel?: string, config?: Omit<DashRelayFlowConfig, 'channel'>): DashRelayFlowTransport;
+
+/**
+ * Bluetooth Flow Transport
+ *
+ * FlowTransport adapter for Web Bluetooth API.
+ * Enables flow protocol over BLE between nearby devices —
+ * the mesh networking primitive for federated inference.
+ *
+ * Two devices running aeon-flux can fork/race inference across
+ * both browsers via Bluetooth, zero cloud cost.
+ *
+ * Uses GATT characteristics for binary frame exchange:
+ *   - TX characteristic: this device writes flow frames
+ *   - RX characteristic: this device reads flow frames
+ *
+ * MTU-aware: fragments large FlowFrames across multiple BLE writes.
+ */
+
+declare global {
+    interface BluetoothLEScanFilter {
+        services?: BluetoothServiceUUID[];
+        name?: string;
+        namePrefix?: string;
+    }
+    type BluetoothServiceUUID = string | number;
+    interface BluetoothDevice extends EventTarget {
+        readonly id: string;
+        readonly name?: string;
+        readonly gatt?: BluetoothRemoteGATTServer;
+    }
+    interface BluetoothRemoteGATTServer {
+        readonly connected: boolean;
+        readonly device: BluetoothDevice;
+        connect(): Promise<BluetoothRemoteGATTServer>;
+        disconnect(): void;
+        getPrimaryService(service: BluetoothServiceUUID): Promise<BluetoothRemoteGATTService>;
+    }
+    interface BluetoothRemoteGATTService {
+        readonly device: BluetoothDevice;
+        readonly uuid: string;
+        getCharacteristic(characteristic: string): Promise<BluetoothRemoteGATTCharacteristic>;
+    }
+    interface BluetoothRemoteGATTCharacteristic extends EventTarget {
+        readonly service: BluetoothRemoteGATTService;
+        readonly uuid: string;
+        readonly value: DataView | null;
+        writeValueWithoutResponse(value: BufferSource): Promise<void>;
+        startNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+        stopNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+    }
+    interface RequestDeviceOptions {
+        filters?: BluetoothLEScanFilter[];
+        optionalServices?: BluetoothServiceUUID[];
+        acceptAllDevices?: boolean;
+    }
+    interface Bluetooth {
+        requestDevice(options: RequestDeviceOptions): Promise<BluetoothDevice>;
+    }
+    interface Navigator {
+        bluetooth: Bluetooth;
+    }
+}
+/** Aeon Flow BLE Service UUID */
+declare const AEON_FLOW_SERVICE_UUID = "0000af10-0000-1000-8000-00805f9b34fb";
+/** TX Characteristic — write flow frames */
+declare const AEON_FLOW_TX_UUID = "0000af11-0000-1000-8000-00805f9b34fb";
+/** RX Characteristic — receive flow frames (notify) */
+declare const AEON_FLOW_RX_UUID = "0000af12-0000-1000-8000-00805f9b34fb";
+interface BluetoothFlowConfig {
+    /** BLE MTU (default: 509, negotiated at connection time) */
+    mtu?: number;
+    /** Service UUID override */
+    serviceUuid?: string;
+    /** Optional name filter for device discovery */
+    namePrefix?: string;
+}
+/**
+ * FlowTransport over Web Bluetooth GATT.
+ *
+ * Fragments flow frames to fit within BLE MTU, reassembles on receive.
+ * Uses notifications on RX characteristic for incoming frames.
+ */
+declare class BluetoothFlowTransport implements FlowTransport {
+    private config;
+    private device;
+    private txChar;
+    private rxChar;
+    private receiveHandler;
+    private mtu;
+    private closed;
+    /** Reassembly buffer for fragmented incoming frames */
+    private rxBuffer;
+    constructor(config?: BluetoothFlowConfig);
+    /**
+     * Scan for and connect to a nearby Aeon device.
+     * Returns the connected device name.
+     */
+    connect(): Promise<string>;
+    /**
+     * Create from an already-connected GATT server (for peripheral/server mode).
+     */
+    static fromCharacteristics(tx: BluetoothRemoteGATTCharacteristic, rx: BluetoothRemoteGATTCharacteristic, config?: BluetoothFlowConfig): BluetoothFlowTransport;
+    send(data: Uint8Array): void;
+    onReceive(handler: (data: Uint8Array) => void): void;
+    close(): void;
+    /** Whether Bluetooth is connected */
+    get isConnected(): boolean;
+    private writeCharacteristic;
+    private handleRxNotification;
+    private endsWithBoundary;
+}
+
+/**
+ * WebRTC Flow Transport
+ *
+ * FlowTransport adapter for WebRTC DataChannel.
+ * Enables flow protocol between browsers via DashRelay signaling —
+ * the foundation for federated browser inference.
+ *
+ * Two devices open a DataChannel via DashRelay as the signaling layer,
+ * then speak flow protocol directly peer-to-peer. The fork/race/fold
+ * primitives work across the mesh — inference forked to N peers,
+ * fastest result wins.
+ *
+ * Binary-mode DataChannel: no base64, no JSON wrapping.
+ */
+
+interface WebRTCFlowConfig {
+    /** DashRelay signaling URL (default: wss://relay.dashrelay.com) */
+    signalingUrl?: string;
+    /** Room ID for peer discovery */
+    roomId: string;
+    /** This peer's ID */
+    peerId?: string;
+    /** ICE servers (default: Google STUN) */
+    iceServers?: RTCIceServer[];
+    /** DataChannel label */
+    channelLabel?: string;
+    /** Max buffered amount before backpressure (default: 16MB) */
+    maxBufferedAmount?: number;
+}
+interface SignalingMessage {
+    type: 'offer' | 'answer' | 'ice-candidate';
+    from: string;
+    to: string;
+    payload: RTCSessionDescriptionInit | RTCIceCandidateInit;
+}
+/**
+ * FlowTransport over WebRTC DataChannel.
+ *
+ * Uses DashRelay WebSocket for signaling (offer/answer/ICE exchange),
+ * then establishes a direct peer-to-peer DataChannel for binary
+ * flow frame exchange.
+ */
+declare class WebRTCFlowTransport implements FlowTransport {
+    private pc;
+    private dc;
+    private signalingWs;
+    private receiveHandler;
+    private closed;
+    private peerId;
+    private config;
+    private maxBufferedAmount;
+    constructor(config: WebRTCFlowConfig);
+    /**
+     * Initialize as the offering peer (initiator).
+     * Connects to signaling, creates offer, waits for answer.
+     */
+    offer(): Promise<void>;
+    /**
+     * Initialize as the answering peer (responder).
+     * Waits for an offer, creates answer.
+     */
+    answer(): Promise<void>;
+    /**
+     * Wait until the DataChannel is open and ready.
+     */
+    waitForOpen(): Promise<void>;
+    send(data: Uint8Array): void;
+    onReceive(handler: (data: Uint8Array) => void): void;
+    close(): void;
+    /** Whether the DataChannel is open */
+    get isOpen(): boolean;
+    /** Get this peer's ID */
+    get id(): string;
+    private wireDataChannel;
+    private connectSignaling;
+    private sendSignaling;
+}
+/**
+ * Create a flow protocol connection between two peers via WebRTC.
+ *
+ * Uses DashRelay for signaling, then establishes a direct P2P
+ * DataChannel for binary flow frame exchange.
+ *
+ * @param roomId - Shared room ID for peer discovery
+ * @param role - 'initiator' creates the offer, 'responder' waits
+ */
+declare function createP2PFlow(roomId: string, role: 'initiator' | 'responder', config?: Partial<WebRTCFlowConfig>): Promise<WebRTCFlowTransport>;
+
+/**
+ * TCP Flow Transport
+ *
+ * FlowTransport adapter for Node/Bun TCP sockets.
+ * Enables flow protocol between server processes —
+ * coordinator ↔ layer nodes, forge ↔ deploy targets.
+ *
+ * Uses length-prefixed framing over raw TCP to delineate
+ * flow frame boundaries. Each message is:
+ *   [u32 length][payload bytes]
+ *
+ * This is the backbone transport for server-to-server
+ * Aeon protocol communication.
+ */
+
+interface TCPFlowConfig {
+    /** Host to connect to (client) or bind to (server) */
+    host?: string;
+    /** Port number */
+    port: number;
+    /** Connection timeout in ms (default: 10000) */
+    connectTimeout?: number;
+    /** Keep-alive interval in ms (default: 30000) */
+    keepAliveMs?: number;
+}
+/** Minimal TCP socket interface — works with Node net.Socket and Bun */
+interface TCPSocket {
+    write(data: Uint8Array): boolean;
+    on(event: 'data', handler: (data: Buffer | Uint8Array) => void): void;
+    on(event: 'close', handler: () => void): void;
+    on(event: 'error', handler: (err: Error) => void): void;
+    end(): void;
+    destroy(): void;
+    setKeepAlive?(enable: boolean, initialDelay?: number): void;
+    setNoDelay?(noDelay?: boolean): void;
+}
+/**
+ * FlowTransport over TCP with length-prefixed framing.
+ *
+ * Handles message boundary detection (TCP is a stream, not message-oriented).
+ * Uses a u32 length prefix so the receiver knows exactly how many bytes
+ * to read for each flow frame.
+ */
+declare class TCPFlowTransport implements FlowTransport {
+    private socket;
+    private receiveHandler;
+    private closed;
+    /** Reassembly buffer for TCP stream → discrete messages */
+    private rxBuffer;
+    constructor(socket: TCPSocket, config?: Partial<TCPFlowConfig>);
+    send(data: Uint8Array): void;
+    onReceive(handler: (data: Uint8Array) => void): void;
+    close(): void;
+    /** Whether the transport is still open */
+    get isOpen(): boolean;
+    private onData;
+}
+/**
+ * Create a TCP FlowTransport by connecting to a remote host.
+ *
+ * Uses dynamic import of 'net' so this module is tree-shakeable
+ * in browser builds.
+ *
+ * @param host - Remote host
+ * @param port - Remote port
+ * @param config - Optional TCP configuration
+ */
+declare function connectTCPFlow(host: string, port: number, config?: Partial<TCPFlowConfig>): Promise<TCPFlowTransport>;
+/**
+ * Create a TCP flow server that accepts incoming connections.
+ *
+ * Each accepted connection becomes a FlowTransport.
+ *
+ * @param port - Port to listen on
+ * @param host - Host to bind to (default: '0.0.0.0')
+ * @param onConnection - Called for each new flow transport connection
+ */
+declare function listenTCPFlow(port: number, host: string, onConnection: (transport: TCPFlowTransport) => void): Promise<{
+    close: () => void;
+}>;
+
+/**
+ * IPC Flow Transport
+ *
+ * FlowTransport adapter for inter-process communication:
+ *   - MessagePort (Web Workers, SharedWorker, BroadcastChannel)
+ *   - MessageChannel (Node/Bun worker_threads)
+ *   - child_process IPC (Node fork)
+ *
+ * Enables flow protocol between:
+ *   - Main thread ↔ inference Web Worker (browser)
+ *   - Shell process ↔ forge daemon (local)
+ *   - Any two processes on the same machine
+ *
+ * Zero-copy when possible — transfers ArrayBuffers via
+ * structured clone's transfer list.
+ */
+
+/**
+ * Minimal MessagePort-like interface.
+ * Covers Web Workers, worker_threads, BroadcastChannel.
+ */
+interface MessagePortLike {
+    postMessage(data: unknown, transfer?: Transferable[]): void;
+    addEventListener?(type: 'message', handler: (event: MessageEvent) => void): void;
+    removeEventListener?(type: 'message', handler: (event: MessageEvent) => void): void;
+    onmessage?: ((event: MessageEvent) => void) | null;
+    close?(): void;
+    start?(): void;
+}
+/**
+ * Minimal child_process-like interface for IPC.
+ * Covers Node child_process.fork() results.
+ */
+interface ChildProcessLike {
+    send(data: unknown): boolean;
+    on(event: 'message', handler: (data: unknown) => void): void;
+    on(event: 'exit', handler: (code: number | null) => void): void;
+    removeListener?(event: string, handler: (...args: unknown[]) => void): void;
+    kill?(): void;
+}
+interface IPCFlowConfig {
+    /** Whether to transfer ArrayBuffers (zero-copy but invalidates sender's ref) */
+    transferBuffers?: boolean;
+}
+/**
+ * FlowTransport over MessagePort (Web Workers, worker_threads, BroadcastChannel).
+ *
+ * Uses structured clone for binary transfer. When `transferBuffers` is true,
+ * the ArrayBuffer backing the Uint8Array is transferred (zero-copy) rather
+ * than cloned. This is faster but invalidates the sender's reference.
+ */
+declare class MessagePortFlowTransport implements FlowTransport {
+    private port;
+    private receiveHandler;
+    private closed;
+    private transferBuffers;
+    private messageHandler;
+    constructor(port: MessagePortLike, config?: IPCFlowConfig);
+    send(data: Uint8Array): void;
+    onReceive(handler: (data: Uint8Array) => void): void;
+    close(): void;
+    /** Whether the transport is still open */
+    get isOpen(): boolean;
+}
+/**
+ * FlowTransport over Node child_process IPC.
+ *
+ * Uses process.send()/process.on('message') for fork()-based IPC.
+ * Messages are serialized via V8's structured clone, so Uint8Array
+ * arrives as a Buffer on the other side.
+ */
+declare class ChildProcessFlowTransport implements FlowTransport {
+    private process;
+    private receiveHandler;
+    private closed;
+    private ipcHandler;
+    constructor(childProcess: ChildProcessLike);
+    send(data: Uint8Array): void;
+    onReceive(handler: (data: Uint8Array) => void): void;
+    close(): void;
+    /** Whether the transport is still open */
+    get isOpen(): boolean;
+}
+/**
+ * Create a pair of linked MessagePort FlowTransports.
+ *
+ * Uses MessageChannel to create a bidirectional pair —
+ * data sent on one arrives on the other.
+ *
+ * Works in browsers, Bun, and Node (with worker_threads).
+ */
+declare function createIPCPair(config?: IPCFlowConfig): [MessagePortFlowTransport, MessagePortFlowTransport];
+
+/**
+ * USB Flow Transport
+ *
+ * FlowTransport adapter for WebUSB API.
+ * Enables flow protocol between browser and USB devices —
+ * the communication channel for Rabbit R1 and other
+ * hardware endpoints.
+ *
+ * Uses bulk transfer endpoints for binary flow frame exchange.
+ * Length-prefixed framing (u32) for message boundary detection
+ * over the bulk pipe.
+ *
+ * The device must expose a vendor-specific interface with
+ * IN and OUT bulk endpoints that speak Aeon flow frames.
+ */
+
+/** Aeon vendor-specific interface class */
+declare const AEON_USB_INTERFACE_CLASS = 255;
+/** Aeon vendor-specific subclass */
+declare const AEON_USB_SUBCLASS = 174;
+/** Aeon protocol ID within the interface */
+declare const AEON_USB_PROTOCOL = 1;
+interface USBFlowConfig {
+    /** Interface number to claim (auto-detected if not specified) */
+    interfaceNumber?: number;
+    /** OUT endpoint number (auto-detected if not specified) */
+    outEndpoint?: number;
+    /** IN endpoint number (auto-detected if not specified) */
+    inEndpoint?: number;
+    /** Transfer size for bulk reads (default: 64KB) */
+    transferSize?: number;
+    /** USB vendor ID filter for device selection */
+    vendorId?: number;
+    /** USB product ID filter for device selection */
+    productId?: number;
+}
+/**
+ * FlowTransport over WebUSB bulk endpoints.
+ *
+ * Uses length-prefixed framing over bulk transfers to delineate
+ * flow frame boundaries. Continuously polls the IN endpoint
+ * for incoming data.
+ */
+declare class USBFlowTransport implements FlowTransport {
+    private device;
+    private receiveHandler;
+    private closed;
+    private interfaceNum;
+    private outEndpoint;
+    private inEndpoint;
+    private transferSize;
+    private readLoopRunning;
+    /** Reassembly buffer for length-prefixed framing */
+    private rxBuffer;
+    private constructor();
+    /**
+     * Connect to a USB device and create a FlowTransport.
+     *
+     * Requests device access, opens it, claims the Aeon interface,
+     * and auto-detects bulk endpoints if not specified.
+     */
+    static connect(config?: USBFlowConfig): Promise<USBFlowTransport>;
+    /**
+     * Create from an already-opened USB device (for testing or manual setup).
+     */
+    static fromDevice(device: USBDevice, interfaceNum: number, outEndpoint: number, inEndpoint: number, config?: Partial<USBFlowConfig>): USBFlowTransport;
+    send(data: Uint8Array): void;
+    onReceive(handler: (data: Uint8Array) => void): void;
+    close(): void;
+    /** Whether the transport is still open */
+    get isOpen(): boolean;
+    /** Get the USB device info */
+    get deviceInfo(): {
+        vendorId: number;
+        productId: number;
+        name: string;
+    };
+    private startReadLoop;
+    private processChunk;
+}
+
+/**
+ * HTTP Flow Transport (nginx Bridge)
+ *
+ * FlowTransport adapter that translates between HTTP and Aeon flow protocol.
+ * This is the normie projection layer — external clients speak HTTP,
+ * the nginx module translates to Aeon flow, and everything internal
+ * speaks Aeon natively.
+ *
+ * Two sides:
+ *   1. **Server-side (Aeon→HTTP)**: Receives flow frames from internal Aeon
+ *      services and translates them into HTTP responses for external clients.
+ *   2. **Client-side (HTTP→Aeon)**: Receives HTTP requests from nginx and
+ *      translates them into flow frames for internal processing.
+ *
+ * The nginx module handles the C-level WebSocket↔HTTP translation.
+ * This TypeScript module handles the flow frame↔HTTP semantic mapping:
+ *   - HTTP GET → flow stream open + await FIN
+ *   - HTTP POST → flow stream open + data frames + FIN
+ *   - HTTP response → flow frames + FIN
+ *   - HTTP streaming response → flow frames (no FIN until complete)
+ *   - HTTP error → VENT frame
+ *
+ * Wire format between nginx module and this bridge:
+ *   Control messages are length-prefixed JSON.
+ *   Data messages are raw flow frames.
+ */
+
+/** HTTP request as received from nginx */
+interface AeonHTTPRequest {
+    /** HTTP method */
+    method: string;
+    /** Request path */
+    path: string;
+    /** Query string (without leading ?) */
+    query?: string;
+    /** Request headers */
+    headers: Record<string, string>;
+    /** Request body (for POST/PUT/PATCH) */
+    body?: Uint8Array;
+    /** Unique request ID assigned by nginx */
+    requestId: string;
+}
+/** HTTP response to send back through nginx */
+interface AeonHTTPResponse {
+    /** HTTP status code */
+    status: number;
+    /** Response headers */
+    headers: Record<string, string>;
+    /** Response body */
+    body: Uint8Array;
+    /** Whether this is a streaming response (more chunks follow) */
+    streaming?: boolean;
+    /** Request ID this response belongs to */
+    requestId: string;
+}
+interface HTTPBridgeConfig {
+    /** Default content type for responses (default: 'application/octet-stream') */
+    defaultContentType?: string;
+    /** Maximum request body size in bytes (default: 16MB) */
+    maxBodySize?: number;
+    /** Timeout for flow response in ms (default: 30000) */
+    responseTimeout?: number;
+}
+/**
+ * Encode an HTTP request into flow frame payload.
+ *
+ * Format:
+ *   [0-3]   u32  method length
+ *   [4-7]   u32  path length
+ *   [8-11]  u32  headers JSON length
+ *   [12-15] u32  body length
+ *   [...]   method bytes
+ *   [...]   path bytes (includes query string)
+ *   [...]   headers JSON bytes
+ *   [...]   body bytes
+ */
+declare function encodeHTTPRequest(req: AeonHTTPRequest): Uint8Array;
+/**
+ * Decode a flow frame payload back into an HTTP request.
+ */
+declare function decodeHTTPRequest(data: Uint8Array): AeonHTTPRequest;
+/**
+ * Encode an HTTP response into flow frame payload.
+ *
+ * Format:
+ *   [0-1]   u16  status code
+ *   [2-5]   u32  headers JSON length
+ *   [6-9]   u32  body length
+ *   [...]   headers JSON bytes
+ *   [...]   body bytes
+ */
+declare function encodeHTTPResponse(res: Omit<AeonHTTPResponse, 'requestId'>): Uint8Array;
+/**
+ * Decode a flow frame payload back into an HTTP response.
+ */
+declare function decodeHTTPResponse(data: Uint8Array): Omit<AeonHTTPResponse, 'requestId'>;
+/**
+ * Bidirectional HTTP↔Aeon flow protocol bridge.
+ *
+ * Sits between nginx (HTTP) and internal Aeon services (flow protocol).
+ * Translates HTTP requests into flow streams and flow responses back
+ * into HTTP responses.
+ *
+ * nginx module sends HTTP requests over a WebSocket to this bridge.
+ * This bridge opens flow streams, forwards the request as flow frames,
+ * collects the response frames, and sends the HTTP response back to nginx.
+ */
+declare class HTTPAeonBridge {
+    private transport;
+    private config;
+    /** Pending HTTP requests waiting for flow responses */
+    private pending;
+    /** Handler for incoming HTTP requests (from nginx side) */
+    private requestHandler;
+    constructor(transport: FlowTransport, config?: HTTPBridgeConfig);
+    /**
+     * Register a handler for incoming HTTP requests.
+     * This is used on the Aeon side — the bridge receives HTTP requests
+     * from nginx, translates them to flow, and calls this handler.
+     */
+    onRequest(handler: (req: AeonHTTPRequest) => Promise<AeonHTTPResponse>): void;
+    /**
+     * Send an HTTP request through the bridge (used by nginx side).
+     * Translates the HTTP request into flow frames, waits for the
+     * flow response, and returns it as an HTTP response.
+     */
+    sendRequest(req: AeonHTTPRequest): Promise<AeonHTTPResponse>;
+    /**
+     * Send an HTTP response back through the bridge (used by Aeon side).
+     */
+    sendResponse(res: AeonHTTPResponse): void;
+    close(): void;
+    private handleIncoming;
+    private handleResponseFrame;
+    private handleRequestFrame;
+}
+
+/**
+ * Federated Browser Inference
+ *
+ * Fork inference requests across N mesh peers via flow protocol,
+ * race the results, winner provides the response. This turns
+ * every browser tab with WASM inference into a federated compute node.
+ *
+ * The coordinator:
+ *   1. Discovers peers via DashRelay room or Bluetooth/WebRTC mesh
+ *   2. Forks a flow stream per peer for the same prompt
+ *   3. Races all streams — fastest inference result wins
+ *   4. Vents slower streams to free their resources
+ *   5. Returns the winning result to the caller
+ *
+ * This is fork/race/fold at the network level —
+ * the same primitive that handles ESI cache vs inference,
+ * but applied across physical devices.
+ *
+ * Use cases:
+ *   - 3 phones in a room → fork prompt to all 3, fastest wins
+ *   - Laptop + tablet → laptop runs 7B, tablet runs 1B, race them
+ *   - Federated speculative decoding across device mesh
+ */
+
+interface FederatedPeer {
+    /** Unique peer identifier */
+    id: string;
+    /** Flow transport to this peer */
+    transport: FlowTransport;
+    /** Peer's reported capabilities */
+    capabilities: PeerCapabilities;
+    /** Last seen timestamp */
+    lastSeen: number;
+    /** Whether peer is currently available for inference */
+    available: boolean;
+}
+interface PeerCapabilities {
+    /** Models available on this peer */
+    models: string[];
+    /** Acceleration type */
+    acceleration: 'webgpu' | 'webnn' | 'wasm' | 'none';
+    /** Estimated tokens/second */
+    estimatedTps?: number;
+    /** Available memory in MB */
+    availableMemoryMB?: number;
+    /** Whether peer is on battery */
+    onBattery?: boolean;
+}
+interface FederatedInferenceRequest {
+    /** Prompt text */
+    prompt: string;
+    /** Model preference (peers without this model are skipped) */
+    model?: string;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Temperature */
+    temperature?: number;
+    /** Whether to include all peer results or just the winner */
+    collectAll?: boolean;
+}
+interface FederatedInferenceResult {
+    /** The winning peer's ID */
+    winnerId: string;
+    /** Generated text */
+    text: string;
+    /** Time to first token (ms) */
+    ttft: number;
+    /** Total generation time (ms) */
+    totalTime: number;
+    /** Tokens per second achieved */
+    tokensPerSecond: number;
+    /** All peer results (if collectAll was true) */
+    allResults?: Map<string, {
+        text: string;
+        time: number;
+    }>;
+}
+interface FederatedInferenceConfig {
+    /** Timeout for inference requests in ms (default: 60000) */
+    timeout?: number;
+    /** Minimum peers required to start federated inference (default: 1) */
+    minPeers?: number;
+    /** Maximum peers to fork to (default: 8) */
+    maxPeers?: number;
+    /** Whether to include local inference in the race (default: true) */
+    includeLocal?: boolean;
+    /** Local inference handler (if includeLocal is true) */
+    localInference?: (prompt: string) => Promise<string>;
+}
+/**
+ * Coordinates federated inference across a mesh of peers.
+ *
+ * Each peer runs its own WASM inference engine. The coordinator
+ * forks the same prompt to multiple peers, races them, and returns
+ * the fastest result.
+ *
+ * Uses AeonFlowProtocol for fork/race/fold:
+ *   - fork(root, N) creates N child streams, one per peer
+ *   - race(children) picks the first to complete
+ *   - Losers are automatically vented
+ */
+declare class FederatedInferenceCoordinator {
+    private peers;
+    private config;
+    private listeners;
+    constructor(config?: FederatedInferenceConfig);
+    /**
+     * Register a peer with its flow transport.
+     * The transport should already be connected.
+     */
+    addPeer(id: string, transport: FlowTransport, capabilities?: PeerCapabilities): void;
+    /**
+     * Remove a peer from the federation.
+     */
+    removePeer(id: string): void;
+    /**
+     * Get all available peers, optionally filtered by model support.
+     */
+    getAvailablePeers(model?: string): FederatedPeer[];
+    /**
+     * Run federated inference across available peers.
+     *
+     * Forks the prompt to N peers, races them, returns the fastest result.
+     * This is the core fork/race primitive applied at the network level.
+     */
+    infer(request: FederatedInferenceRequest): Promise<FederatedInferenceResult>;
+    /**
+     * Create a handler for incoming inference requests.
+     * Call this on the peer side to process requests from the coordinator.
+     *
+     * @param inferFn - The actual inference function on this peer
+     * @returns A FlowTransport receive handler
+     */
+    static createPeerHandler(inferFn: (prompt: string, options?: {
+        maxTokens?: number;
+        temperature?: number;
+    }) => Promise<string>): (data: Uint8Array) => void;
+    /**
+     * Set up a peer to respond to federated inference requests.
+     *
+     * @param transport - The FlowTransport connected to the coordinator
+     * @param inferFn - The inference function to run
+     * @param capabilities - This peer's capabilities to announce
+     */
+    static setupPeer(transport: FlowTransport, inferFn: (prompt: string, options?: {
+        maxTokens?: number;
+        temperature?: number;
+    }) => Promise<string>, capabilities: PeerCapabilities): void;
+    on(handler: (event: FederationEvent) => void): void;
+    off(handler: (event: FederationEvent) => void): void;
+    private emit;
+    get peerCount(): number;
+    get availablePeerCount(): number;
+    destroy(): void;
+}
+type FederationEvent = {
+    type: 'peer-added';
+    peerId: string;
+} | {
+    type: 'peer-removed';
+    peerId: string;
+} | {
+    type: 'peer-capabilities';
+    peerId: string;
+    capabilities: PeerCapabilities;
+} | {
+    type: 'inference-start';
+    peerCount: number;
+} | {
+    type: 'inference-complete';
+    winnerId: string;
+    totalTime: number;
+} | {
+    type: 'error';
+    message: string;
+};
+
+/**
+ * Aeon - Distributed Synchronization & Versioning Library
+ *
+ * A comprehensive library for building distributed, collaborative applications
+ * with real-time synchronization, schema versioning, and conflict resolution.
+ *
+ * @example
+ * ```typescript
+ * import { SyncCoordinator, SchemaVersionManager } from '@a0n/aeon';
+ *
+ * // Create a sync coordinator
+ * const coordinator = new SyncCoordinator();
+ *
+ * // Register a node
+ * coordinator.registerNode({
+ *   id: 'node-1',
+ *   address: 'localhost',
+ *   port: 3000,
+ *   status: 'online',
+ *   lastHeartbeat: new Date().toISOString(),
+ *   version: '1.0.0',
+ *   capabilities: ['sync', 'replicate'],
+ * });
+ *
+ * // Create a sync session
+ * const session = coordinator.createSyncSession('node-1', ['node-2', 'node-3']);
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * STUBS for React components and hooks
+ * These are normally provided by @a0n/aeon-flux-react but are
+ * imported from @a0n/aeon in many legacy parts of edge-web-app.
+ *
+ * NOTE: Only stub things NOT exported by submodules above.
+ * SchemaVersionManager, SyncCoordinator, getAdaptiveCompressionOptimizer,
+ * and getAgentPresenceManager are real exports — do NOT shadow them here.
+ */
+declare const Link: any;
+declare const useAeonPage: any;
+
+export { ACK_FLAG, AEON_FLOW_RX_UUID, AEON_FLOW_SERVICE_UUID, AEON_FLOW_TX_UUID, AEON_USB_INTERFACE_CLASS, AEON_USB_PROTOCOL, AEON_USB_SUBCLASS, type AdaptiveParallelismPolicyResult, AeonFlowProtocol, type AeonHTTPRequest, type AeonHTTPResponse, type BettiNumbers, type BluetoothFlowConfig, BluetoothFlowTransport, ChildProcessFlowTransport, type ChildProcessLike, type ComputationEdge, type ComputationGraph, type ComputationNode, DEFAULT_FLOW_CONFIG, type DashRelayFlowConfig, DashRelayFlowTransport, type DashRelayLike, type DeficitReport, FIN, FOLD, FORK, FRAGMENT_HEADER_SIZE, type FederatedInferenceConfig, FederatedInferenceCoordinator, type FederatedInferenceRequest, type FederatedInferenceResult, type FederatedPeer, type FederationEvent, FlowCodec, type FlowFrame, type FlowProtocolConfig, type FlowProtocolEvents, type FlowStream, type FlowStreamState, type FlowTransport, type ForkJoinPair, FrameReassembler, type FrontierFillResult, GNOSIS_IMPOSSIBLE_SYSTEM_TOPOLOGIES, type GnosisImpossibleSystemId, type GnosisImpossibleSystemTopology, HEADER_SIZE, HTTPAeonBridge, type HTTPBridgeConfig, type IPCFlowConfig, Link, MAX_FRAGMENT_PAYLOAD, MAX_PAYLOAD_LENGTH, MessagePortFlowTransport, type MessagePortLike, POISON, type ParallelismAction, type PeerCapabilities, type PipelineOccupancyResult, type PipelineRegime, type ProtocolDeficitResult, type QuantumDeficitResult, RACE, type ReassemblerConfig, type ReassemblerStats, type Sample, type SamplerConfig, type SamplerReport, type SettlementDeficitResult, type SignalingMessage, type SpeculativeTreeResult, type TCPFlowConfig, TCPFlowTransport, TopologyAnalyzer, type TopologyReport, TopologySampler, type TurbulentIdleResult, UDPFlowTransport, type UDPFlowTransportConfig, UDP_MTU, type USBFlowConfig, USBFlowTransport, VENT, type WebRTCFlowConfig, WebRTCFlowTransport, WebTransportFlowTransport, type WorthingtonWhipResult, adaptiveParallelismPolicy, beta2FromBandGap, classifyPipelineRegime, connectTCPFlow, createDashRelayFlow, createIPCPair, createP2PFlow, decodeHTTPRequest, decodeHTTPResponse, encodeHTTPRequest, encodeHTTPResponse, firstLawConserved, frontierFill, getGnosisImpossibleSystemTopology, listenTCPFlow, pipelineOccupancy, protocolDeficits, quantumDeficitIdentity, settlementDeficits, speculativeTreeExpectedAccepted, turbulentIdleFraction, useAeonPage, worthingtonWhipSavings };