@affectively/aeon 1.3.0 → 5.0.1

package/dist/index.cjs

@@ -57,12 +57,17 @@ var logger = {
 };
 
 // src/persistence/DashStorageAdapter.ts
+var DEFAULT_RULE = {
+  urgency: "deferred",
+  debounce: 50,
+  maxBufferSize: 5e3,
+  readThrough: true
+};
 var DashStorageAdapter = class {
   backend;
   syncClient;
-  syncDebounceMs;
-  maxPendingChanges;
-  onSyncError;
+  rules;
+  hooks;
   pendingChanges = /* @__PURE__ */ new Map();
   syncTimer = null;
   syncInFlight = false;
@@ -70,11 +75,33 @@ var DashStorageAdapter = class {
   constructor(backend, options = {}) {
     this.backend = backend;
     this.syncClient = options.syncClient ?? null;
-    this.syncDebounceMs = options.syncDebounceMs ?? 50;
-    this.maxPendingChanges = options.maxPendingChanges ?? 5e3;
-    this.onSyncError = options.onSyncError ?? null;
+    this.hooks = options.hooks ?? {};
+    const defaultRule = {
+      ...DEFAULT_RULE,
+      ...options.rules?.default ?? {}
+    };
+    if (options.syncDebounceMs !== void 0)
+      defaultRule.debounce = options.syncDebounceMs;
+    if (options.maxPendingChanges !== void 0)
+      defaultRule.maxBufferSize = options.maxPendingChanges;
+    if (options.onSyncError && !this.hooks.onSyncError)
+      this.hooks.onSyncError = options.onSyncError;
+    this.rules = {
+      default: defaultRule,
+      prefixes: options.rules?.prefixes ?? {}
+    };
   }
+  /**
+   * Get an item, checking the write pool (pending changes) first for consistency.
+   */
   async getItem(key) {
+    const rule = this.getRuleForKey(key);
+    if (rule.readThrough !== false) {
+      const pending = this.pendingChanges.get(key);
+      if (pending) {
+        return pending.operation === "delete" ? null : pending.value ?? null;
+      }
+    }
     return await this.backend.get(key);
   }
   async setItem(key, value) {
@@ -109,34 +136,45 @@ var DashStorageAdapter = class {
   }
   trackChange(change) {
     this.pendingChanges.set(change.key, change);
-    this.enforcePendingLimit();
-    this.scheduleSync();
-  }
-  enforcePendingLimit() {
-    if (this.pendingChanges.size <= this.maxPendingChanges) {
+    const rule = this.getRuleForKey(change.key);
+    if (rule.urgency === "realtime") {
+      void this.performSync();
       return;
     }
-    const sorted = Array.from(this.pendingChanges.values()).sort(
-      (a, b) => a.timestamp - b.timestamp
-    );
-    const overflow = this.pendingChanges.size - this.maxPendingChanges;
-    for (let i = 0; i < overflow; i++) {
-      const toDrop = sorted[i];
-      if (toDrop) {
-        this.pendingChanges.delete(toDrop.key);
-      }
+    const maxSize = rule.maxBufferSize ?? 5e3;
+    if (this.pendingChanges.size >= maxSize) {
+      this.hooks.onBufferOverflow?.(
+        this.getPrefixMatch(change.key) || "default",
+        this.pendingChanges.size,
+        maxSize
+      );
+      void this.performSync();
+      return;
     }
+    this.scheduleSync(rule);
   }
-  scheduleSync() {
-    if (!this.syncClient) {
-      return;
+  getRuleForKey(key) {
+    const prefix = this.getPrefixMatch(key);
+    return (prefix ? this.rules.prefixes?.[prefix] : this.rules.default) ?? this.rules.default;
+  }
+  getPrefixMatch(key) {
+    if (!this.rules.prefixes) {
+      return null;
     }
-    if (this.syncTimer) {
-      clearTimeout(this.syncTimer);
+    const prefixes = Object.keys(this.rules.prefixes).sort(
+      (a, b) => b.length - a.length
+    );
+    return prefixes.find((p) => key.startsWith(p)) ?? null;
+  }
+  scheduleSync(rule) {
+    if (!this.syncClient || this.syncTimer) {
+      return;
     }
+    const debounceMs = typeof rule.debounce === "string" ? this.parseInterval(rule.debounce) : rule.debounce ?? 50;
     this.syncTimer = setTimeout(() => {
+      this.syncTimer = null;
       void this.performSync();
-    }, this.syncDebounceMs);
+    }, debounceMs);
   }
   async performSync() {
     if (!this.syncClient) {
@@ -156,6 +194,8 @@ var DashStorageAdapter = class {
     this.syncInFlight = true;
     try {
       await this.syncClient.syncChanges(changes);
+      this.hooks.onSync?.(changes);
+      this.hooks.onFlush?.(changes.length);
     } catch (error) {
       for (const change of changes) {
         const current = this.pendingChanges.get(change.key);
@@ -163,19 +203,39 @@ var DashStorageAdapter = class {
           this.pendingChanges.set(change.key, change);
         }
       }
-      if (this.onSyncError) {
+      if (this.hooks.onSyncError) {
         const normalizedError = error instanceof Error ? error : new Error(String(error));
-        this.onSyncError(normalizedError, changes);
+        this.hooks.onSyncError(normalizedError, changes);
       }
     } finally {
       this.syncInFlight = false;
       const rerun = this.syncPending || this.pendingChanges.size > 0;
       this.syncPending = false;
       if (rerun) {
-        this.scheduleSync();
+        this.scheduleSync(this.rules.default);
       }
     }
   }
+  parseInterval(input) {
+    const match = input.match(/^(\d+)(ms|s|m|h|d)$/);
+    if (!match) return 50;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 60 * 1e3;
+      case "h":
+        return value * 60 * 60 * 1e3;
+      case "d":
+        return value * 24 * 60 * 60 * 1e3;
+      default:
+        return 50;
+    }
+  }
 };
 
 // src/persistence/InMemoryStorageAdapter.ts
@@ -190,6 +250,8 @@ var InMemoryStorageAdapter = class {
   removeItem(key) {
     this.store.delete(key);
   }
+  async flushSync() {
+  }
   clear() {
     this.store.clear();
   }
@@ -353,10 +415,11 @@ var SchemaVersionManager = class {
    */
   parseVersion(versionString) {
     const parts = versionString.split(".").map(Number);
+    const safeInt = (v) => v !== void 0 && Number.isFinite(v) ? v : 0;
     return {
-      major: parts[0] || 0,
-      minor: parts[1] || 0,
-      patch: parts[2] || 0,
+      major: safeInt(parts[0]),
+      minor: safeInt(parts[1]),
+      patch: safeInt(parts[2]),
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       description: "",
       breaking: false
@@ -1323,7 +1386,8 @@ var MigrationTracker = class _MigrationTracker {
     return (hash >>> 0).toString(16).padStart(8, "0");
   }
 };
-var SyncCoordinator = class extends eventemitter3.EventEmitter {
+var SyncCoordinator = class _SyncCoordinator extends eventemitter3.EventEmitter {
+  static MAX_SYNC_EVENTS = 1e4;
   nodes = /* @__PURE__ */ new Map();
   sessions = /* @__PURE__ */ new Map();
   syncEvents = [];
@@ -1336,6 +1400,12 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
   constructor() {
     super();
   }
+  addSyncEvent(event) {
+    this.syncEvents.push(event);
+    if (this.syncEvents.length > _SyncCoordinator.MAX_SYNC_EVENTS) {
+      this.syncEvents = this.syncEvents.slice(-_SyncCoordinator.MAX_SYNC_EVENTS);
+    }
+  }
   /**
    * Configure cryptographic provider for authenticated sync
    */
@@ -1375,7 +1445,7 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       data: { did: nodeInfo.did, authenticated: true }
     };
-    this.syncEvents.push(event);
+    this.addSyncEvent(event);
     this.emit("node-joined", node);
     logger.debug("[SyncCoordinator] Authenticated node registered", {
       nodeId: node.id,
@@ -1453,7 +1523,7 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
         encryptionMode: session.encryptionMode
       }
     };
-    this.syncEvents.push(event);
+    this.addSyncEvent(event);
     this.emit("sync-started", session);
     logger.debug("[SyncCoordinator] Authenticated sync session created", {
       sessionId: session.id,
@@ -1500,7 +1570,7 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
       nodeId: node.id,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
-    this.syncEvents.push(event);
+    this.addSyncEvent(event);
     this.emit("node-joined", node);
     logger.debug("[SyncCoordinator] Node registered", {
       nodeId: node.id,
@@ -1523,7 +1593,7 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
       nodeId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
-    this.syncEvents.push(event);
+    this.addSyncEvent(event);
     this.emit("node-left", node);
     logger.debug("[SyncCoordinator] Node deregistered", { nodeId });
   }
@@ -1552,7 +1622,7 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
       nodeId: initiatorId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
-    this.syncEvents.push(event);
+    this.addSyncEvent(event);
     this.emit("sync-started", session);
     logger.debug("[SyncCoordinator] Sync session created", {
       sessionId: session.id,
@@ -1579,7 +1649,7 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         data: { status: updates.status, itemsSynced: session.itemsSynced }
       };
-      this.syncEvents.push(event);
+      this.addSyncEvent(event);
       this.emit("sync-completed", session);
     }
     logger.debug("[SyncCoordinator] Sync session updated", {
@@ -1602,7 +1672,7 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         data: conflictData
       };
-      this.syncEvents.push(event);
+      this.addSyncEvent(event);
       this.emit("conflict-detected", { session, nodeId, conflictData });
       logger.debug("[SyncCoordinator] Conflict recorded", {
         sessionId,
@@ -4150,7 +4220,10 @@ var CompressionEngine = class {
    */
   reassembleChunks(chunks) {
     const sorted = [...chunks].sort((a, b) => a.index - b.index);
-    const total = sorted[0]?.total ?? 0;
+    if (sorted.length === 0) {
+      throw new Error("Cannot reassemble: no chunks provided");
+    }
+    const total = sorted[0].total;
     if (sorted.length !== total) {
       throw new Error(
         `Missing chunks: got ${sorted.length}, expected ${total}`
@@ -4176,7 +4249,7 @@ var CompressionEngine = class {
     for (let i = 0; i < data.length; i++) {
       hash = (hash << 5) - hash + data[i] | 0;
     }
-    return hash.toString(16);
+    return (hash >>> 0).toString(16);
   }
   /**
    * Update average compression ratio
@@ -4220,7 +4293,8 @@ function resetCompressionEngine() {
 
 // src/compression/DeltaSyncOptimizer.ts
 var logger4 = getLogger();
-var DeltaSyncOptimizer = class {
+var DeltaSyncOptimizer = class _DeltaSyncOptimizer {
+  static MAX_HISTORY_SIZE = 1e4;
   operationHistory = /* @__PURE__ */ new Map();
   stats = {
     totalOperations: 0,
@@ -4265,6 +4339,10 @@ var DeltaSyncOptimizer = class {
       ).byteLength;
       this.stats.totalDeltaSize += deltaSize2;
       this.operationHistory.set(operation.id, operation);
+      if (this.operationHistory.size > _DeltaSyncOptimizer.MAX_HISTORY_SIZE) {
+        const firstKey = this.operationHistory.keys().next().value;
+        if (firstKey !== void 0) this.operationHistory.delete(firstKey);
+      }
       return delta;
     }
     const changes = {};
@@ -4315,6 +4393,10 @@ var DeltaSyncOptimizer = class {
     this.stats.totalOriginalSize += originalSize;
     this.stats.totalDeltaSize += deltaSize;
     this.operationHistory.set(operation.id, operation);
+    if (this.operationHistory.size > _DeltaSyncOptimizer.MAX_HISTORY_SIZE) {
+      const firstKey = this.operationHistory.keys().next().value;
+      if (firstKey !== void 0) this.operationHistory.delete(firstKey);
+    }
     return finalDelta;
   }
   /**
@@ -4399,6 +4481,11 @@ var DeltaSyncOptimizer = class {
     for (const op of operations) {
       this.operationHistory.set(op.id, op);
     }
+    while (this.operationHistory.size > _DeltaSyncOptimizer.MAX_HISTORY_SIZE) {
+      const firstKey = this.operationHistory.keys().next().value;
+      if (firstKey !== void 0) this.operationHistory.delete(firstKey);
+      else break;
+    }
     logger4.debug("[DeltaSyncOptimizer] History updated", {
       count: operations.length,
       totalHistorySize: this.operationHistory.size
@@ -4599,7 +4686,7 @@ var PrefetchingEngine = class {
     const predictions = [];
     const recentTypeSequence = recentOperations.slice(-3).map((op) => op.type).join(" \u2192 ");
     for (const [key, pattern] of this.patterns.entries()) {
-      if (key.includes(recentTypeSequence)) {
+      if (key.includes(recentTypeSequence) && pattern.sequence.length > 0) {
         const nextType = pattern.sequence[pattern.sequence.length - 1];
         const prediction = {
           operationType: nextType,
@@ -5116,8 +5203,11 @@ var AdaptiveCompressionOptimizer = class {
       this.compressionHistory.shift();
     }
     this.stats.totalBatches++;
-    this.stats.averageCompressionMs = this.compressionHistory.reduce((sum, h) => sum + h.timeMs, 0) / this.compressionHistory.length;
-    this.stats.averageRatio = this.compressionHistory.reduce((sum, h) => sum + h.ratio, 0) / this.compressionHistory.length;
+    const historyLength = this.compressionHistory.length;
+    if (historyLength > 0) {
+      this.stats.averageCompressionMs = this.compressionHistory.reduce((sum, h) => sum + h.timeMs, 0) / historyLength;
+      this.stats.averageRatio = this.compressionHistory.reduce((sum, h) => sum + h.ratio, 0) / historyLength;
+    }
   }
   /**
    * Get compression recommendation based on conditions
@@ -5810,29 +5900,2814 @@ var NullCryptoProvider = class {
   }
 };
 
+// src/crypto/transactionSigner.ts
+var NullTransactionSigner = class {
+  async execute(request) {
+    return {
+      success: false,
+      action: request.action,
+      chainId: request.chainId || 0,
+      errorCode: "signer_unavailable",
+      errorMessage: "Transaction signer not configured"
+    };
+  }
+  async getSigner(action) {
+    throw new Error(
+      `Transaction signer metadata unavailable for action: ${action}`
+    );
+  }
+  async health() {
+    return {
+      ok: false,
+      service: "transaction-signer",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+function createTransactionSignerAdapter(contract) {
+  return contract;
+}
+
+// src/flow/FlowCodec.ts
+var HEADER_SIZE = 10;
+var MAX_PAYLOAD_LENGTH = 16777215;
+var FlowCodec = class _FlowCodec {
+  wasmInstance = null;
+  constructor(wasmInstance) {
+    this.wasmInstance = wasmInstance;
+  }
+  /**
+   * Create a FlowCodec. Tries WASM acceleration, falls back to JS.
+   * The JS path is always correct — WASM is a performance optimization only.
+   */
+  static async create() {
+    return new _FlowCodec(null);
+  }
+  /**
+   * Create a FlowCodec synchronously (JS-only, no WASM attempt).
+   */
+  static createSync() {
+    return new _FlowCodec(null);
+  }
+  /**
+   * Whether WASM acceleration is active.
+   */
+  get isWasmAccelerated() {
+    return this.wasmInstance !== null;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Encode
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Encode a single FlowFrame into a binary buffer.
+   *
+   * Returns a new Uint8Array containing the 10-byte header followed by
+   * the payload bytes.
+   */
+  encode(frame) {
+    const payloadLen = frame.payload.length;
+    if (payloadLen > MAX_PAYLOAD_LENGTH) {
+      throw new RangeError(
+        `Payload length ${payloadLen} exceeds maximum ${MAX_PAYLOAD_LENGTH}`
+      );
+    }
+    const buf = new Uint8Array(HEADER_SIZE + payloadLen);
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    view.setUint16(0, frame.streamId);
+    view.setUint32(2, frame.sequence);
+    buf[6] = frame.flags;
+    buf[7] = payloadLen >>> 16 & 255;
+    buf[8] = payloadLen >>> 8 & 255;
+    buf[9] = payloadLen & 255;
+    buf.set(frame.payload, HEADER_SIZE);
+    return buf;
+  }
+  /**
+   * 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, offset = 0) {
+    if (buffer.length - offset < HEADER_SIZE) {
+      throw new RangeError(
+        `Buffer too small: need at least ${HEADER_SIZE} bytes, have ${buffer.length - offset}`
+      );
+    }
+    const view = new DataView(
+      buffer.buffer,
+      buffer.byteOffset + offset,
+      buffer.byteLength - offset
+    );
+    const streamId = view.getUint16(0);
+    const sequence = view.getUint32(2);
+    const flags = buffer[offset + 6];
+    const length = buffer[offset + 7] << 16 | buffer[offset + 8] << 8 | buffer[offset + 9];
+    if (buffer.length - offset - HEADER_SIZE < length) {
+      throw new RangeError(
+        `Buffer too small for payload: need ${length} bytes, have ${buffer.length - offset - HEADER_SIZE}`
+      );
+    }
+    const payload = buffer.subarray(
+      offset + HEADER_SIZE,
+      offset + HEADER_SIZE + length
+    );
+    return {
+      frame: { streamId, sequence, flags, payload },
+      bytesRead: HEADER_SIZE + length
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Batch encode/decode
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Encode multiple frames into a single contiguous buffer.
+   *
+   * Frames are laid out sequentially: [header+payload][header+payload]...
+   */
+  encodeBatch(frames) {
+    let totalSize = 0;
+    for (const frame of frames) {
+      if (frame.payload.length > MAX_PAYLOAD_LENGTH) {
+        throw new RangeError(
+          `Payload length ${frame.payload.length} exceeds maximum ${MAX_PAYLOAD_LENGTH}`
+        );
+      }
+      totalSize += HEADER_SIZE + frame.payload.length;
+    }
+    const buf = new Uint8Array(totalSize);
+    let writeOffset = 0;
+    for (const frame of frames) {
+      const encoded = this.encode(frame);
+      buf.set(encoded, writeOffset);
+      writeOffset += encoded.length;
+    }
+    return buf;
+  }
+  /**
+   * Decode all frames from a contiguous buffer.
+   *
+   * Payloads are zerocopy views into the original buffer.
+   */
+  decodeBatch(buffer) {
+    const frames = [];
+    let offset = 0;
+    while (offset < buffer.length) {
+      if (buffer.length - offset < HEADER_SIZE) {
+        throw new RangeError(
+          `Truncated frame at offset ${offset}: need ${HEADER_SIZE} bytes, have ${buffer.length - offset}`
+        );
+      }
+      const { frame, bytesRead } = this.decode(buffer, offset);
+      frames.push(frame);
+      offset += bytesRead;
+    }
+    return frames;
+  }
+};
+
+// src/flow/types.ts
+var FORK = 1;
+var RACE = 2;
+var COLLAPSE = 4;
+var POISON = 8;
+var FIN = 16;
+var DEFAULT_FLOW_CONFIG = {
+  highWaterMark: 64,
+  role: "client",
+  maxConcurrentStreams: 256
+};
+
+// src/flow/AeonFlowProtocol.ts
+var AeonFlowProtocol = class {
+  streams = /* @__PURE__ */ new Map();
+  nextEvenId = 0;
+  nextOddId = 1;
+  codec;
+  transport;
+  config;
+  // Event handlers
+  frameHandlers = /* @__PURE__ */ new Map();
+  endHandlers = /* @__PURE__ */ new Map();
+  poisonHandlers = /* @__PURE__ */ new Map();
+  // Race tracking
+  raceGroups = /* @__PURE__ */ new Map();
+  // Collapse tracking
+  collapseGroups = /* @__PURE__ */ new Map();
+  constructor(transport, config) {
+    this.transport = transport;
+    this.config = { ...DEFAULT_FLOW_CONFIG, ...config };
+    this.codec = FlowCodec.createSync();
+    this.transport.onReceive((data) => {
+      this.handleIncoming(data);
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Stream management
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Open a new root stream (no parent).
+   *
+   * Client-initiated streams get even IDs; server-initiated get odd IDs.
+   */
+  openStream() {
+    const id = this.allocateStreamId();
+    this.createStream(id);
+    return id;
+  }
+  /**
+   * Get the current state of a stream.
+   */
+  getStream(streamId) {
+    return this.streams.get(streamId);
+  }
+  /**
+   * Get all active streams.
+   */
+  getActiveStreams() {
+    return Array.from(this.streams.values()).filter(
+      (s) => s.state !== "closed" && s.state !== "poisoned"
+    );
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Fork: create N child streams from a parent
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Fork a parent stream into N child streams.
+   *
+   * Each child stream is independent and can send/receive frames.
+   * The parent tracks all children. Poisoning the parent poisons 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, count) {
+    const parent = this.requireStream(parentStreamId, "open");
+    if (count < 1) {
+      throw new RangeError("Fork count must be at least 1");
+    }
+    if (this.streams.size + count > this.config.maxConcurrentStreams) {
+      throw new Error(
+        `Cannot fork ${count} streams: would exceed maxConcurrentStreams (${this.config.maxConcurrentStreams})`
+      );
+    }
+    const childIds = [];
+    for (let i = 0; i < count; i++) {
+      const childId = this.allocateStreamId();
+      this.createStream(childId, parentStreamId);
+      parent.children.push(childId);
+      childIds.push(childId);
+    }
+    this.sendFrame(parentStreamId, FORK, new Uint8Array(
+      childIds.flatMap((id) => [id >>> 8 & 255, id & 255])
+    ));
+    return childIds;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Race: first stream to FIN wins, losers are poisoned
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Race multiple streams. The first to send a FIN frame wins.
+   * All other streams in the race are automatically poisoned.
+   *
+   * @param streamIds Streams to race (must all be open)
+   * @returns Promise resolving with the winner's stream ID and final payload
+   */
+  race(streamIds) {
+    if (streamIds.length < 2) {
+      throw new RangeError("Race requires at least 2 streams");
+    }
+    for (const id of streamIds) {
+      const stream = this.requireStream(id);
+      stream.state = "racing";
+    }
+    for (const id of streamIds) {
+      const peerIds = streamIds.filter((sid) => sid !== id);
+      this.sendFrame(id, RACE, new Uint8Array(
+        peerIds.flatMap((pid) => [pid >>> 8 & 255, pid & 255])
+      ));
+    }
+    const groupId = `race-${streamIds.join("-")}-${Date.now()}`;
+    return new Promise((resolve) => {
+      this.raceGroups.set(groupId, {
+        streamIds,
+        resolve,
+        settled: false
+      });
+      for (const id of streamIds) {
+        this.onStreamEnd(id, () => {
+          this.settleRace(groupId, id);
+        });
+      }
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Collapse: wait for all streams, merge results
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Collapse multiple streams: wait for all to complete (or poison),
+   * then merge their results.
+   *
+   * @param streamIds Streams to collapse
+   * @param merger Function that merges results from all streams
+   * @returns Promise resolving with the merged result
+   */
+  collapse(streamIds, merger) {
+    if (streamIds.length < 1) {
+      throw new RangeError("Collapse requires at least 1 stream");
+    }
+    for (const id of streamIds) {
+      const stream = this.requireStream(id);
+      stream.state = "collapsing";
+    }
+    for (const id of streamIds) {
+      this.sendFrame(id, COLLAPSE, new Uint8Array(0));
+    }
+    const groupId = `collapse-${streamIds.join("-")}-${Date.now()}`;
+    return new Promise((resolve) => {
+      const group = {
+        streamIds,
+        merger,
+        resolve,
+        results: /* @__PURE__ */ new Map(),
+        completed: /* @__PURE__ */ new Set(),
+        settled: false
+      };
+      this.collapseGroups.set(groupId, group);
+      for (const id of streamIds) {
+        this.onStreamEnd(id, () => {
+          this.settleCollapse(groupId, id, false);
+        });
+        this.onStreamPoisoned(id, () => {
+          this.settleCollapse(groupId, id, true);
+        });
+      }
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Send / Poison / Close
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Send a payload on a stream.
+   */
+  send(streamId, payload, flags = 0) {
+    const stream = this.requireStream(streamId);
+    if (stream.bufferedFrames >= this.config.highWaterMark) {
+      throw new Error(
+        `Stream ${streamId} backpressure: ${stream.bufferedFrames} frames buffered (high-water mark: ${this.config.highWaterMark})`
+      );
+    }
+    if (payload.length > 0) {
+      stream.results.push(payload);
+    }
+    stream.bufferedFrames++;
+    this.sendFrame(streamId, flags, payload);
+  }
+  /**
+   * 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, finalPayload) {
+    const stream = this.requireStream(streamId);
+    if (finalPayload && finalPayload.length > 0) {
+      stream.results.push(finalPayload);
+    }
+    this.sendFrame(streamId, FIN, finalPayload ?? new Uint8Array(0));
+    stream.state = "closed";
+    const handlers = this.endHandlers.get(streamId);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler();
+      }
+    }
+  }
+  /**
+   * Poison a stream. Sends a POISON frame and propagates to all descendants.
+   *
+   * Poisoning is the protocol-level equivalent of NaN propagation,
+   * AbortSignal cancellation, or error cascading.
+   */
+  poison(streamId) {
+    const stream = this.streams.get(streamId);
+    if (!stream || stream.state === "poisoned" || stream.state === "closed") {
+      return;
+    }
+    stream.state = "poisoned";
+    this.sendFrame(streamId, POISON, new Uint8Array(0));
+    const handlers = this.poisonHandlers.get(streamId);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler();
+      }
+    }
+    for (const childId of stream.children) {
+      this.poison(childId);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Event handlers
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Register a handler for frames arriving on a specific stream.
+   */
+  onFrame(streamId, handler) {
+    let handlers = this.frameHandlers.get(streamId);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.frameHandlers.set(streamId, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+    };
+  }
+  /**
+   * Register a handler for when a stream ends (FIN received).
+   */
+  onStreamEnd(streamId, handler) {
+    let handlers = this.endHandlers.get(streamId);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.endHandlers.set(streamId, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+    };
+  }
+  /**
+   * Register a handler for when a stream is poisoned.
+   */
+  onStreamPoisoned(streamId, handler) {
+    let handlers = this.poisonHandlers.get(streamId);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.poisonHandlers.set(streamId, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      handlers.delete(handler);
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Destroy
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Close the protocol and underlying transport.
+   * Poisons all open streams first.
+   */
+  destroy() {
+    for (const [id, stream] of this.streams) {
+      if (stream.state !== "closed" && stream.state !== "poisoned") {
+        stream.state = "closed";
+      }
+    }
+    this.streams.clear();
+    this.frameHandlers.clear();
+    this.endHandlers.clear();
+    this.poisonHandlers.clear();
+    this.raceGroups.clear();
+    this.collapseGroups.clear();
+    this.transport.close();
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Private: incoming frame handling
+  // ═══════════════════════════════════════════════════════════════════════
+  handleIncoming(data) {
+    let frames;
+    try {
+      frames = this.codec.decodeBatch(data);
+    } catch {
+      return;
+    }
+    for (const frame of frames) {
+      this.handleFrame(frame);
+    }
+  }
+  handleFrame(frame) {
+    const { streamId, flags } = frame;
+    if (!this.streams.has(streamId)) {
+      this.createStream(streamId);
+    }
+    const stream = this.streams.get(streamId);
+    if (flags & POISON) {
+      this.poison(streamId);
+      return;
+    }
+    if (flags & FIN) {
+      if (frame.payload.length > 0) {
+        stream.results.push(frame.payload);
+      }
+      stream.state = "closed";
+      const endHandlers = this.endHandlers.get(streamId);
+      if (endHandlers) {
+        for (const handler of endHandlers) {
+          handler();
+        }
+      }
+      return;
+    }
+    if (flags & FORK) {
+      for (let i = 0; i + 1 < frame.payload.length; i += 2) {
+        const childId = frame.payload[i] << 8 | frame.payload[i + 1];
+        if (!this.streams.has(childId)) {
+          this.createStream(childId, streamId);
+        }
+        if (!stream.children.includes(childId)) {
+          stream.children.push(childId);
+        }
+      }
+      return;
+    }
+    if (frame.payload.length > 0) {
+      stream.results.push(frame.payload);
+    }
+    stream.bufferedFrames++;
+    const handlers = this.frameHandlers.get(streamId);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(frame);
+      }
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Private: race/collapse settlement
+  // ═══════════════════════════════════════════════════════════════════════
+  settleRace(groupId, winnerId) {
+    const group = this.raceGroups.get(groupId);
+    if (!group || group.settled) return;
+    group.settled = true;
+    const winnerStream = this.streams.get(winnerId);
+    const result = winnerStream ? this.concatenateResults(winnerStream.results) : new Uint8Array(0);
+    for (const id of group.streamIds) {
+      if (id !== winnerId) {
+        this.poison(id);
+      }
+    }
+    group.resolve({ winner: winnerId, result });
+    this.raceGroups.delete(groupId);
+  }
+  settleCollapse(groupId, streamId, wasPoisoned) {
+    const group = this.collapseGroups.get(groupId);
+    if (!group || group.settled) return;
+    group.completed.add(streamId);
+    if (!wasPoisoned) {
+      const stream = this.streams.get(streamId);
+      if (stream) {
+        group.results.set(streamId, this.concatenateResults(stream.results));
+      }
+    }
+    if (group.completed.size >= group.streamIds.length) {
+      group.settled = true;
+      const merged = group.merger(group.results);
+      group.resolve(merged);
+      this.collapseGroups.delete(groupId);
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Private: stream helpers
+  // ═══════════════════════════════════════════════════════════════════════
+  allocateStreamId() {
+    if (this.config.role === "client") {
+      const id = this.nextEvenId;
+      this.nextEvenId += 2;
+      return id;
+    } else {
+      const id = this.nextOddId;
+      this.nextOddId += 2;
+      return id;
+    }
+  }
+  createStream(id, parent) {
+    const stream = {
+      id,
+      state: "open",
+      parent,
+      children: [],
+      nextSequence: 0,
+      bufferedFrames: 0,
+      results: []
+    };
+    this.streams.set(id, stream);
+    return stream;
+  }
+  requireStream(streamId, ...allowedStates) {
+    const stream = this.streams.get(streamId);
+    if (!stream) {
+      throw new Error(`Stream ${streamId} does not exist`);
+    }
+    if (allowedStates.length > 0 && !allowedStates.includes(stream.state)) {
+      throw new Error(
+        `Stream ${streamId} is in state '${stream.state}', expected one of: ${allowedStates.join(", ")}`
+      );
+    }
+    return stream;
+  }
+  sendFrame(streamId, flags, payload) {
+    const stream = this.streams.get(streamId);
+    if (!stream) return;
+    const frame = {
+      streamId,
+      sequence: stream.nextSequence++,
+      flags,
+      payload
+    };
+    const encoded = this.codec.encode(frame);
+    this.transport.send(encoded);
+  }
+  concatenateResults(chunks) {
+    if (chunks.length === 0) return new Uint8Array(0);
+    if (chunks.length === 1) return chunks[0];
+    let totalLen = 0;
+    for (const chunk of chunks) totalLen += chunk.length;
+    const result = new Uint8Array(totalLen);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+};
+
+// src/flow/frame-reassembler.ts
+var DEFAULT_REASSEMBLER_CONFIG = {
+  maxBufferPerStream: 256,
+  maxStreams: 1024,
+  maxGap: 64
+};
+var FrameReassembler = class {
+  config;
+  streams = /* @__PURE__ */ new Map();
+  stats = {
+    framesReceived: 0,
+    framesDelivered: 0,
+    framesBuffered: 0,
+    framesDropped: 0,
+    framesReordered: 0,
+    activeStreams: 0
+  };
+  constructor(config) {
+    this.config = { ...DEFAULT_REASSEMBLER_CONFIG, ...config };
+  }
+  /**
+   * 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) {
+    this.stats.framesReceived++;
+    const streamId = frame.streamId;
+    let state = this.streams.get(streamId);
+    if (!state) {
+      if (this.streams.size >= this.config.maxStreams) {
+        this.evictOldestStream();
+      }
+      state = {
+        nextExpected: 0,
+        buffer: /* @__PURE__ */ new Map(),
+        lastActivity: Date.now(),
+        emittedSequences: /* @__PURE__ */ new Set()
+      };
+      this.streams.set(streamId, state);
+      this.stats.activeStreams = this.streams.size;
+    }
+    state.lastActivity = Date.now();
+    if (state.emittedSequences.has(frame.sequence)) {
+      this.stats.framesDropped++;
+      return [];
+    }
+    if (state.buffer.has(frame.sequence)) {
+      this.stats.framesDropped++;
+      return [];
+    }
+    const seq = frame.sequence;
+    if (seq === state.nextExpected) {
+      return this.deliverAndFlush(state, frame);
+    }
+    if (seq < state.nextExpected) {
+      this.stats.framesDropped++;
+      return [];
+    }
+    const gap = seq - state.nextExpected;
+    if (gap > this.config.maxGap) {
+      state.nextExpected = seq;
+      return this.deliverAndFlush(state, frame);
+    }
+    if (state.buffer.size >= this.config.maxBufferPerStream) {
+      this.stats.framesDropped++;
+      return [];
+    }
+    state.buffer.set(seq, frame);
+    this.stats.framesBuffered++;
+    return [];
+  }
+  /**
+   * Get the sequence numbers that are missing (gaps) for a stream.
+   * Used by the reliability layer to request retransmission.
+   */
+  getMissingSequences(streamId) {
+    const state = this.streams.get(streamId);
+    if (!state) return [];
+    const missing = [];
+    const maxBuffered = state.buffer.size > 0 ? Math.max(...state.buffer.keys()) : state.nextExpected;
+    for (let seq = state.nextExpected; seq < maxBuffered; seq++) {
+      if (!state.buffer.has(seq)) {
+        missing.push(seq);
+      }
+    }
+    return missing;
+  }
+  /**
+   * Clean up a stream's reassembly state.
+   * Call when a stream is closed or poisoned.
+   */
+  closeStream(streamId) {
+    const state = this.streams.get(streamId);
+    if (state) {
+      this.stats.framesBuffered -= state.buffer.size;
+      this.streams.delete(streamId);
+      this.stats.activeStreams = this.streams.size;
+    }
+  }
+  /**
+   * Get current reassembly statistics.
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Reset all state.
+   */
+  reset() {
+    this.streams.clear();
+    this.stats = {
+      framesReceived: 0,
+      framesDelivered: 0,
+      framesBuffered: 0,
+      framesDropped: 0,
+      framesReordered: 0,
+      activeStreams: 0
+    };
+  }
+  // ─── Internal ──────────────────────────────────────────────────────────
+  /**
+   * Deliver a frame and flush any consecutively-buffered followers.
+   */
+  deliverAndFlush(state, frame) {
+    const deliverable = [frame];
+    state.emittedSequences.add(frame.sequence);
+    state.nextExpected = frame.sequence + 1;
+    this.stats.framesDelivered++;
+    while (state.buffer.has(state.nextExpected)) {
+      const buffered = state.buffer.get(state.nextExpected);
+      state.buffer.delete(state.nextExpected);
+      state.emittedSequences.add(state.nextExpected);
+      state.nextExpected++;
+      deliverable.push(buffered);
+      this.stats.framesBuffered--;
+      this.stats.framesDelivered++;
+      this.stats.framesReordered++;
+    }
+    if (state.emittedSequences.size > 1024) {
+      const cutoff = state.nextExpected - 512;
+      for (const seq of state.emittedSequences) {
+        if (seq < cutoff) state.emittedSequences.delete(seq);
+      }
+    }
+    return deliverable;
+  }
+  /**
+   * Evict the least-recently-active stream to make room.
+   */
+  evictOldestStream() {
+    let oldestKey = -1;
+    let oldestTime = Infinity;
+    for (const [key, state] of this.streams) {
+      if (state.lastActivity < oldestTime) {
+        oldestTime = state.lastActivity;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey >= 0) {
+      this.closeStream(oldestKey);
+    }
+  }
+};
+
+// src/flow/UDPFlowTransport.ts
+var UDP_MTU = 1472;
+var FRAGMENT_HEADER_SIZE = 4;
+var MAX_FRAGMENT_PAYLOAD = UDP_MTU - FRAGMENT_HEADER_SIZE;
+var ACK_FLAG = 128;
+var ACK_INTERVAL_MS = 50;
+var RETRANSMIT_TIMEOUT_MS = 200;
+var INITIAL_CWND = 16;
+var MAX_CWND = 256;
+var UDPFlowTransport = class {
+  config;
+  receiveHandler = null;
+  closed = false;
+  // UDP socket (set by bind/connect)
+  socket = null;
+  // Frame reassembly (out-of-order)
+  reassembler;
+  // Fragment reassembly (MTU splitting)
+  fragmentGroups = /* @__PURE__ */ new Map();
+  nextFrameId = 0;
+  // Reliability: inflight tracking
+  inflight = /* @__PURE__ */ new Map();
+  // Reliability: ACK state
+  receivedPerStream = /* @__PURE__ */ new Map();
+  ackTimer = null;
+  retransmitTimer = null;
+  // Congestion control
+  cwnd = INITIAL_CWND;
+  inflightCount = 0;
+  // Flow codec for ACK frame encoding
+  codec = FlowCodec.createSync();
+  constructor(config) {
+    this.config = {
+      host: config.host,
+      port: config.port,
+      remoteHost: config.remoteHost ?? "",
+      remotePort: config.remotePort ?? 0,
+      mtu: config.mtu ?? UDP_MTU,
+      reliable: config.reliable ?? true,
+      reassembler: config.reassembler ?? {}
+    };
+    this.reassembler = new FrameReassembler(this.config.reassembler);
+  }
+  /**
+   * Bind and start the UDP transport.
+   *
+   * In server mode (no remoteHost), listens for incoming datagrams.
+   * In client mode, binds and sets the remote endpoint.
+   */
+  async bind() {
+    this.socket = await createUDPSocket(this.config.host, this.config.port);
+    this.socket.onMessage((data, rinfo) => {
+      if (this.closed) return;
+      if (!this.config.remoteHost && rinfo.address) {
+        this.config.remoteHost = rinfo.address;
+        this.config.remotePort = rinfo.port;
+      }
+      this.handleDatagram(data);
+    });
+    if (this.config.reliable) {
+      this.ackTimer = setInterval(() => this.sendAcks(), ACK_INTERVAL_MS);
+      this.retransmitTimer = setInterval(() => this.retransmitLost(), RETRANSMIT_TIMEOUT_MS);
+    }
+  }
+  // ─── FlowTransport interface ───────────────────────────────────────────
+  send(data) {
+    if (this.closed || !this.socket) return;
+    if (this.config.reliable && this.inflightCount >= this.cwnd) {
+      return;
+    }
+    const maxPayload = this.config.mtu - FRAGMENT_HEADER_SIZE;
+    if (data.length <= maxPayload) {
+      const frameId = this.nextFrameId++ & 65535;
+      const datagram = this.wrapFragment(frameId, 0, 1, data);
+      this.sendDatagram(datagram);
+      this.trackInflight(data, frameId);
+    } else {
+      const frameId = this.nextFrameId++ & 65535;
+      const totalFragments = Math.ceil(data.length / maxPayload);
+      if (totalFragments > 255) {
+        return;
+      }
+      for (let i = 0; i < totalFragments; i++) {
+        const start = i * maxPayload;
+        const end = Math.min(start + maxPayload, data.length);
+        const chunk = data.slice(start, end);
+        const datagram = this.wrapFragment(frameId, i, totalFragments, chunk);
+        this.sendDatagram(datagram);
+      }
+      this.trackInflight(data, frameId);
+    }
+  }
+  onReceive(handler) {
+    this.receiveHandler = handler;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.ackTimer) clearInterval(this.ackTimer);
+    if (this.retransmitTimer) clearInterval(this.retransmitTimer);
+    this.socket?.close();
+    this.socket = null;
+    this.receiveHandler = null;
+    this.inflight.clear();
+    this.fragmentGroups.clear();
+    this.reassembler.reset();
+  }
+  // ─── Stats ─────────────────────────────────────────────────────────────
+  /** Get reassembly statistics */
+  getReassemblerStats() {
+    return this.reassembler.getStats();
+  }
+  /** Current congestion window size */
+  get congestionWindow() {
+    return this.cwnd;
+  }
+  /** Number of frames in flight (unacked) */
+  get framesInFlight() {
+    return this.inflightCount;
+  }
+  // ─── Internal: datagram handling ───────────────────────────────────────
+  /**
+   * Handle an incoming UDP datagram.
+   *
+   * Datagram format:
+   *   [frame_id:u16][frag_index:u8][frag_total:u8][payload...]
+   */
+  handleDatagram(data) {
+    if (data.length < FRAGMENT_HEADER_SIZE) return;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const frameId = view.getUint16(0);
+    const fragIndex = data[2];
+    const fragTotal = data[3];
+    const payload = data.subarray(FRAGMENT_HEADER_SIZE);
+    if (fragTotal === 1) {
+      this.handleReassembledFrame(payload);
+    } else {
+      this.handleFragment(frameId, fragIndex, fragTotal, payload);
+    }
+  }
+  /**
+   * Handle a fragment of a multi-datagram flow frame.
+   */
+  handleFragment(frameId, fragIndex, fragTotal, payload) {
+    let group = this.fragmentGroups.get(frameId);
+    if (!group) {
+      group = {
+        frameId,
+        total: fragTotal,
+        received: /* @__PURE__ */ new Map(),
+        createdAt: Date.now()
+      };
+      this.fragmentGroups.set(frameId, group);
+    }
+    group.received.set(fragIndex, payload.slice());
+    if (group.received.size === group.total) {
+      let totalLen = 0;
+      for (let i = 0; i < group.total; i++) {
+        totalLen += group.received.get(i).length;
+      }
+      const reassembled = new Uint8Array(totalLen);
+      let offset = 0;
+      for (let i = 0; i < group.total; i++) {
+        const frag = group.received.get(i);
+        reassembled.set(frag, offset);
+        offset += frag.length;
+      }
+      this.fragmentGroups.delete(frameId);
+      this.handleReassembledFrame(reassembled);
+    }
+    if (this.fragmentGroups.size > 100) {
+      const cutoff = Date.now() - 5e3;
+      for (const [id, g] of this.fragmentGroups) {
+        if (g.createdAt < cutoff) {
+          this.fragmentGroups.delete(id);
+        }
+      }
+    }
+  }
+  /**
+   * Handle a complete (reassembled) flow frame.
+   * This is where we do out-of-order reassembly using the stream_id + sequence.
+   */
+  handleReassembledFrame(data) {
+    if (data.length >= HEADER_SIZE) {
+      const flags = data[6];
+      if (flags & ACK_FLAG) {
+        this.handleAck(data);
+        return;
+      }
+    }
+    let frame;
+    try {
+      const result = this.codec.decode(data);
+      frame = result.frame;
+    } catch {
+      return;
+    }
+    if (this.config.reliable) {
+      let seqSet = this.receivedPerStream.get(frame.streamId);
+      if (!seqSet) {
+        seqSet = /* @__PURE__ */ new Set();
+        this.receivedPerStream.set(frame.streamId, seqSet);
+      }
+      seqSet.add(frame.sequence);
+    }
+    const deliverable = this.reassembler.push(frame);
+    for (const orderedFrame of deliverable) {
+      const encoded = this.codec.encode(orderedFrame);
+      if (this.receiveHandler) {
+        this.receiveHandler(encoded);
+      }
+    }
+  }
+  // ─── Internal: fragmentation ───────────────────────────────────────────
+  /**
+   * Wrap a flow frame chunk in a fragment header.
+   */
+  wrapFragment(frameId, fragIndex, fragTotal, payload) {
+    const datagram = new Uint8Array(FRAGMENT_HEADER_SIZE + payload.length);
+    const view = new DataView(datagram.buffer);
+    view.setUint16(0, frameId);
+    datagram[2] = fragIndex;
+    datagram[3] = fragTotal;
+    datagram.set(payload, FRAGMENT_HEADER_SIZE);
+    return datagram;
+  }
+  /**
+   * Send a UDP datagram to the remote endpoint.
+   */
+  sendDatagram(data) {
+    if (!this.socket || !this.config.remoteHost) return;
+    this.socket.send(data, this.config.remoteHost, this.config.remotePort);
+  }
+  // ─── Internal: reliability ─────────────────────────────────────────────
+  /**
+   * Track a sent frame for potential retransmission.
+   */
+  trackInflight(data, frameId) {
+    if (!this.config.reliable) return;
+    if (data.length < HEADER_SIZE) return;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const streamId = view.getUint16(0);
+    const sequence = view.getUint32(2);
+    const key = `${streamId}:${sequence}`;
+    this.inflight.set(key, {
+      data: data.slice(),
+      streamId,
+      sequence,
+      sentAt: Date.now(),
+      retransmits: 0
+    });
+    this.inflightCount++;
+  }
+  /**
+   * 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)
+   */
+  handleAck(data) {
+    const payload = data.subarray(HEADER_SIZE);
+    const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    for (let offset = 0; offset + 14 <= payload.length; offset += 14) {
+      const streamId = view.getUint16(offset);
+      const baseSeq = view.getUint32(offset + 2);
+      const bitmapHi = view.getUint32(offset + 6);
+      const bitmapLo = view.getUint32(offset + 10);
+      for (let bit = 0; bit < 64; bit++) {
+        const seq = baseSeq + bit;
+        const isAcked = bit < 32 ? (bitmapLo & 1 << bit) !== 0 : (bitmapHi & 1 << bit - 32) !== 0;
+        if (isAcked) {
+          const key = `${streamId}:${seq}`;
+          if (this.inflight.has(key)) {
+            this.inflight.delete(key);
+            this.inflightCount--;
+            if (this.cwnd < MAX_CWND) {
+              this.cwnd += 1 / this.cwnd;
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Send ACK bitmaps for all received sequences.
+   */
+  sendAcks() {
+    if (this.receivedPerStream.size === 0) return;
+    const ackEntries = [];
+    for (const [streamId, seqSet] of this.receivedPerStream) {
+      if (seqSet.size === 0) continue;
+      let baseSeq = Infinity;
+      for (const seq of seqSet) {
+        if (seq < baseSeq) baseSeq = seq;
+      }
+      let bitmapHi = 0;
+      let bitmapLo = 0;
+      for (const seq of seqSet) {
+        const bit = seq - baseSeq;
+        if (bit >= 0 && bit < 64) {
+          if (bit < 32) {
+            bitmapLo |= 1 << bit;
+          } else {
+            bitmapHi |= 1 << bit - 32;
+          }
+        }
+      }
+      const entry = new Uint8Array(14);
+      const view = new DataView(entry.buffer);
+      view.setUint16(0, streamId);
+      view.setUint32(2, baseSeq);
+      view.setUint32(6, bitmapHi);
+      view.setUint32(10, bitmapLo);
+      ackEntries.push(entry);
+      if (seqSet.size > 128) {
+        const cutoff = baseSeq + 64;
+        for (const seq of seqSet) {
+          if (seq < cutoff) seqSet.delete(seq);
+        }
+      }
+    }
+    if (ackEntries.length === 0) return;
+    let totalLen = 0;
+    for (const e of ackEntries) totalLen += e.length;
+    const payload = new Uint8Array(totalLen);
+    let offset = 0;
+    for (const e of ackEntries) {
+      payload.set(e, offset);
+      offset += e.length;
+    }
+    const ackFrame = this.codec.encode({
+      streamId: 65535,
+      // Reserved stream for transport-level control
+      sequence: 0,
+      flags: ACK_FLAG,
+      payload
+    });
+    const datagram = this.wrapFragment(
+      this.nextFrameId++ & 65535,
+      0,
+      1,
+      ackFrame
+    );
+    this.sendDatagram(datagram);
+  }
+  /**
+   * Retransmit frames that haven't been ACKed.
+   */
+  retransmitLost() {
+    const now = Date.now();
+    for (const [key, frame] of this.inflight) {
+      if (now - frame.sentAt > RETRANSMIT_TIMEOUT_MS) {
+        if (frame.retransmits >= 5) {
+          this.inflight.delete(key);
+          this.inflightCount--;
+          this.cwnd = Math.max(INITIAL_CWND, Math.floor(this.cwnd / 2));
+          continue;
+        }
+        frame.retransmits++;
+        frame.sentAt = now;
+        const frameId = this.nextFrameId++ & 65535;
+        const maxPayload = this.config.mtu - FRAGMENT_HEADER_SIZE;
+        if (frame.data.length <= maxPayload) {
+          const datagram = this.wrapFragment(frameId, 0, 1, frame.data);
+          this.sendDatagram(datagram);
+        } else {
+          const totalFragments = Math.ceil(frame.data.length / maxPayload);
+          for (let i = 0; i < totalFragments; i++) {
+            const start = i * maxPayload;
+            const end = Math.min(start + maxPayload, frame.data.length);
+            const chunk = frame.data.slice(start, end);
+            const datagram = this.wrapFragment(frameId, i, totalFragments, chunk);
+            this.sendDatagram(datagram);
+          }
+        }
+        this.cwnd = Math.max(INITIAL_CWND, Math.floor(this.cwnd / 2));
+      }
+    }
+  }
+};
+async function createUDPSocket(host, port) {
+  const dgram = await import('dgram');
+  const socket = dgram.createSocket("udp4");
+  return new Promise((resolve, reject) => {
+    socket.on("error", (err) => reject(err));
+    socket.bind(port, host, () => {
+      const udpSocket = {
+        send(data, remoteHost, remotePort) {
+          socket.send(data, 0, data.length, remotePort, remoteHost);
+        },
+        onMessage(handler) {
+          socket.on("message", (msg, rinfo) => {
+            handler(new Uint8Array(msg), { address: rinfo.address, port: rinfo.port });
+          });
+        },
+        close() {
+          socket.close();
+        }
+      };
+      resolve(udpSocket);
+    });
+  });
+}
+var WebTransportFlowTransport = class _WebTransportFlowTransport {
+  wt;
+  // WebTransport instance (typed as any for portability)
+  writer;
+  receiveHandler = null;
+  closed = false;
+  reassembler;
+  fragmentGroups = /* @__PURE__ */ new Map();
+  nextFrameId = 0;
+  codec = FlowCodec.createSync();
+  constructor(wt) {
+    this.wt = wt;
+    this.reassembler = new FrameReassembler();
+  }
+  /**
+   * Connect to a WebTransport endpoint and return a FlowTransport.
+   */
+  static async connect(url) {
+    if (typeof globalThis.WebTransport === "undefined") {
+      throw new Error("WebTransport not available in this environment");
+    }
+    const wt = new globalThis.WebTransport(url);
+    await wt.ready;
+    const transport = new _WebTransportFlowTransport(wt);
+    transport.writer = wt.datagrams.writable.getWriter();
+    transport.readLoop(wt.datagrams.readable.getReader());
+    return transport;
+  }
+  send(data) {
+    if (this.closed) return;
+    const maxPayload = UDP_MTU - FRAGMENT_HEADER_SIZE;
+    if (data.length <= maxPayload) {
+      const frameId = this.nextFrameId++ & 65535;
+      const datagram = new Uint8Array(FRAGMENT_HEADER_SIZE + data.length);
+      const view = new DataView(datagram.buffer);
+      view.setUint16(0, frameId);
+      datagram[2] = 0;
+      datagram[3] = 1;
+      datagram.set(data, FRAGMENT_HEADER_SIZE);
+      this.writer.write(datagram).catch(() => {
+      });
+    } else {
+      const frameId = this.nextFrameId++ & 65535;
+      const totalFragments = Math.ceil(data.length / maxPayload);
+      if (totalFragments > 255) return;
+      for (let i = 0; i < totalFragments; i++) {
+        const start = i * maxPayload;
+        const end = Math.min(start + maxPayload, data.length);
+        const chunk = data.slice(start, end);
+        const datagram = new Uint8Array(FRAGMENT_HEADER_SIZE + chunk.length);
+        const view = new DataView(datagram.buffer);
+        view.setUint16(0, frameId);
+        datagram[2] = i;
+        datagram[3] = totalFragments;
+        datagram.set(chunk, FRAGMENT_HEADER_SIZE);
+        this.writer.write(datagram).catch(() => {
+        });
+      }
+    }
+  }
+  onReceive(handler) {
+    this.receiveHandler = handler;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.wt.close();
+    this.receiveHandler = null;
+  }
+  async readLoop(reader) {
+    try {
+      while (!this.closed) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        const data = new Uint8Array(value);
+        if (data.length < FRAGMENT_HEADER_SIZE) continue;
+        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        const frameId = view.getUint16(0);
+        const fragIndex = data[2];
+        const fragTotal = data[3];
+        const payload = data.subarray(FRAGMENT_HEADER_SIZE);
+        let reassembled;
+        if (fragTotal === 1) {
+          reassembled = payload;
+        } else {
+          let group = this.fragmentGroups.get(frameId);
+          if (!group) {
+            group = { frameId, total: fragTotal, received: /* @__PURE__ */ new Map(), createdAt: Date.now() };
+            this.fragmentGroups.set(frameId, group);
+          }
+          group.received.set(fragIndex, payload.slice());
+          if (group.received.size < group.total) continue;
+          let totalLen = 0;
+          for (let i = 0; i < group.total; i++) totalLen += group.received.get(i).length;
+          reassembled = new Uint8Array(totalLen);
+          let offset = 0;
+          for (let i = 0; i < group.total; i++) {
+            const frag = group.received.get(i);
+            reassembled.set(frag, offset);
+            offset += frag.length;
+          }
+          this.fragmentGroups.delete(frameId);
+        }
+        try {
+          const result = this.codec.decode(reassembled);
+          const deliverable = this.reassembler.push(result.frame);
+          for (const frame of deliverable) {
+            const encoded = this.codec.encode(frame);
+            if (this.receiveHandler) {
+              this.receiveHandler(encoded);
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/transport/dashrelay.ts
+var ENVELOPE_VERSION = 1;
+var FLAG_DIRECTED = 1;
+var FLAG_HAS_CHANNEL = 2;
+function encodeEnvelope(payload, targetPeerId, channel) {
+  const encoder2 = new TextEncoder();
+  const targetBytes = targetPeerId ? encoder2.encode(targetPeerId) : new Uint8Array(0);
+  const channelBytes = channel ? encoder2.encode(channel) : new Uint8Array(0);
+  let flags = 0;
+  if (targetPeerId) flags |= FLAG_DIRECTED;
+  if (channel) flags |= FLAG_HAS_CHANNEL;
+  const headerSize = 10;
+  const totalSize = headerSize + targetBytes.byteLength + channelBytes.byteLength + payload.byteLength;
+  const envelope = new Uint8Array(totalSize);
+  const view = new DataView(envelope.buffer);
+  envelope[0] = ENVELOPE_VERSION;
+  envelope[1] = flags;
+  view.setUint32(2, targetBytes.byteLength, false);
+  view.setUint32(6, channelBytes.byteLength, false);
+  let offset = headerSize;
+  envelope.set(targetBytes, offset);
+  offset += targetBytes.byteLength;
+  envelope.set(channelBytes, offset);
+  offset += channelBytes.byteLength;
+  envelope.set(payload, offset);
+  return envelope;
+}
+function decodeEnvelope(data) {
+  if (data.byteLength < 10) return null;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  if (data[0] !== ENVELOPE_VERSION) return null;
+  const flags = data[1];
+  const targetLen = view.getUint32(2, false);
+  const channelLen = view.getUint32(6, false);
+  const headerSize = 10;
+  if (data.byteLength < headerSize + targetLen + channelLen) return null;
+  const decoder2 = new TextDecoder();
+  let offset = headerSize;
+  const target = flags & FLAG_DIRECTED ? decoder2.decode(data.subarray(offset, offset + targetLen)) : null;
+  offset += targetLen;
+  const channel = flags & FLAG_HAS_CHANNEL ? decoder2.decode(data.subarray(offset, offset + channelLen)) : null;
+  offset += channelLen;
+  const payload = data.subarray(offset);
+  return { target, channel, payload };
+}
+var DashRelayFlowTransport = class {
+  relay;
+  receiveHandler = null;
+  closed = false;
+  config;
+  peerHandler = null;
+  /** Connected peers observed via relay events */
+  peers = /* @__PURE__ */ new Set();
+  peerJoinHandler = null;
+  peerLeaveHandler = null;
+  /** Optional handlers for peer lifecycle events */
+  onPeerJoin = null;
+  onPeerLeave = null;
+  constructor(relay, config) {
+    this.relay = relay;
+    this.config = config ?? {};
+    this.peerHandler = (senderId, payload) => {
+      if (!this.receiveHandler) return;
+      if (this.config.localPeerId && senderId === this.config.localPeerId) return;
+      const envelope = decodeEnvelope(payload);
+      if (!envelope) return;
+      if (envelope.target && this.config.localPeerId && envelope.target !== this.config.localPeerId) {
+        return;
+      }
+      if (this.config.channel && envelope.channel !== this.config.channel) {
+        return;
+      }
+      this.receiveHandler(envelope.payload);
+    };
+    relay.on("message", this.peerHandler);
+    this.peerJoinHandler = (peerId) => {
+      this.peers.add(peerId);
+      this.onPeerJoin?.(peerId);
+    };
+    this.peerLeaveHandler = (peerId) => {
+      this.peers.delete(peerId);
+      this.onPeerLeave?.(peerId);
+    };
+    relay.on("peerJoined", this.peerJoinHandler);
+    relay.on("peerLeft", this.peerLeaveHandler);
+  }
+  // ─── FlowTransport interface ───────────────────────────────────────
+  send(data) {
+    if (this.closed) return;
+    const envelope = encodeEnvelope(
+      data,
+      this.config.targetPeerId,
+      this.config.channel
+    );
+    this.relay.broadcast(envelope);
+  }
+  onReceive(handler) {
+    this.receiveHandler = handler;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.peerHandler) {
+      this.relay.off("message", this.peerHandler);
+    }
+    if (this.peerJoinHandler) {
+      this.relay.off("peerJoined", this.peerJoinHandler);
+    }
+    if (this.peerLeaveHandler) {
+      this.relay.off("peerLeft", this.peerLeaveHandler);
+    }
+    this.receiveHandler = null;
+    this.onPeerJoin = null;
+    this.onPeerLeave = null;
+  }
+  // ─── Peer awareness ───────────────────────────────────────────────
+  /** Get all known peers in the room */
+  getPeers() {
+    return Array.from(this.peers);
+  }
+  /** Number of peers in the room */
+  get peerCount() {
+    return this.peers.size;
+  }
+  /** Whether the transport is still open */
+  get isOpen() {
+    return !this.closed;
+  }
+  /** Send to a specific peer (overrides config.targetPeerId for this call) */
+  sendTo(peerId, data) {
+    if (this.closed) return;
+    const envelope = encodeEnvelope(data, peerId, this.config.channel);
+    this.relay.broadcast(envelope);
+  }
+};
+function createDashRelayFlow(relay, channel, config) {
+  return new DashRelayFlowTransport(relay, { ...config, channel });
+}
+
+// src/transport/bluetooth.ts
+var AEON_FLOW_SERVICE_UUID = "0000af10-0000-1000-8000-00805f9b34fb";
+var AEON_FLOW_TX_UUID = "0000af11-0000-1000-8000-00805f9b34fb";
+var AEON_FLOW_RX_UUID = "0000af12-0000-1000-8000-00805f9b34fb";
+var DEFAULT_MTU = 512 - 3;
+var FRAME_BOUNDARY = new Uint8Array([174, 15, 16, 255]);
+var BluetoothFlowTransport = class _BluetoothFlowTransport {
+  constructor(config = {}) {
+    this.config = config;
+    this.mtu = config.mtu ?? DEFAULT_MTU;
+  }
+  device = null;
+  txChar = null;
+  rxChar = null;
+  receiveHandler = null;
+  mtu;
+  closed = false;
+  /** Reassembly buffer for fragmented incoming frames */
+  rxBuffer = [];
+  /**
+   * Scan for and connect to a nearby Aeon device.
+   * Returns the connected device name.
+   */
+  async connect() {
+    const serviceUuid = this.config.serviceUuid ?? AEON_FLOW_SERVICE_UUID;
+    const filters = [];
+    if (this.config.namePrefix) {
+      filters.push({ namePrefix: this.config.namePrefix });
+    }
+    filters.push({ services: [serviceUuid] });
+    this.device = await navigator.bluetooth.requestDevice({
+      filters,
+      optionalServices: [serviceUuid]
+    });
+    if (!this.device.gatt) {
+      throw new Error("GATT not available on device");
+    }
+    const server = await this.device.gatt.connect();
+    const service = await server.getPrimaryService(serviceUuid);
+    this.txChar = await service.getCharacteristic(
+      this.config.serviceUuid ? AEON_FLOW_TX_UUID : AEON_FLOW_TX_UUID
+    );
+    this.rxChar = await service.getCharacteristic(AEON_FLOW_RX_UUID);
+    await this.rxChar.startNotifications();
+    this.rxChar.addEventListener(
+      "characteristicvaluechanged",
+      this.handleRxNotification
+    );
+    this.device.addEventListener("gattserverdisconnected", () => {
+      this.closed = true;
+      this.receiveHandler = null;
+    });
+    return this.device.name || this.device.id;
+  }
+  /**
+   * Create from an already-connected GATT server (for peripheral/server mode).
+   */
+  static fromCharacteristics(tx, rx, config) {
+    const transport = new _BluetoothFlowTransport(config);
+    transport.txChar = tx;
+    transport.rxChar = rx;
+    rx.addEventListener(
+      "characteristicvaluechanged",
+      transport.handleRxNotification
+    );
+    return transport;
+  }
+  // ─── FlowTransport interface ───────────────────────────────────────
+  send(data) {
+    if (this.closed || !this.txChar) return;
+    const fragmentSize = this.mtu - FRAME_BOUNDARY.length;
+    if (data.byteLength <= fragmentSize) {
+      const packet = new Uint8Array(data.byteLength + FRAME_BOUNDARY.length);
+      packet.set(data);
+      packet.set(FRAME_BOUNDARY, data.byteLength);
+      this.writeCharacteristic(packet);
+    } else {
+      let offset = 0;
+      while (offset < data.byteLength) {
+        const chunkSize = Math.min(fragmentSize, data.byteLength - offset);
+        const isLast = offset + chunkSize >= data.byteLength;
+        const chunk = data.subarray(offset, offset + chunkSize);
+        if (isLast) {
+          const packet = new Uint8Array(chunk.byteLength + FRAME_BOUNDARY.length);
+          packet.set(chunk);
+          packet.set(FRAME_BOUNDARY, chunk.byteLength);
+          this.writeCharacteristic(packet);
+        } else {
+          this.writeCharacteristic(chunk);
+        }
+        offset += chunkSize;
+      }
+    }
+  }
+  onReceive(handler) {
+    this.receiveHandler = handler;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.rxChar) {
+      this.rxChar.removeEventListener(
+        "characteristicvaluechanged",
+        this.handleRxNotification
+      );
+      this.rxChar.stopNotifications().catch(() => {
+      });
+    }
+    if (this.device?.gatt?.connected) {
+      this.device.gatt.disconnect();
+    }
+    this.receiveHandler = null;
+    this.rxBuffer = [];
+  }
+  /** Whether Bluetooth is connected */
+  get isConnected() {
+    return !this.closed && !!this.device?.gatt?.connected;
+  }
+  // ─── Internal ──────────────────────────────────────────────────────
+  async writeCharacteristic(data) {
+    if (!this.txChar) return;
+    try {
+      await this.txChar.writeValueWithoutResponse(data);
+    } catch {
+    }
+  }
+  handleRxNotification = (event) => {
+    const target = event.target;
+    if (!target.value) return;
+    const chunk = new Uint8Array(target.value.buffer);
+    if (this.endsWithBoundary(chunk)) {
+      const frameData = chunk.subarray(0, chunk.byteLength - FRAME_BOUNDARY.length);
+      if (this.rxBuffer.length > 0) {
+        this.rxBuffer.push(frameData);
+        const totalLen = this.rxBuffer.reduce((s, b) => s + b.byteLength, 0);
+        const assembled = new Uint8Array(totalLen);
+        let offset = 0;
+        for (const buf of this.rxBuffer) {
+          assembled.set(buf, offset);
+          offset += buf.byteLength;
+        }
+        this.rxBuffer = [];
+        this.receiveHandler?.(assembled);
+      } else {
+        this.receiveHandler?.(frameData);
+      }
+    } else {
+      this.rxBuffer.push(chunk);
+    }
+  };
+  endsWithBoundary(data) {
+    if (data.byteLength < FRAME_BOUNDARY.length) return false;
+    const tail = data.subarray(data.byteLength - FRAME_BOUNDARY.length);
+    return tail[0] === FRAME_BOUNDARY[0] && tail[1] === FRAME_BOUNDARY[1] && tail[2] === FRAME_BOUNDARY[2] && tail[3] === FRAME_BOUNDARY[3];
+  }
+};
+
+// src/transport/webrtc.ts
+var WebRTCFlowTransport = class {
+  pc = null;
+  dc = null;
+  signalingWs = null;
+  receiveHandler = null;
+  closed = false;
+  peerId;
+  config;
+  maxBufferedAmount;
+  constructor(config) {
+    this.config = config;
+    this.peerId = config.peerId ?? crypto.randomUUID();
+    this.maxBufferedAmount = config.maxBufferedAmount ?? 16 * 1024 * 1024;
+  }
+  /**
+   * Initialize as the offering peer (initiator).
+   * Connects to signaling, creates offer, waits for answer.
+   */
+  async offer() {
+    await this.connectSignaling();
+    this.pc = new RTCPeerConnection({
+      iceServers: this.config.iceServers ?? [
+        { urls: "stun:stun.l.google.com:19302" }
+      ]
+    });
+    const label = this.config.channelLabel ?? "aeon-flow";
+    this.dc = this.pc.createDataChannel(label, {
+      ordered: true,
+      protocol: "aeon-flow"
+    });
+    this.dc.binaryType = "arraybuffer";
+    this.wireDataChannel(this.dc);
+    this.pc.onicecandidate = (event) => {
+      if (event.candidate) {
+        this.sendSignaling({
+          type: "ice-candidate",
+          from: this.peerId,
+          to: "*",
+          payload: event.candidate.toJSON()
+        });
+      }
+    };
+    const offer = await this.pc.createOffer();
+    await this.pc.setLocalDescription(offer);
+    this.sendSignaling({
+      type: "offer",
+      from: this.peerId,
+      to: "*",
+      payload: offer
+    });
+  }
+  /**
+   * Initialize as the answering peer (responder).
+   * Waits for an offer, creates answer.
+   */
+  async answer() {
+    await this.connectSignaling();
+    this.pc = new RTCPeerConnection({
+      iceServers: this.config.iceServers ?? [
+        { urls: "stun:stun.l.google.com:19302" }
+      ]
+    });
+    this.pc.onicecandidate = (event) => {
+      if (event.candidate) {
+        this.sendSignaling({
+          type: "ice-candidate",
+          from: this.peerId,
+          to: "*",
+          payload: event.candidate.toJSON()
+        });
+      }
+    };
+    this.pc.ondatachannel = (event) => {
+      this.dc = event.channel;
+      this.dc.binaryType = "arraybuffer";
+      this.wireDataChannel(this.dc);
+    };
+  }
+  /**
+   * Wait until the DataChannel is open and ready.
+   */
+  async waitForOpen() {
+    if (this.dc?.readyState === "open") return;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("WebRTC DataChannel open timeout"));
+      }, 3e4);
+      const check = () => {
+        if (this.dc?.readyState === "open") {
+          clearTimeout(timeout);
+          resolve();
+        }
+      };
+      const interval = setInterval(check, 100);
+      check();
+      if (this.dc) {
+        const onOpen = () => {
+          clearTimeout(timeout);
+          clearInterval(interval);
+          resolve();
+        };
+        this.dc.addEventListener("open", onOpen, { once: true });
+      }
+    });
+  }
+  // ─── FlowTransport interface ───────────────────────────────────────
+  send(data) {
+    if (this.closed || !this.dc) return;
+    if (this.dc.readyState !== "open") return;
+    if (this.dc.bufferedAmount > this.maxBufferedAmount) {
+      console.warn("[aeon-webrtc] DataChannel buffer full, dropping frame");
+      return;
+    }
+    this.dc.send(data);
+  }
+  onReceive(handler) {
+    this.receiveHandler = handler;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.dc?.close();
+    this.pc?.close();
+    this.signalingWs?.close();
+    this.receiveHandler = null;
+    this.dc = null;
+    this.pc = null;
+    this.signalingWs = null;
+  }
+  /** Whether the DataChannel is open */
+  get isOpen() {
+    return !this.closed && this.dc?.readyState === "open";
+  }
+  /** Get this peer's ID */
+  get id() {
+    return this.peerId;
+  }
+  // ─── Internal ──────────────────────────────────────────────────────
+  wireDataChannel(dc) {
+    dc.onmessage = (event) => {
+      if (!this.receiveHandler) return;
+      if (event.data instanceof ArrayBuffer) {
+        this.receiveHandler(new Uint8Array(event.data));
+      }
+    };
+    dc.onclose = () => {
+      this.closed = true;
+      this.receiveHandler = null;
+    };
+    dc.onerror = () => {
+    };
+  }
+  async connectSignaling() {
+    const url = this.config.signalingUrl ?? "wss://relay.dashrelay.com/relay/sync";
+    const roomUrl = `${url}?room=${encodeURIComponent(this.config.roomId)}&peer=${encodeURIComponent(this.peerId)}`;
+    this.signalingWs = new WebSocket(roomUrl);
+    await new Promise((resolve, reject) => {
+      const ws = this.signalingWs;
+      ws.onopen = () => resolve();
+      ws.onerror = () => reject(new Error("Signaling connection failed"));
+    });
+    this.signalingWs.onmessage = async (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        if (msg.from === this.peerId) return;
+        switch (msg.type) {
+          case "offer": {
+            if (!this.pc) return;
+            const desc = msg.payload;
+            await this.pc.setRemoteDescription(desc);
+            const answer = await this.pc.createAnswer();
+            await this.pc.setLocalDescription(answer);
+            this.sendSignaling({
+              type: "answer",
+              from: this.peerId,
+              to: msg.from,
+              payload: answer
+            });
+            break;
+          }
+          case "answer": {
+            if (!this.pc) return;
+            const desc = msg.payload;
+            await this.pc.setRemoteDescription(desc);
+            break;
+          }
+          case "ice-candidate": {
+            if (!this.pc) return;
+            const candidate = msg.payload;
+            await this.pc.addIceCandidate(candidate);
+            break;
+          }
+        }
+      } catch {
+      }
+    };
+  }
+  sendSignaling(msg) {
+    if (this.signalingWs?.readyState === WebSocket.OPEN) {
+      this.signalingWs.send(JSON.stringify(msg));
+    }
+  }
+};
+async function createP2PFlow(roomId, role, config) {
+  const transport = new WebRTCFlowTransport({ roomId, ...config });
+  if (role === "initiator") {
+    await transport.offer();
+  } else {
+    await transport.answer();
+  }
+  await transport.waitForOpen();
+  return transport;
+}
+
+// src/transport/tcp.ts
+var LENGTH_PREFIX_SIZE = 4;
+function encodeFrame(data) {
+  const frame = new Uint8Array(LENGTH_PREFIX_SIZE + data.byteLength);
+  const view = new DataView(frame.buffer);
+  view.setUint32(0, data.byteLength, false);
+  frame.set(data, LENGTH_PREFIX_SIZE);
+  return frame;
+}
+var TCPFlowTransport = class {
+  socket;
+  receiveHandler = null;
+  closed = false;
+  /** Reassembly buffer for TCP stream → discrete messages */
+  rxBuffer = new Uint8Array(0);
+  constructor(socket, config) {
+    this.socket = socket;
+    socket.setNoDelay?.(true);
+    socket.setKeepAlive?.(true, config?.keepAliveMs ?? 3e4);
+    socket.on("data", (chunk) => {
+      this.onData(new Uint8Array(chunk));
+    });
+    socket.on("close", () => {
+      this.closed = true;
+      this.receiveHandler = null;
+    });
+    socket.on("error", () => {
+    });
+  }
+  // ─── FlowTransport interface ───────────────────────────────────────
+  send(data) {
+    if (this.closed) return;
+    const frame = encodeFrame(data);
+    this.socket.write(frame);
+  }
+  onReceive(handler) {
+    this.receiveHandler = handler;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.receiveHandler = null;
+    this.socket.end();
+  }
+  /** Whether the transport is still open */
+  get isOpen() {
+    return !this.closed;
+  }
+  // ─── Internal: Stream Reassembly ──────────────────────────────────
+  onData(chunk) {
+    const combined = new Uint8Array(this.rxBuffer.byteLength + chunk.byteLength);
+    combined.set(this.rxBuffer);
+    combined.set(chunk, this.rxBuffer.byteLength);
+    this.rxBuffer = combined;
+    while (this.rxBuffer.byteLength >= LENGTH_PREFIX_SIZE) {
+      const view = new DataView(
+        this.rxBuffer.buffer,
+        this.rxBuffer.byteOffset,
+        this.rxBuffer.byteLength
+      );
+      const msgLen = view.getUint32(0, false);
+      if (this.rxBuffer.byteLength < LENGTH_PREFIX_SIZE + msgLen) {
+        break;
+      }
+      const message = this.rxBuffer.slice(
+        LENGTH_PREFIX_SIZE,
+        LENGTH_PREFIX_SIZE + msgLen
+      );
+      this.rxBuffer = this.rxBuffer.slice(LENGTH_PREFIX_SIZE + msgLen);
+      this.receiveHandler?.(message);
+    }
+  }
+};
+async function connectTCPFlow(host, port, config) {
+  const net = await import('net');
+  const timeout = config?.connectTimeout ?? 1e4;
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection({ host, port }, () => {
+      resolve(new TCPFlowTransport(socket, config));
+    });
+    socket.setTimeout(timeout);
+    socket.on("timeout", () => {
+      socket.destroy();
+      reject(new Error(`TCP connection timeout to ${host}:${port}`));
+    });
+    socket.on("error", (err) => {
+      reject(new Error(`TCP connection failed to ${host}:${port}: ${err.message}`));
+    });
+  });
+}
+async function listenTCPFlow(port, host, onConnection) {
+  const net = await import('net');
+  const server = net.createServer((socket) => {
+    const transport = new TCPFlowTransport(socket);
+    onConnection(transport);
+  });
+  return new Promise((resolve, reject) => {
+    server.listen(port, host, () => {
+      resolve({
+        close: () => server.close()
+      });
+    });
+    server.on("error", (err) => {
+      reject(new Error(`TCP flow server failed on ${host}:${port}: ${err.message}`));
+    });
+  });
+}
+
+// src/transport/ipc.ts
+var MessagePortFlowTransport = class {
+  port;
+  receiveHandler = null;
+  closed = false;
+  transferBuffers;
+  messageHandler = null;
+  constructor(port, config) {
+    this.port = port;
+    this.transferBuffers = config?.transferBuffers ?? false;
+    port.start?.();
+    this.messageHandler = (event) => {
+      if (!this.receiveHandler) return;
+      const data = event.data;
+      if (data instanceof ArrayBuffer) {
+        this.receiveHandler(new Uint8Array(data));
+      } else if (data instanceof Uint8Array) {
+        this.receiveHandler(data);
+      } else if (data?.type === "aeon-flow" && data.buffer instanceof ArrayBuffer) {
+        this.receiveHandler(new Uint8Array(data.buffer));
+      }
+    };
+    if (port.addEventListener) {
+      port.addEventListener("message", this.messageHandler);
+    } else {
+      port.onmessage = this.messageHandler;
+    }
+  }
+  // ─── FlowTransport interface ───────────────────────────────────────
+  send(data) {
+    if (this.closed) return;
+    if (this.transferBuffers) {
+      const copy = new Uint8Array(data);
+      this.port.postMessage(copy.buffer, [copy.buffer]);
+    } else {
+      this.port.postMessage({ type: "aeon-flow", buffer: data.buffer.slice(0) });
+    }
+  }
+  onReceive(handler) {
+    this.receiveHandler = handler;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.messageHandler) {
+      if (this.port.removeEventListener) {
+        this.port.removeEventListener("message", this.messageHandler);
+      } else {
+        this.port.onmessage = null;
+      }
+    }
+    this.receiveHandler = null;
+    this.port.close?.();
+  }
+  /** Whether the transport is still open */
+  get isOpen() {
+    return !this.closed;
+  }
+};
+var ChildProcessFlowTransport = class {
+  process;
+  receiveHandler = null;
+  closed = false;
+  ipcHandler = null;
+  constructor(childProcess) {
+    this.process = childProcess;
+    this.ipcHandler = (data) => {
+      if (!this.receiveHandler) return;
+      if (data instanceof Uint8Array || Buffer.isBuffer(data)) {
+        this.receiveHandler(new Uint8Array(data));
+      } else if (typeof data === "object" && data !== null && data.type === "aeon-flow") {
+        const buffer = data.buffer;
+        if (buffer instanceof ArrayBuffer) {
+          this.receiveHandler(new Uint8Array(buffer));
+        } else if (typeof buffer === "object" && buffer !== null && "data" in buffer) {
+          const arr = buffer.data;
+          this.receiveHandler(new Uint8Array(arr));
+        }
+      }
+    };
+    childProcess.on("message", this.ipcHandler);
+    childProcess.on("exit", () => {
+      this.closed = true;
+      this.receiveHandler = null;
+    });
+  }
+  // ─── FlowTransport interface ───────────────────────────────────────
+  send(data) {
+    if (this.closed) return;
+    this.process.send({
+      type: "aeon-flow",
+      buffer: Array.from(data)
+      // Serialize as plain array for V8 IPC
+    });
+  }
+  onReceive(handler) {
+    this.receiveHandler = handler;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.ipcHandler && this.process.removeListener) {
+      this.process.removeListener("message", this.ipcHandler);
+    }
+    this.receiveHandler = null;
+  }
+  /** Whether the transport is still open */
+  get isOpen() {
+    return !this.closed;
+  }
+};
+function createIPCPair(config) {
+  const channel = new MessageChannel();
+  return [
+    new MessagePortFlowTransport(channel.port1, config),
+    new MessagePortFlowTransport(channel.port2, config)
+  ];
+}
+
+// src/transport/usb.ts
+var AEON_USB_INTERFACE_CLASS = 255;
+var AEON_USB_SUBCLASS = 174;
+var AEON_USB_PROTOCOL = 1;
+var LENGTH_PREFIX_SIZE2 = 4;
+var DEFAULT_TRANSFER_SIZE = 64 * 1024;
+var USBFlowTransport = class _USBFlowTransport {
+  device;
+  receiveHandler = null;
+  closed = false;
+  interfaceNum;
+  outEndpoint;
+  inEndpoint;
+  transferSize;
+  readLoopRunning = false;
+  /** Reassembly buffer for length-prefixed framing */
+  rxBuffer = new Uint8Array(0);
+  constructor(device, interfaceNum, outEndpoint, inEndpoint, transferSize) {
+    this.device = device;
+    this.interfaceNum = interfaceNum;
+    this.outEndpoint = outEndpoint;
+    this.inEndpoint = inEndpoint;
+    this.transferSize = transferSize;
+  }
+  /**
+   * 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 async connect(config) {
+    const filters = [];
+    if (config?.vendorId !== void 0) {
+      const filter = { vendorId: config.vendorId };
+      if (config.productId !== void 0) {
+        filter.productId = config.productId;
+      }
+      filters.push(filter);
+    }
+    const device = await navigator.usb.requestDevice({
+      filters: filters.length > 0 ? filters : [{ classCode: AEON_USB_INTERFACE_CLASS }]
+    });
+    await device.open();
+    let interfaceNum = config?.interfaceNumber;
+    let outEp = config?.outEndpoint;
+    let inEp = config?.inEndpoint;
+    if (interfaceNum === void 0 || outEp === void 0 || inEp === void 0) {
+      const iface = device.configuration?.interfaces.find(
+        (i) => i.alternates.some(
+          (alt) => alt.interfaceClass === AEON_USB_INTERFACE_CLASS && alt.interfaceSubclass === AEON_USB_SUBCLASS
+        )
+      );
+      if (!iface) {
+        throw new Error("No Aeon USB interface found on device");
+      }
+      interfaceNum = iface.interfaceNumber;
+      const alternate = iface.alternates.find(
+        (alt) => alt.interfaceClass === AEON_USB_INTERFACE_CLASS && alt.interfaceSubclass === AEON_USB_SUBCLASS
+      );
+      for (const ep of alternate.endpoints) {
+        if (ep.type === "bulk") {
+          if (ep.direction === "out" && outEp === void 0) {
+            outEp = ep.endpointNumber;
+          } else if (ep.direction === "in" && inEp === void 0) {
+            inEp = ep.endpointNumber;
+          }
+        }
+      }
+    }
+    if (interfaceNum === void 0 || outEp === void 0 || inEp === void 0) {
+      throw new Error("Could not find bulk endpoints on Aeon USB interface");
+    }
+    await device.claimInterface(interfaceNum);
+    const transport = new _USBFlowTransport(
+      device,
+      interfaceNum,
+      outEp,
+      inEp,
+      config?.transferSize ?? DEFAULT_TRANSFER_SIZE
+    );
+    transport.startReadLoop();
+    return transport;
+  }
+  /**
+   * Create from an already-opened USB device (for testing or manual setup).
+   */
+  static fromDevice(device, interfaceNum, outEndpoint, inEndpoint, config) {
+    const transport = new _USBFlowTransport(
+      device,
+      interfaceNum,
+      outEndpoint,
+      inEndpoint,
+      config?.transferSize ?? DEFAULT_TRANSFER_SIZE
+    );
+    transport.startReadLoop();
+    return transport;
+  }
+  // ─── FlowTransport interface ───────────────────────────────────────
+  send(data) {
+    if (this.closed) return;
+    const frame = new Uint8Array(LENGTH_PREFIX_SIZE2 + data.byteLength);
+    const view = new DataView(frame.buffer);
+    view.setUint32(0, data.byteLength, false);
+    frame.set(data, LENGTH_PREFIX_SIZE2);
+    this.device.transferOut(this.outEndpoint, frame).catch(() => {
+    });
+  }
+  onReceive(handler) {
+    this.receiveHandler = handler;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.readLoopRunning = false;
+    this.receiveHandler = null;
+    this.device.releaseInterface(this.interfaceNum).then(() => {
+      this.device.close().catch(() => {
+      });
+    }).catch(() => {
+    });
+  }
+  /** Whether the transport is still open */
+  get isOpen() {
+    return !this.closed;
+  }
+  /** Get the USB device info */
+  get deviceInfo() {
+    return {
+      vendorId: this.device.vendorId,
+      productId: this.device.productId,
+      name: this.device.productName ?? this.device.serialNumber ?? "Unknown"
+    };
+  }
+  // ─── Internal: Continuous Read Loop ───────────────────────────────
+  startReadLoop() {
+    if (this.readLoopRunning) return;
+    this.readLoopRunning = true;
+    const loop = async () => {
+      while (this.readLoopRunning && !this.closed) {
+        try {
+          const result = await this.device.transferIn(
+            this.inEndpoint,
+            this.transferSize
+          );
+          if (result.status === "ok" && result.data && result.data.byteLength > 0) {
+            const chunk = new Uint8Array(result.data.buffer);
+            this.processChunk(chunk);
+          }
+        } catch {
+          if (!this.closed) {
+            this.closed = true;
+            this.readLoopRunning = false;
+            this.receiveHandler = null;
+          }
+          return;
+        }
+      }
+    };
+    void loop();
+  }
+  processChunk(chunk) {
+    const combined = new Uint8Array(this.rxBuffer.byteLength + chunk.byteLength);
+    combined.set(this.rxBuffer);
+    combined.set(chunk, this.rxBuffer.byteLength);
+    this.rxBuffer = combined;
+    while (this.rxBuffer.byteLength >= LENGTH_PREFIX_SIZE2) {
+      const view = new DataView(
+        this.rxBuffer.buffer,
+        this.rxBuffer.byteOffset,
+        this.rxBuffer.byteLength
+      );
+      const msgLen = view.getUint32(0, false);
+      if (this.rxBuffer.byteLength < LENGTH_PREFIX_SIZE2 + msgLen) {
+        break;
+      }
+      const message = this.rxBuffer.slice(
+        LENGTH_PREFIX_SIZE2,
+        LENGTH_PREFIX_SIZE2 + msgLen
+      );
+      this.rxBuffer = this.rxBuffer.slice(LENGTH_PREFIX_SIZE2 + msgLen);
+      this.receiveHandler?.(message);
+    }
+  }
+};
+
+// src/transport/http.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function encodeHTTPRequest(req) {
+  const methodBytes = encoder.encode(req.method);
+  const fullPath = req.query ? `${req.path}?${req.query}` : req.path;
+  const pathBytes = encoder.encode(fullPath);
+  const headersBytes = encoder.encode(JSON.stringify(req.headers));
+  const bodyBytes = req.body ?? new Uint8Array(0);
+  const headerSize = 16;
+  const totalSize = headerSize + methodBytes.byteLength + pathBytes.byteLength + headersBytes.byteLength + bodyBytes.byteLength;
+  const encoded = new Uint8Array(totalSize);
+  const view = new DataView(encoded.buffer);
+  view.setUint32(0, methodBytes.byteLength, false);
+  view.setUint32(4, pathBytes.byteLength, false);
+  view.setUint32(8, headersBytes.byteLength, false);
+  view.setUint32(12, bodyBytes.byteLength, false);
+  let offset = headerSize;
+  encoded.set(methodBytes, offset);
+  offset += methodBytes.byteLength;
+  encoded.set(pathBytes, offset);
+  offset += pathBytes.byteLength;
+  encoded.set(headersBytes, offset);
+  offset += headersBytes.byteLength;
+  encoded.set(bodyBytes, offset);
+  return encoded;
+}
+function decodeHTTPRequest(data) {
+  if (data.byteLength < 16) throw new Error("Invalid HTTP request frame");
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const methodLen = view.getUint32(0, false);
+  const pathLen = view.getUint32(4, false);
+  const headersLen = view.getUint32(8, false);
+  const bodyLen = view.getUint32(12, false);
+  let offset = 16;
+  const method = decoder.decode(data.subarray(offset, offset + methodLen));
+  offset += methodLen;
+  const fullPath = decoder.decode(data.subarray(offset, offset + pathLen));
+  offset += pathLen;
+  const headersJson = decoder.decode(data.subarray(offset, offset + headersLen));
+  offset += headersLen;
+  const body = bodyLen > 0 ? data.slice(offset, offset + bodyLen) : void 0;
+  const qIdx = fullPath.indexOf("?");
+  const path = qIdx >= 0 ? fullPath.substring(0, qIdx) : fullPath;
+  const query = qIdx >= 0 ? fullPath.substring(qIdx + 1) : void 0;
+  return {
+    method,
+    path,
+    query,
+    headers: JSON.parse(headersJson),
+    body,
+    requestId: ""
+    // Assigned by caller
+  };
+}
+function encodeHTTPResponse(res) {
+  const headersBytes = encoder.encode(JSON.stringify(res.headers));
+  const bodyBytes = res.body;
+  const headerSize = 10;
+  const totalSize = headerSize + headersBytes.byteLength + bodyBytes.byteLength;
+  const encoded = new Uint8Array(totalSize);
+  const view = new DataView(encoded.buffer);
+  view.setUint16(0, res.status, false);
+  view.setUint32(2, headersBytes.byteLength, false);
+  view.setUint32(6, bodyBytes.byteLength, false);
+  let offset = headerSize;
+  encoded.set(headersBytes, offset);
+  offset += headersBytes.byteLength;
+  encoded.set(bodyBytes, offset);
+  return encoded;
+}
+function decodeHTTPResponse(data) {
+  if (data.byteLength < 10) throw new Error("Invalid HTTP response frame");
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const status = view.getUint16(0, false);
+  const headersLen = view.getUint32(2, false);
+  const bodyLen = view.getUint32(6, false);
+  let offset = 10;
+  const headersJson = decoder.decode(data.subarray(offset, offset + headersLen));
+  offset += headersLen;
+  const body = data.slice(offset, offset + bodyLen);
+  return {
+    status,
+    headers: JSON.parse(headersJson),
+    body
+  };
+}
+var HTTPAeonBridge = class {
+  transport;
+  config;
+  /** Pending HTTP requests waiting for flow responses */
+  pending = /* @__PURE__ */ new Map();
+  /** Handler for incoming HTTP requests (from nginx side) */
+  requestHandler = null;
+  constructor(transport, config) {
+    this.transport = transport;
+    this.config = config ?? {};
+    transport.onReceive((data) => {
+      this.handleIncoming(data);
+    });
+  }
+  /**
+   * 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) {
+    this.requestHandler = handler;
+  }
+  /**
+   * 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.
+   */
+  async sendRequest(req) {
+    const timeout = this.config.responseTimeout ?? 3e4;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(req.requestId);
+        reject(new Error(`Flow response timeout for ${req.method} ${req.path}`));
+      }, timeout);
+      this.pending.set(req.requestId, { resolve, reject, timer, chunks: [] });
+      const payload = encodeHTTPRequest(req);
+      const reqIdBytes = encoder.encode(req.requestId);
+      const frame = new Uint8Array(4 + reqIdBytes.byteLength + payload.byteLength);
+      const view = new DataView(frame.buffer);
+      view.setUint32(0, reqIdBytes.byteLength, false);
+      frame.set(reqIdBytes, 4);
+      frame.set(payload, 4 + reqIdBytes.byteLength);
+      this.transport.send(frame);
+    });
+  }
+  /**
+   * Send an HTTP response back through the bridge (used by Aeon side).
+   */
+  sendResponse(res) {
+    const payload = encodeHTTPResponse(res);
+    const reqIdBytes = encoder.encode(res.requestId);
+    const frame = new Uint8Array(5 + reqIdBytes.byteLength + payload.byteLength);
+    const view = new DataView(frame.buffer);
+    frame[0] = 2;
+    view.setUint32(1, reqIdBytes.byteLength, false);
+    frame.set(reqIdBytes, 5);
+    frame.set(payload, 5 + reqIdBytes.byteLength);
+    this.transport.send(frame);
+  }
+  close() {
+    for (const [, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Bridge closed"));
+    }
+    this.pending.clear();
+    this.transport.close();
+  }
+  // ─── Internal ──────────────────────────────────────────────────────
+  handleIncoming(data) {
+    if (data.byteLength < 5) return;
+    if (data[0] === 2) {
+      this.handleResponseFrame(data);
+    } else {
+      this.handleRequestFrame(data);
+    }
+  }
+  handleResponseFrame(data) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const reqIdLen = view.getUint32(1, false);
+    const requestId = decoder.decode(data.subarray(5, 5 + reqIdLen));
+    const payload = data.subarray(5 + reqIdLen);
+    const pending = this.pending.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this.pending.delete(requestId);
+    const response = decodeHTTPResponse(payload);
+    pending.resolve({ ...response, requestId });
+  }
+  async handleRequestFrame(data) {
+    if (!this.requestHandler) return;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const reqIdLen = view.getUint32(0, false);
+    const requestId = decoder.decode(data.subarray(4, 4 + reqIdLen));
+    const payload = data.subarray(4 + reqIdLen);
+    const request = decodeHTTPRequest(payload);
+    request.requestId = requestId;
+    try {
+      const response = await this.requestHandler(request);
+      this.sendResponse(response);
+    } catch (err) {
+      this.sendResponse({
+        requestId,
+        status: 502,
+        headers: { "content-type": "text/plain" },
+        body: encoder.encode(err instanceof Error ? err.message : "Internal flow error")
+      });
+    }
+  }
+};
+
+// src/federation/federated-inference.ts
+var MSG_INFERENCE_REQUEST = 1;
+var MSG_INFERENCE_RESPONSE = 2;
+var MSG_CAPABILITY_ANNOUNCE = 3;
+var MSG_CAPABILITY_REQUEST = 4;
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function encodeInferenceRequest(req) {
+  const json = JSON.stringify(req);
+  const jsonBytes = textEncoder.encode(json);
+  const frame = new Uint8Array(1 + jsonBytes.byteLength);
+  frame[0] = MSG_INFERENCE_REQUEST;
+  frame.set(jsonBytes, 1);
+  return frame;
+}
+function encodeInferenceResponse(text, metrics) {
+  const json = JSON.stringify({ text, ...metrics });
+  const jsonBytes = textEncoder.encode(json);
+  const frame = new Uint8Array(1 + jsonBytes.byteLength);
+  frame[0] = MSG_INFERENCE_RESPONSE;
+  frame.set(jsonBytes, 1);
+  return frame;
+}
+function encodeCapabilities(caps) {
+  const json = JSON.stringify(caps);
+  const jsonBytes = textEncoder.encode(json);
+  const frame = new Uint8Array(1 + jsonBytes.byteLength);
+  frame[0] = MSG_CAPABILITY_ANNOUNCE;
+  frame.set(jsonBytes, 1);
+  return frame;
+}
+var FederatedInferenceCoordinator = class {
+  peers = /* @__PURE__ */ new Map();
+  config;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.config = config ?? {};
+  }
+  // ─── Peer Management ────────────────────────────────────────────
+  /**
+   * Register a peer with its flow transport.
+   * The transport should already be connected.
+   */
+  addPeer(id, transport, capabilities) {
+    const peer = {
+      id,
+      transport,
+      capabilities: capabilities ?? { models: [], acceleration: "none" },
+      lastSeen: Date.now(),
+      available: true
+    };
+    this.peers.set(id, peer);
+    this.emit({ type: "peer-added", peerId: id });
+    if (!capabilities) {
+      const reqFrame = new Uint8Array([MSG_CAPABILITY_REQUEST]);
+      transport.send(reqFrame);
+    }
+    transport.onReceive((data) => {
+      if (data[0] === MSG_CAPABILITY_ANNOUNCE) {
+        const json = textDecoder.decode(data.subarray(1));
+        peer.capabilities = JSON.parse(json);
+        peer.lastSeen = Date.now();
+        this.emit({ type: "peer-capabilities", peerId: id, capabilities: peer.capabilities });
+      }
+    });
+  }
+  /**
+   * Remove a peer from the federation.
+   */
+  removePeer(id) {
+    const peer = this.peers.get(id);
+    if (peer) {
+      peer.available = false;
+      this.peers.delete(id);
+      this.emit({ type: "peer-removed", peerId: id });
+    }
+  }
+  /**
+   * Get all available peers, optionally filtered by model support.
+   */
+  getAvailablePeers(model) {
+    return Array.from(this.peers.values()).filter((peer) => {
+      if (!peer.available) return false;
+      if (model && !peer.capabilities.models.includes(model)) return false;
+      return true;
+    });
+  }
+  // ─── Federated Inference ──────────────────────────────────────────
+  /**
+   * 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.
+   */
+  async infer(request) {
+    const availablePeers = this.getAvailablePeers(request.model);
+    const minPeers = this.config.minPeers ?? 1;
+    const maxPeers = this.config.maxPeers ?? 8;
+    const timeout = this.config.timeout ?? 6e4;
+    const includeLocal = this.config.includeLocal ?? true;
+    const totalCandidates = availablePeers.length + (includeLocal ? 1 : 0);
+    if (totalCandidates < minPeers) {
+      throw new Error(
+        `Not enough peers for federated inference: ${totalCandidates} available, ${minPeers} required`
+      );
+    }
+    const selectedPeers = availablePeers.sort((a, b) => (b.capabilities.estimatedTps ?? 0) - (a.capabilities.estimatedTps ?? 0)).slice(0, maxPeers - (includeLocal ? 1 : 0));
+    const startTime = Date.now();
+    this.emit({ type: "inference-start", peerCount: selectedPeers.length + (includeLocal ? 1 : 0) });
+    const raceEntries = [];
+    for (const peer of selectedPeers) {
+      const requestFrame = encodeInferenceRequest(request);
+      const peerPromise = new Promise(
+        (resolve, reject) => {
+          const timer = setTimeout(() => {
+            reject(new Error(`Peer ${peer.id} timeout`));
+          }, timeout);
+          const handler = (data) => {
+            if (data[0] === MSG_INFERENCE_RESPONSE) {
+              clearTimeout(timer);
+              const json = textDecoder.decode(data.subarray(1));
+              const result = JSON.parse(json);
+              resolve(result);
+            }
+          };
+          peer.transport.onReceive(handler);
+          peer.transport.send(requestFrame);
+        }
+      );
+      raceEntries.push({ id: peer.id, promise: peerPromise });
+    }
+    if (includeLocal && this.config.localInference) {
+      const localStart = Date.now();
+      const localPromise = this.config.localInference(request.prompt).then((text) => {
+        const totalTime = Date.now() - localStart;
+        const tokens = text.split(/\s+/).length;
+        return {
+          text,
+          ttft: totalTime / 2,
+          // Rough estimate
+          totalTime,
+          tps: tokens / (totalTime / 1e3)
+        };
+      });
+      raceEntries.push({ id: "__local__", promise: localPromise });
+    }
+    if (request.collectAll) {
+      const allResults = /* @__PURE__ */ new Map();
+      let winner = null;
+      await Promise.allSettled(
+        raceEntries.map(async (entry) => {
+          const result = await entry.promise;
+          if (!winner) {
+            winner = { id: entry.id, result };
+          }
+          allResults.set(entry.id, { text: result.text, time: result.totalTime });
+          return { id: entry.id, result };
+        })
+      );
+      if (!winner) {
+        throw new Error("All peers failed inference");
+      }
+      const w = winner;
+      return {
+        winnerId: w.id,
+        text: w.result.text,
+        ttft: w.result.ttft,
+        totalTime: w.result.totalTime,
+        tokensPerSecond: w.result.tps,
+        allResults
+      };
+    } else {
+      const winner = await Promise.any(
+        raceEntries.map(async (entry) => {
+          const result = await entry.promise;
+          return { id: entry.id, result };
+        })
+      );
+      this.emit({
+        type: "inference-complete",
+        winnerId: winner.id,
+        totalTime: Date.now() - startTime
+      });
+      return {
+        winnerId: winner.id,
+        text: winner.result.text,
+        ttft: winner.result.ttft,
+        totalTime: winner.result.totalTime,
+        tokensPerSecond: winner.result.tps
+      };
+    }
+  }
+  // ─── Peer-Side: Handle Incoming Inference Requests ────────────────
+  /**
+   * 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) {
+    return (data) => {
+      if (data[0] !== MSG_INFERENCE_REQUEST) return;
+      const json = textDecoder.decode(data.subarray(1));
+      const request = JSON.parse(json);
+      const startTime = Date.now();
+      let ttft = 0;
+      void inferFn(request.prompt, {
+        maxTokens: request.maxTokens,
+        temperature: request.temperature
+      }).then((text) => {
+        if (ttft === 0) ttft = Date.now() - startTime;
+        const totalTime = Date.now() - startTime;
+        const tokens = text.split(/\s+/).length;
+        const tps = tokens / (totalTime / 1e3);
+        return encodeInferenceResponse(text, { ttft, totalTime, tps });
+      });
+    };
+  }
+  /**
+   * 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, inferFn, capabilities) {
+    transport.send(encodeCapabilities(capabilities));
+    transport.onReceive((data) => {
+      if (data[0] === MSG_CAPABILITY_REQUEST) {
+        transport.send(encodeCapabilities(capabilities));
+        return;
+      }
+      if (data[0] !== MSG_INFERENCE_REQUEST) return;
+      const json = textDecoder.decode(data.subarray(1));
+      const request = JSON.parse(json);
+      const startTime = Date.now();
+      void inferFn(request.prompt, {
+        maxTokens: request.maxTokens,
+        temperature: request.temperature
+      }).then((text) => {
+        const totalTime = Date.now() - startTime;
+        const tokens = text.split(/\s+/).length;
+        const tps = tokens / Math.max(totalTime / 1e3, 1e-3);
+        const response = encodeInferenceResponse(text, { ttft: totalTime / 2, totalTime, tps });
+        transport.send(response);
+      }).catch(() => {
+      });
+    });
+  }
+  // ─── Events ──────────────────────────────────────────────────────
+  on(handler) {
+    this.listeners.add(handler);
+  }
+  off(handler) {
+    this.listeners.delete(handler);
+  }
+  emit(event) {
+    for (const handler of this.listeners) {
+      handler(event);
+    }
+  }
+  // ─── Status ──────────────────────────────────────────────────────
+  get peerCount() {
+    return this.peers.size;
+  }
+  get availablePeerCount() {
+    return Array.from(this.peers.values()).filter((p) => p.available).length;
+  }
+  destroy() {
+    for (const peer of this.peers.values()) {
+      peer.transport.close();
+    }
+    this.peers.clear();
+    this.listeners.clear();
+  }
+};
+
+// src/index.ts
+var Link = (() => {
+  throw new Error(
+    "Link: Stub called from @affectively/aeon. Import from @affectively/aeon-flux-react or mock in tests."
+  );
+});
+var useAeonPage = (() => {
+  throw new Error(
+    "useAeonPage: Stub called from @affectively/aeon. Import from @affectively/aeon-flux-react or mock in tests."
+  );
+});
+
+exports.ACK_FLAG = ACK_FLAG;
 exports.AEON_CAPABILITIES = AEON_CAPABILITIES;
+exports.AEON_FLOW_RX_UUID = AEON_FLOW_RX_UUID;
+exports.AEON_FLOW_SERVICE_UUID = AEON_FLOW_SERVICE_UUID;
+exports.AEON_FLOW_TX_UUID = AEON_FLOW_TX_UUID;
+exports.AEON_USB_INTERFACE_CLASS = AEON_USB_INTERFACE_CLASS;
+exports.AEON_USB_PROTOCOL = AEON_USB_PROTOCOL;
+exports.AEON_USB_SUBCLASS = AEON_USB_SUBCLASS;
 exports.AdaptiveCompressionOptimizer = AdaptiveCompressionOptimizer;
+exports.AeonFlowProtocol = AeonFlowProtocol;
 exports.AgentPresenceManager = AgentPresenceManager;
 exports.BatchTimingOptimizer = BatchTimingOptimizer;
+exports.BluetoothFlowTransport = BluetoothFlowTransport;
+exports.COLLAPSE = COLLAPSE;
+exports.ChildProcessFlowTransport = ChildProcessFlowTransport;
 exports.CompressionEngine = CompressionEngine;
 exports.DEFAULT_CRYPTO_CONFIG = DEFAULT_CRYPTO_CONFIG;
+exports.DEFAULT_FLOW_CONFIG = DEFAULT_FLOW_CONFIG;
+exports.DashRelayFlowTransport = DashRelayFlowTransport;
 exports.DashStorageAdapter = DashStorageAdapter;
 exports.DataTransformer = DataTransformer;
 exports.DeltaSyncOptimizer = DeltaSyncOptimizer;
+exports.FIN = FIN;
+exports.FORK = FORK;
+exports.FRAGMENT_HEADER_SIZE = FRAGMENT_HEADER_SIZE;
+exports.FederatedInferenceCoordinator = FederatedInferenceCoordinator;
+exports.FlowCodec = FlowCodec;
+exports.FrameReassembler = FrameReassembler;
+exports.HEADER_SIZE = HEADER_SIZE;
+exports.HTTPAeonBridge = HTTPAeonBridge;
 exports.InMemoryStorageAdapter = InMemoryStorageAdapter;
+exports.Link = Link;
+exports.MAX_FRAGMENT_PAYLOAD = MAX_FRAGMENT_PAYLOAD;
+exports.MAX_PAYLOAD_LENGTH = MAX_PAYLOAD_LENGTH;
+exports.MessagePortFlowTransport = MessagePortFlowTransport;
 exports.MigrationEngine = MigrationEngine;
 exports.MigrationTracker = MigrationTracker;
 exports.NullCryptoProvider = NullCryptoProvider;
+exports.NullTransactionSigner = NullTransactionSigner;
 exports.OfflineOperationQueue = OfflineOperationQueue;
+exports.POISON = POISON;
 exports.PrefetchingEngine = PrefetchingEngine;
+exports.RACE = RACE;
 exports.ReplicationManager = ReplicationManager;
 exports.SchemaVersionManager = SchemaVersionManager;
 exports.StateReconciler = StateReconciler;
 exports.SyncCoordinator = SyncCoordinator;
 exports.SyncProtocol = SyncProtocol;
+exports.TCPFlowTransport = TCPFlowTransport;
+exports.UDPFlowTransport = UDPFlowTransport;
+exports.UDP_MTU = UDP_MTU;
+exports.USBFlowTransport = USBFlowTransport;
+exports.WebRTCFlowTransport = WebRTCFlowTransport;
+exports.WebTransportFlowTransport = WebTransportFlowTransport;
 exports.clearAgentPresenceManager = clearAgentPresenceManager;
+exports.connectTCPFlow = connectTCPFlow;
+exports.createDashRelayFlow = createDashRelayFlow;
+exports.createIPCPair = createIPCPair;
 exports.createNamespacedLogger = createNamespacedLogger;
+exports.createP2PFlow = createP2PFlow;
+exports.createTransactionSignerAdapter = createTransactionSignerAdapter;
+exports.decodeHTTPRequest = decodeHTTPRequest;
+exports.decodeHTTPResponse = decodeHTTPResponse;
 exports.disableLogging = disableLogging;
+exports.encodeHTTPRequest = encodeHTTPRequest;
+exports.encodeHTTPResponse = encodeHTTPResponse;
 exports.getAdaptiveCompressionOptimizer = getAdaptiveCompressionOptimizer;
 exports.getAgentPresenceManager = getAgentPresenceManager;
 exports.getBatchTimingOptimizer = getBatchTimingOptimizer;
@@ -5841,6 +8716,7 @@ exports.getDeltaSyncOptimizer = getDeltaSyncOptimizer;
 exports.getLogger = getLogger;
 exports.getOfflineOperationQueue = getOfflineOperationQueue;
 exports.getPrefetchingEngine = getPrefetchingEngine;
+exports.listenTCPFlow = listenTCPFlow;
 exports.logger = logger;
 exports.resetAdaptiveCompressionOptimizer = resetAdaptiveCompressionOptimizer;
 exports.resetBatchTimingOptimizer = resetBatchTimingOptimizer;
@@ -5850,5 +8726,6 @@ exports.resetLogger = resetLogger;
 exports.resetOfflineOperationQueue = resetOfflineOperationQueue;
 exports.resetPrefetchingEngine = resetPrefetchingEngine;
 exports.setLogger = setLogger;
+exports.useAeonPage = useAeonPage;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map