adaptive-bitmask 1.0.0-rc.1

package/dist/chunk-ZWEXRT33.mjs

@@ -0,0 +1,2402 @@
+// src/transports/websocket.ts
+import { WebSocketServer, WebSocket } from "ws";
+
+// src/message.ts
+var MESSAGE_SIZE_BYTES = 24;
+var UINT32_MAX = 4294967295;
+var UINT64_MAX = (1n << 64n) - 1n;
+var BitmaskMessage = class _BitmaskMessage {
+  mask;
+  agentId;
+  timestampMs;
+  schemaVersion;
+  constructor(data) {
+    this._assertValid(data);
+    this.mask = data.mask;
+    this.agentId = data.agentId;
+    this.timestampMs = data.timestampMs;
+    this.schemaVersion = data.schemaVersion;
+  }
+  /** Create a message with current timestamp. */
+  static now(mask, agentId, schemaVersion) {
+    return new _BitmaskMessage({
+      mask,
+      agentId,
+      timestampMs: Date.now(),
+      schemaVersion
+    });
+  }
+  /** Wire size in bytes. */
+  get sizeBytes() {
+    return MESSAGE_SIZE_BYTES;
+  }
+  /**
+   * Serialize to 24-byte ArrayBuffer (little-endian).
+   *
+   * This is the canonical wire format. gRPC/WebSocket transports
+   * should send these bytes directly.
+   */
+  serialize() {
+    const buf = new ArrayBuffer(MESSAGE_SIZE_BYTES);
+    const view = new DataView(buf);
+    view.setBigUint64(0, this.mask, true);
+    view.setUint32(8, this.agentId, true);
+    view.setBigInt64(12, BigInt(this.timestampMs), true);
+    view.setUint32(20, this.schemaVersion, true);
+    return buf;
+  }
+  /** Serialize to Uint8Array. */
+  toBytes() {
+    return new Uint8Array(this.serialize());
+  }
+  /**
+   * Deserialize from ArrayBuffer or Uint8Array.
+   * Validates length before parsing.
+   */
+  static deserialize(data) {
+    const buf = data instanceof Uint8Array ? data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) : data;
+    if (buf.byteLength !== MESSAGE_SIZE_BYTES) {
+      throw new Error(
+        `Invalid message: expected exactly ${MESSAGE_SIZE_BYTES} bytes, got ${buf.byteLength}`
+      );
+    }
+    const view = new DataView(buf);
+    return new _BitmaskMessage({
+      mask: view.getBigUint64(0, true),
+      agentId: view.getUint32(8, true),
+      timestampMs: Number(view.getBigInt64(12, true)),
+      schemaVersion: view.getUint32(20, true)
+    });
+  }
+  /**
+   * JSON-equivalent size for comparison.
+   * Useful for demonstrating compression ratio.
+   */
+  get jsonSize() {
+    return JSON.stringify({
+      mask: this.mask.toString(),
+      agentId: this.agentId,
+      timestampMs: this.timestampMs,
+      schemaVersion: this.schemaVersion
+    }).length;
+  }
+  /** Compression ratio vs JSON encoding. */
+  get compressionVsJson() {
+    return this.jsonSize / MESSAGE_SIZE_BYTES;
+  }
+  /** Human-readable string for debugging. */
+  toString() {
+    return `BitmaskMessage(agent=${this.agentId}, v=${this.schemaVersion}, bits=${this.mask.toString(2).padStart(64, "0")}, t=${this.timestampMs})`;
+  }
+  _assertValid(data) {
+    if (typeof data.mask !== "bigint") {
+      throw new TypeError(`mask must be bigint, got ${typeof data.mask}`);
+    }
+    if (data.mask < 0n || data.mask > UINT64_MAX) {
+      throw new RangeError(`mask out of uint64 range: ${data.mask.toString()}`);
+    }
+    this._assertUint32("agentId", data.agentId);
+    this._assertUint32("schemaVersion", data.schemaVersion);
+    if (!Number.isSafeInteger(data.timestampMs)) {
+      throw new RangeError(
+        `timestampMs must be a safe integer, got ${data.timestampMs}`
+      );
+    }
+  }
+  _assertUint32(field, value) {
+    if (!Number.isInteger(value) || value < 0 || value > UINT32_MAX) {
+      throw new RangeError(
+        `${field} must be an integer in [0, ${UINT32_MAX}], got ${value}`
+      );
+    }
+  }
+};
+
+// src/errors.ts
+var AdaptiveBitmaskError = class _AdaptiveBitmaskError extends Error {
+  code;
+  category;
+  context;
+  timestamp;
+  constructor(message, code, category, context) {
+    super(message);
+    this.name = "AdaptiveBitmaskError";
+    this.code = code;
+    this.category = category;
+    this.context = context;
+    this.timestamp = Date.now();
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, _AdaptiveBitmaskError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      category: this.category,
+      context: this.context,
+      timestamp: this.timestamp,
+      stack: this.stack
+    };
+  }
+};
+var ValidationError = class extends AdaptiveBitmaskError {
+  constructor(message, context) {
+    super(message, "VALIDATION_ERROR", "VALIDATION", context);
+    this.name = "ValidationError";
+  }
+};
+var SchemaValidationError = class extends ValidationError {
+  constructor(message, schemaVersion, feature) {
+    super(message, { schemaVersion, feature });
+    this.name = "SchemaValidationError";
+  }
+};
+var MessageValidationError = class extends ValidationError {
+  constructor(message, agentId, messageSize) {
+    super(message, { agentId, messageSize });
+    this.name = "MessageValidationError";
+  }
+};
+var RuntimeError = class extends AdaptiveBitmaskError {
+  constructor(message, context) {
+    super(message, "RUNTIME_ERROR", "RUNTIME", context);
+    this.name = "RuntimeError";
+  }
+};
+var CoordinatorError = class extends RuntimeError {
+  constructor(message, agentCount, deadlineMs) {
+    super(message, { agentCount, deadlineMs });
+    this.name = "CoordinatorError";
+  }
+};
+var ArbiterError = class extends RuntimeError {
+  constructor(message, score, decision) {
+    super(message, { score, decision });
+    this.name = "ArbiterError";
+  }
+};
+var NetworkError = class extends AdaptiveBitmaskError {
+  constructor(message, context) {
+    super(message, "NETWORK_ERROR", "NETWORK", context);
+    this.name = "NetworkError";
+  }
+};
+var TimeoutError = class extends NetworkError {
+  constructor(message, timeoutMs, operation) {
+    super(message, { timeoutMs, operation });
+    this.name = "TimeoutError";
+  }
+};
+var SystemError = class extends AdaptiveBitmaskError {
+  constructor(message, context) {
+    super(message, "SYSTEM_ERROR", "SYSTEM", context);
+    this.name = "SystemError";
+  }
+};
+var MemoryError = class extends SystemError {
+  constructor(message, memoryUsage, limit) {
+    super(message, { memoryUsage, limit });
+    this.name = "MemoryError";
+  }
+};
+var Validator = class {
+  static validateAgentId(agentId) {
+    if (!Number.isInteger(agentId) || agentId < 0 || agentId > 4294967295) {
+      throw new MessageValidationError(
+        `Invalid agent ID: ${agentId}. Must be a non-negative integer <= 4294967295`,
+        agentId
+      );
+    }
+  }
+  static validateFeatureName(feature) {
+    if (typeof feature !== "string" || feature.length === 0) {
+      throw new ValidationError(
+        `Invalid feature name: must be a non-empty string`,
+        { feature }
+      );
+    }
+    if (feature.length > 100) {
+      throw new ValidationError(
+        `Feature name too long: ${feature.length} chars. Max: 100`,
+        { feature, length: feature.length }
+      );
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(feature)) {
+      throw new ValidationError(
+        `Invalid feature name format: ${feature}. Only alphanumeric, underscore, and hyphen allowed`,
+        { feature }
+      );
+    }
+  }
+  static validateFeatureArray(features) {
+    if (!Array.isArray(features)) {
+      throw new ValidationError(
+        `Features must be an array`,
+        { type: typeof features }
+      );
+    }
+    if (features.length > 64) {
+      throw new ValidationError(
+        `Too many features: ${features.length}. Max: 64`,
+        { count: features.length }
+      );
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const feature of features) {
+      this.validateFeatureName(feature);
+      if (seen.has(feature)) {
+        throw new ValidationError(
+          `Duplicate feature: ${feature}`,
+          { feature }
+        );
+      }
+      seen.add(feature);
+    }
+  }
+  static validateSchemaVersion(version) {
+    if (!Number.isInteger(version) || version < 0 || version > 4294967295) {
+      throw new SchemaValidationError(
+        `Invalid schema version: ${version}. Must be a non-negative integer <= 4294967295`,
+        version
+      );
+    }
+  }
+  static validateDeadlineMs(deadlineMs) {
+    if (!Number.isInteger(deadlineMs) || deadlineMs < 0 || deadlineMs > 6e4) {
+      throw new ValidationError(
+        `Invalid deadline: ${deadlineMs}ms. Must be 0-60000ms`,
+        { deadlineMs }
+      );
+    }
+  }
+  static validateTimeout(timeoutMs, operation) {
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 3e5) {
+      throw new ValidationError(
+        `Invalid timeout for ${operation}: ${timeoutMs}ms. Must be 0-300000ms`,
+        { operation, timeoutMs }
+      );
+    }
+  }
+};
+var CircuitBreaker = class {
+  constructor(failureThreshold = 5, recoveryTimeoutMs = 6e4, monitoringPeriodMs = 1e4) {
+    this.failureThreshold = failureThreshold;
+    this.recoveryTimeoutMs = recoveryTimeoutMs;
+    this.monitoringPeriodMs = monitoringPeriodMs;
+  }
+  failures = 0;
+  lastFailureTime = 0;
+  state = "CLOSED";
+  async execute(operation, operationName) {
+    if (this.state === "OPEN") {
+      if (Date.now() - this.lastFailureTime > this.recoveryTimeoutMs) {
+        this.state = "HALF_OPEN";
+      } else {
+        throw new RuntimeError(
+          `Circuit breaker OPEN for ${operationName}. Too many failures.`,
+          {
+            failures: this.failures,
+            state: this.state,
+            nextRetry: this.lastFailureTime + this.recoveryTimeoutMs
+          }
+        );
+      }
+    }
+    try {
+      const result = await operation();
+      if (this.state === "HALF_OPEN") {
+        this.reset();
+      }
+      return result;
+    } catch (error) {
+      this.recordFailure();
+      if (this.failures >= this.failureThreshold) {
+        this.state = "OPEN";
+        this.lastFailureTime = Date.now();
+      }
+      throw error;
+    }
+  }
+  recordFailure() {
+    this.failures++;
+    this.lastFailureTime = Date.now();
+  }
+  reset() {
+    this.failures = 0;
+    this.state = "CLOSED";
+  }
+  getStatus() {
+    return {
+      state: this.state,
+      failures: this.failures,
+      lastFailureTime: this.lastFailureTime,
+      isHealthy: this.state !== "OPEN"
+    };
+  }
+};
+var TimeoutManager = class {
+  static async withTimeout(promise, timeoutMs, operation) {
+    Validator.validateTimeout(timeoutMs, operation);
+    const timeoutPromise = new Promise((_, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new TimeoutError(
+          `Operation timed out: ${operation}`,
+          timeoutMs,
+          operation
+        ));
+      }, timeoutMs);
+      promise.finally(() => clearTimeout(timeoutId));
+    });
+    return Promise.race([promise, timeoutPromise]);
+  }
+};
+var RecoveryManager = class {
+  static async withRetry(operation, maxRetries = 3, baseDelayMs = 1e3, operationName = "operation") {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (attempt === maxRetries) {
+          throw new RuntimeError(
+            `Operation failed after ${maxRetries + 1} attempts: ${operationName}`,
+            {
+              attempts: attempt + 1,
+              maxRetries: maxRetries + 1,
+              lastError: lastError.message
+            }
+          );
+        }
+        const delay = baseDelayMs * Math.pow(2, attempt) + Math.random() * 1e3;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw lastError;
+  }
+};
+
+// src/transports/websocket.ts
+var WebSocketTransport = class {
+  server;
+  agents = /* @__PURE__ */ new Map();
+  nextAgentId = 1;
+  logger = Logger.getInstance();
+  metrics;
+  circuitBreaker;
+  config;
+  isShuttingDown = false;
+  constructor(config) {
+    this.config = {
+      maxConnections: 1e3,
+      connectionTimeoutMs: 3e4,
+      messageTimeoutMs: 5e3,
+      enableCompression: true,
+      circuitBreakerThreshold: 10,
+      healthCheckIntervalMs: 3e4,
+      ...config
+    };
+    this.metrics = new MetricsCollector();
+    this.circuitBreaker = new CircuitBreaker(this.config.circuitBreakerThreshold);
+    this.server = new WebSocketServer({
+      port: this.config.port,
+      perMessageDeflate: this.config.enableCompression
+    });
+    this.setupEventHandlers();
+    this.startHealthChecks();
+    this.logger.info("WebSocketTransport", `Server started on port ${this.config.port}`);
+  }
+  setupEventHandlers() {
+    this.server.on("connection", (socket, req) => {
+      this.handleConnection(socket, req);
+    });
+    this.server.on("error", (error) => {
+      this.logger.error("WebSocketTransport", "Server error", error);
+      this.metrics.recordError("WebSocketServerError");
+    });
+    this.server.on("listening", () => {
+      this.logger.info("WebSocketTransport", `Server listening on port ${this.config.port}`);
+    });
+  }
+  handleConnection(socket, req) {
+    if (this.isShuttingDown) {
+      socket.close(1013, "Server shutting down");
+      return;
+    }
+    if (this.agents.size >= this.config.maxConnections) {
+      socket.close(1013, "Server at capacity");
+      this.logger.warn("WebSocketTransport", "Connection rejected: server at capacity");
+      return;
+    }
+    const agentId = this.nextAgentId++;
+    const agent = {
+      id: agentId,
+      socket,
+      lastSeen: Date.now(),
+      messagesReceived: 0,
+      messagesSent: 0,
+      schemaVersion: 0
+    };
+    this.agents.set(agentId, agent);
+    this.metrics.setAgentsConnected(this.agents.size);
+    this.logger.info("WebSocketTransport", `Agent connected: ${agentId}`, {
+      remoteAddress: req.socket?.remoteAddress,
+      totalAgents: this.agents.size
+    });
+    socket.on("message", (data) => {
+      this.handleMessage(agentId, data);
+    });
+    socket.on("close", (code, reason) => {
+      this.handleDisconnection(agentId, code, reason.toString());
+    });
+    socket.on("error", (error) => {
+      this.logger.error("WebSocketTransport", `Socket error for agent ${agentId}`, error);
+      this.metrics.recordError("SocketError");
+    });
+    socket.on("pong", () => {
+      agent.lastSeen = Date.now();
+    });
+    this.sendMessage(agentId, {
+      type: "HEARTBEAT",
+      payload: { agentId, timestamp: Date.now() },
+      timestamp: Date.now()
+    });
+    this.startHeartbeat(agentId);
+  }
+  async handleMessage(agentId, data) {
+    const agent = this.agents.get(agentId);
+    if (!agent) return;
+    try {
+      await TimeoutManager.withTimeout(
+        this.processMessage(agentId, data),
+        this.config.messageTimeoutMs,
+        `process message from agent ${agentId}`
+      );
+    } catch (error) {
+      if (error instanceof TimeoutError) {
+        this.logger.warn("WebSocketTransport", `Message timeout for agent ${agentId}`);
+        this.metrics.recordTimeout();
+      } else {
+        this.logger.error("WebSocketTransport", `Message processing error for agent ${agentId}`, error);
+        this.metrics.recordError("MessageProcessingError");
+      }
+    }
+  }
+  async processMessage(agentId, data) {
+    const startTime = performance.now();
+    const agent = this.agents.get(agentId);
+    if (!agent) return;
+    try {
+      const message = this.parseMessage(data);
+      if (message.type === "BITMASK_MESSAGE") {
+        const bitmaskMsg = BitmaskMessage.deserialize(message.payload);
+        agent.schemaVersion = bitmaskMsg.schemaVersion;
+        agent.messagesReceived++;
+        agent.lastSeen = Date.now();
+        this.metrics.incrementMessagesProcessed();
+        const processingTime = (performance.now() - startTime) * 1e3;
+        this.metrics.recordMessageProcessingTime(processingTime);
+        this.logger.debug("WebSocketTransport", `Received bitmask from agent ${agentId}`, {
+          messageSize: data.length,
+          processingTimeUs: processingTime,
+          schemaVersion: bitmaskMsg.schemaVersion
+        });
+        this.emit("message", { agentId, message: bitmaskMsg });
+      } else if (message.type === "HEARTBEAT") {
+        agent.lastSeen = Date.now();
+        this.logger.debug("WebSocketTransport", `Heartbeat from agent ${agentId}`);
+      }
+    } catch (error) {
+      this.logger.error("WebSocketTransport", `Invalid message from agent ${agentId}`, error);
+      this.sendMessage(agentId, {
+        type: "ERROR",
+        payload: { error: "Invalid message format" },
+        timestamp: Date.now()
+      });
+      throw error;
+    }
+  }
+  parseMessage(data) {
+    try {
+      const typeByte = data.readUInt8(0);
+      const type = ["BITMASK_MESSAGE", "HEARTBEAT", "ERROR", "SCHEMA_UPDATE"][typeByte];
+      if (!type) {
+        throw new Error(`Unknown message type: ${typeByte}`);
+      }
+      const payload = data.subarray(1);
+      return {
+        type,
+        payload: type === "BITMASK_MESSAGE" ? payload : JSON.parse(payload.toString()),
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      throw new AdaptiveBitmaskError("Failed to parse message", "PARSE_ERROR", "RUNTIME");
+    }
+  }
+  sendMessage(agentId, message) {
+    const agent = this.agents.get(agentId);
+    if (!agent || agent.socket.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    try {
+      let payload;
+      if (message.type === "BITMASK_MESSAGE") {
+        const typeByte = Buffer.from([0]);
+        payload = Buffer.concat([typeByte, Buffer.from(message.payload)]);
+      } else {
+        const typeByte = Buffer.from([["BITMASK_MESSAGE", "HEARTBEAT", "ERROR", "SCHEMA_UPDATE"].indexOf(message.type)]);
+        const jsonPayload = Buffer.from(JSON.stringify(message.payload));
+        payload = Buffer.concat([typeByte, jsonPayload]);
+      }
+      agent.socket.send(payload);
+      agent.messagesSent++;
+      agent.lastSeen = Date.now();
+      this.logger.debug("WebSocketTransport", `Sent message to agent ${agentId}`, {
+        type: message.type,
+        size: payload.length
+      });
+    } catch (error) {
+      this.logger.error("WebSocketTransport", `Failed to send message to agent ${agentId}`, error);
+      this.metrics.recordError("SendMessageError");
+    }
+  }
+  handleDisconnection(agentId, code, reason) {
+    const agent = this.agents.get(agentId);
+    if (!agent) return;
+    this.agents.delete(agentId);
+    this.metrics.setAgentsConnected(this.agents.size);
+    this.logger.info("WebSocketTransport", `Agent disconnected: ${agentId}`, {
+      code,
+      reason,
+      duration: Date.now() - agent.lastSeen,
+      messagesExchanged: agent.messagesReceived + agent.messagesSent
+    });
+    this.emit("disconnection", { agentId, code, reason });
+  }
+  startHeartbeat(agentId) {
+    const interval = setInterval(() => {
+      const agent = this.agents.get(agentId);
+      if (!agent) {
+        clearInterval(interval);
+        return;
+      }
+      if (agent.socket.readyState !== WebSocket.OPEN) {
+        clearInterval(interval);
+        return;
+      }
+      if (Date.now() - agent.lastSeen > this.config.connectionTimeoutMs) {
+        this.logger.warn("WebSocketTransport", `Agent ${agentId} connection stale, closing`);
+        agent.socket.terminate();
+        clearInterval(interval);
+        return;
+      }
+      try {
+        agent.socket.ping();
+      } catch (error) {
+        this.logger.error("WebSocketTransport", `Failed to ping agent ${agentId}`, error);
+        clearInterval(interval);
+      }
+    }, this.config.healthCheckIntervalMs);
+  }
+  startHealthChecks() {
+    setInterval(() => {
+      const now = Date.now();
+      const staleAgents = [];
+      for (const [agentId, agent] of this.agents) {
+        if (now - agent.lastSeen > this.config.connectionTimeoutMs) {
+          staleAgents.push(agentId);
+        }
+      }
+      for (const agentId of staleAgents) {
+        const agent = this.agents.get(agentId);
+        if (agent) {
+          this.logger.warn("WebSocketTransport", `Cleaning up stale agent ${agentId}`);
+          agent.socket.terminate();
+        }
+      }
+      this.metrics.updateMemoryUsage();
+    }, this.config.healthCheckIntervalMs);
+  }
+  // Public API methods
+  broadcast(message) {
+    for (const agentId of this.agents.keys()) {
+      this.sendMessage(agentId, message);
+    }
+  }
+  sendToAgent(agentId, message) {
+    this.sendMessage(agentId, message);
+  }
+  getConnectedAgents() {
+    return Array.from(this.agents.values());
+  }
+  getAgentCount() {
+    return this.agents.size;
+  }
+  getMetrics() {
+    return this.metrics;
+  }
+  async shutdown() {
+    this.isShuttingDown = true;
+    this.logger.info("WebSocketTransport", "Shutting down server...");
+    const closePromises = Array.from(this.agents.values()).map((agent) => {
+      return new Promise((resolve) => {
+        if (agent.socket.readyState === WebSocket.OPEN) {
+          agent.socket.close(1013, "Server shutting down");
+          agent.socket.on("close", () => resolve());
+        } else {
+          resolve();
+        }
+      });
+    });
+    await Promise.all(closePromises);
+    return new Promise((resolve) => {
+      this.server.close(() => {
+        this.logger.info("WebSocketTransport", "Server shutdown complete");
+        resolve();
+      });
+    });
+  }
+  // Event emitter functionality (simple implementation)
+  listeners = /* @__PURE__ */ new Map();
+  emit(event, data) {
+    const eventListeners = this.listeners.get(event) || [];
+    for (const listener of eventListeners) {
+      try {
+        listener(data);
+      } catch (error) {
+        this.logger.error("WebSocketTransport", `Event listener error for ${event}`, error);
+      }
+    }
+  }
+  on(event, listener) {
+    const eventListeners = this.listeners.get(event) || [];
+    eventListeners.push(listener);
+    this.listeners.set(event, eventListeners);
+  }
+  off(event, listener) {
+    const eventListeners = this.listeners.get(event) || [];
+    const index = eventListeners.indexOf(listener);
+    if (index > -1) {
+      eventListeners.splice(index, 1);
+    }
+  }
+};
+function createWebSocketTransport(config) {
+  return new WebSocketTransport(config);
+}
+
+// src/transports/http.ts
+import { createServer } from "http";
+var HttpTransport = class {
+  server;
+  logger = Logger.getInstance();
+  metrics;
+  circuitBreaker;
+  config;
+  requestCounts = /* @__PURE__ */ new Map();
+  isShuttingDown = false;
+  constructor(config) {
+    this.config = {
+      requestTimeoutMs: 1e4,
+      maxBodySize: 1024 * 1024,
+      // 1MB
+      enableCors: true,
+      circuitBreakerThreshold: 20,
+      rateLimitPerMinute: 1e3,
+      ...config
+    };
+    this.metrics = new MetricsCollector();
+    this.circuitBreaker = new CircuitBreaker(this.config.circuitBreakerThreshold);
+    this.server = createServer((req, res) => {
+      this.handleRequest(req, res);
+    });
+    this.startRateLimitCleanup();
+    this.logger.info("HttpTransport", `Server started on port ${this.config.port}`);
+  }
+  async handleRequest(req, res) {
+    if (this.isShuttingDown) {
+      this.sendResponse(res, 503, JSON.stringify({ error: "Server shutting down" }));
+      return;
+    }
+    const clientIP = req.socket.remoteAddress || "unknown";
+    const url = req.url || "/";
+    if (this.isRateLimited(clientIP)) {
+      this.sendResponse(res, 429, JSON.stringify({ error: "Rate limit exceeded" }));
+      this.logger.warn("HttpTransport", `Rate limit exceeded for ${clientIP}`);
+      return;
+    }
+    if (this.config.enableCors) {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    }
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    try {
+      await TimeoutManager.withTimeout(
+        this.processRequest(req, res),
+        this.config.requestTimeoutMs,
+        `HTTP request from ${clientIP}`
+      );
+    } catch (error) {
+      if (error instanceof TimeoutError) {
+        this.sendResponse(res, 408, JSON.stringify({ error: "Request timeout" }));
+        this.metrics.recordTimeout();
+      } else {
+        this.logger.error("HttpTransport", "Request processing error", error);
+        this.sendResponse(res, 500, JSON.stringify({ error: "Internal server error" }));
+        this.metrics.recordError("HttpRequestError");
+      }
+    }
+  }
+  async processRequest(req, res) {
+    const startTime = performance.now();
+    const method = req.method || "GET";
+    const url = req.url || "/";
+    let body;
+    if (method === "POST" || method === "PUT") {
+      body = await this.parseRequestBody(req);
+    }
+    const request = {
+      method,
+      url,
+      headers: req.headers,
+      body,
+      timestamp: Date.now()
+    };
+    this.logger.debug("HttpTransport", `Incoming ${method} ${url}`, {
+      contentLength: body?.length,
+      userAgent: request.headers["user-agent"]
+    });
+    let response;
+    try {
+      response = await this.routeRequest(request);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        response = {
+          statusCode: 400,
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ error: error.message, code: error.code }),
+          timestamp: Date.now()
+        };
+      } else if (error instanceof AdaptiveBitmaskError) {
+        response = {
+          statusCode: 500,
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ error: error.message, code: error.code }),
+          timestamp: Date.now()
+        };
+      } else {
+        throw error;
+      }
+    }
+    this.sendResponse(res, response.statusCode, response.body, response.headers);
+    const processingTime = (performance.now() - startTime) * 1e3;
+    this.metrics.recordMessageProcessingTime(processingTime);
+    this.metrics.incrementMessagesProcessed();
+    this.logger.debug("HttpTransport", `Response sent`, {
+      statusCode: response.statusCode,
+      processingTimeUs: processingTime
+    });
+  }
+  async parseRequestBody(req) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      let totalSize = 0;
+      req.on("data", (chunk) => {
+        totalSize += chunk.length;
+        if (totalSize > this.config.maxBodySize) {
+          reject(new ValidationError(`Request body too large: ${totalSize} bytes`));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      req.on("end", () => {
+        resolve(Buffer.concat(chunks));
+      });
+      req.on("error", reject);
+    });
+  }
+  async routeRequest(request) {
+    const { method, url, body } = request;
+    if (url === "/api/coordinate" && method === "POST") {
+      return await this.handleCoordinate(body);
+    }
+    if (url === "/api/health" && method === "GET") {
+      return await this.handleHealth();
+    }
+    if (url === "/api/metrics" && method === "GET") {
+      return await this.handleMetrics();
+    }
+    if (url === "/api/schema" && method === "GET") {
+      return await this.handleGetSchema();
+    }
+    if (url === "/api/schema" && method === "POST") {
+      return await this.handleUpdateSchema(body);
+    }
+    return {
+      statusCode: 404,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ error: "Not found" }),
+      timestamp: Date.now()
+    };
+  }
+  async handleCoordinate(body) {
+    if (!body) {
+      throw new ValidationError("Missing request body");
+    }
+    try {
+      const bitmaskMsg = BitmaskMessage.deserialize(body);
+      this.logger.info("HttpTransport", "Received bitmask message", {
+        agentId: bitmaskMsg.agentId,
+        schemaVersion: bitmaskMsg.schemaVersion,
+        messageSize: body.length
+      });
+      this.emit("message", { message: bitmaskMsg });
+      return {
+        statusCode: 200,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          success: true,
+          received: true,
+          timestamp: Date.now()
+        }),
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      throw new ValidationError("Invalid bitmask message format");
+    }
+  }
+  async handleHealth() {
+    const metrics = this.metrics.getMetrics();
+    const latencyStats = this.metrics.getLatencyStats();
+    const health = {
+      status: "HEALTHY",
+      uptime: metrics.uptimeMs,
+      timestamp: Date.now(),
+      version: "0.2.0-rc.0",
+      metrics: {
+        messagesProcessed: metrics.messagesProcessed,
+        memoryUsageMB: metrics.memoryUsageMB,
+        avgLatencyUs: latencyStats.mean
+      }
+    };
+    return {
+      statusCode: 200,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(health),
+      timestamp: Date.now()
+    };
+  }
+  async handleMetrics() {
+    const metrics = this.metrics.getMetrics();
+    const latencyStats = this.metrics.getLatencyStats();
+    return {
+      statusCode: 200,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ...metrics,
+        latencyStats
+      }),
+      timestamp: Date.now()
+    };
+  }
+  async handleGetSchema() {
+    return {
+      statusCode: 200,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        version: 1,
+        features: [],
+        timestamp: Date.now()
+      }),
+      timestamp: Date.now()
+    };
+  }
+  async handleUpdateSchema(body) {
+    return {
+      statusCode: 501,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ error: "Schema updates not implemented yet" }),
+      timestamp: Date.now()
+    };
+  }
+  sendResponse(res, statusCode, body, headers) {
+    if (headers) {
+      Object.entries(headers).forEach(([key, value]) => {
+        res.setHeader(key, value);
+      });
+    }
+    if (body && !res.getHeader("Content-Type")) {
+      res.setHeader("Content-Type", "application/json");
+    }
+    res.writeHead(statusCode);
+    res.end(body);
+  }
+  isRateLimited(clientIP) {
+    const now = Date.now();
+    const oneMinuteAgo = now - 6e4;
+    let requests = this.requestCounts.get(clientIP) || [];
+    requests = requests.filter((timestamp) => timestamp > oneMinuteAgo);
+    requests.push(now);
+    this.requestCounts.set(clientIP, requests);
+    return requests.length > this.config.rateLimitPerMinute;
+  }
+  startRateLimitCleanup() {
+    setInterval(() => {
+      const now = Date.now();
+      const oneMinuteAgo = now - 6e4;
+      for (const [ip, requests] of this.requestCounts) {
+        const filtered = requests.filter((timestamp) => timestamp > oneMinuteAgo);
+        if (filtered.length === 0) {
+          this.requestCounts.delete(ip);
+        } else {
+          this.requestCounts.set(ip, filtered);
+        }
+      }
+    }, 6e4);
+  }
+  // Public API methods
+  start() {
+    this.server.listen(this.config.port);
+  }
+  async shutdown() {
+    this.isShuttingDown = true;
+    this.logger.info("HttpTransport", "Shutting down server...");
+    return new Promise((resolve) => {
+      this.server.close(() => {
+        this.logger.info("HttpTransport", "Server shutdown complete");
+        resolve();
+      });
+    });
+  }
+  getMetrics() {
+    return this.metrics;
+  }
+  // Event emitter functionality (simple implementation)
+  listeners = /* @__PURE__ */ new Map();
+  emit(event, data) {
+    const eventListeners = this.listeners.get(event) || [];
+    for (const listener of eventListeners) {
+      try {
+        listener(data);
+      } catch (error) {
+        this.logger.error("HttpTransport", `Event listener error for ${event}`, error);
+      }
+    }
+  }
+  on(event, listener) {
+    const eventListeners = this.listeners.get(event) || [];
+    eventListeners.push(listener);
+    this.listeners.set(event, eventListeners);
+  }
+  off(event, listener) {
+    const eventListeners = this.listeners.get(event) || [];
+    const index = eventListeners.indexOf(listener);
+    if (index > -1) {
+      eventListeners.splice(index, 1);
+    }
+  }
+};
+function createHttpTransport(config) {
+  const transport = new HttpTransport(config);
+  transport.start();
+  return transport;
+}
+
+// src/telemetry.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["FATAL"] = 4] = "FATAL";
+  return LogLevel2;
+})(LogLevel || {});
+var Logger = class _Logger {
+  static instance;
+  logLevel = 1 /* INFO */;
+  logs = [];
+  maxLogSize = 1e4;
+  onLog;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_Logger.instance) {
+      _Logger.instance = new _Logger();
+    }
+    return _Logger.instance;
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  setLogCallback(callback) {
+    this.onLog = callback;
+  }
+  shouldLog(level) {
+    return level >= this.logLevel;
+  }
+  createLogEntry(level, component, message, metadata, error) {
+    const entry = {
+      timestamp: Date.now(),
+      level,
+      component,
+      message,
+      metadata
+    };
+    if (error) {
+      entry.error = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+        code: error.code
+      };
+    }
+    return entry;
+  }
+  addLog(entry) {
+    this.logs.push(entry);
+    if (this.logs.length > this.maxLogSize) {
+      this.logs = this.logs.slice(-this.maxLogSize);
+    }
+    if (this.onLog) {
+      this.onLog(entry);
+    }
+    if (this.shouldLog(entry.level)) {
+      const levelName = LogLevel[entry.level];
+      const message = `[${new Date(entry.timestamp).toISOString()}] ${levelName} [${entry.component}] ${entry.message}`;
+      switch (entry.level) {
+        case 0 /* DEBUG */:
+          console.debug(message, entry.metadata || "");
+          break;
+        case 1 /* INFO */:
+          console.info(message, entry.metadata || "");
+          break;
+        case 2 /* WARN */:
+          console.warn(message, entry.metadata || "");
+          break;
+        case 3 /* ERROR */:
+        case 4 /* FATAL */:
+          console.error(message, entry.error || entry.metadata || "");
+          break;
+      }
+    }
+  }
+  debug(component, message, metadata) {
+    const entry = this.createLogEntry(0 /* DEBUG */, component, message, metadata);
+    this.addLog(entry);
+  }
+  info(component, message, metadata) {
+    const entry = this.createLogEntry(1 /* INFO */, component, message, metadata);
+    this.addLog(entry);
+  }
+  warn(component, message, metadata) {
+    const entry = this.createLogEntry(2 /* WARN */, component, message, metadata);
+    this.addLog(entry);
+  }
+  error(component, message, error, metadata) {
+    const entry = this.createLogEntry(3 /* ERROR */, component, message, metadata, error);
+    this.addLog(entry);
+  }
+  fatal(component, message, error, metadata) {
+    const entry = this.createLogEntry(4 /* FATAL */, component, message, metadata, error);
+    this.addLog(entry);
+  }
+  getRecentLogs(count = 100) {
+    return this.logs.slice(-count);
+  }
+  getLogsByLevel(level) {
+    return this.logs.filter((log) => log.level === level);
+  }
+  clearLogs() {
+    this.logs = [];
+  }
+};
+var MetricsCollector = class {
+  metrics;
+  startTime;
+  logger = Logger.getInstance();
+  constructor() {
+    this.startTime = Date.now();
+    this.metrics = this.initializeMetrics();
+  }
+  initializeMetrics() {
+    return {
+      coordinationLatencyUs: [],
+      messageProcessingTimeUs: [],
+      encodingTimeUs: [],
+      decodingTimeUs: [],
+      messagesProcessed: 0,
+      agentsConnected: 0,
+      featuresActive: 0,
+      schemaVersion: 0,
+      errorsByType: {},
+      timeouts: 0,
+      circuitBreakerTrips: 0,
+      memoryUsageMB: 0,
+      bufferUtilization: 0,
+      lastReset: Date.now(),
+      uptimeMs: 0
+    };
+  }
+  recordCoordinationLatency(latencyUs) {
+    this.metrics.coordinationLatencyUs.push(latencyUs);
+    this.logger.debug("Metrics", "Coordination latency recorded", { latencyUs });
+  }
+  recordMessageProcessingTime(timeUs) {
+    this.metrics.messageProcessingTimeUs.push(timeUs);
+  }
+  recordEncodingTime(timeUs) {
+    this.metrics.encodingTimeUs.push(timeUs);
+  }
+  recordDecodingTime(timeUs) {
+    this.metrics.decodingTimeUs.push(timeUs);
+  }
+  incrementMessagesProcessed() {
+    this.metrics.messagesProcessed++;
+  }
+  setAgentsConnected(count) {
+    this.metrics.agentsConnected = count;
+  }
+  setFeaturesActive(count) {
+    this.metrics.featuresActive = count;
+  }
+  setSchemaVersion(version) {
+    this.metrics.schemaVersion = version;
+  }
+  recordError(errorType) {
+    this.metrics.errorsByType[errorType] = (this.metrics.errorsByType[errorType] || 0) + 1;
+  }
+  recordTimeout() {
+    this.metrics.timeouts++;
+  }
+  recordCircuitBreakerTrip() {
+    this.metrics.circuitBreakerTrips++;
+  }
+  updateMemoryUsage() {
+    if (typeof process !== "undefined" && process.memoryUsage) {
+      const usage = process.memoryUsage();
+      this.metrics.memoryUsageMB = usage.heapUsed / 1024 / 1024;
+    }
+  }
+  setBufferUtilization(utilization) {
+    this.metrics.bufferUtilization = Math.min(1, Math.max(0, utilization));
+  }
+  getMetrics() {
+    this.metrics.uptimeMs = Date.now() - this.startTime;
+    return { ...this.metrics };
+  }
+  getLatencyStats() {
+    const latencies = this.metrics.coordinationLatencyUs;
+    if (latencies.length === 0) {
+      return { mean: 0, p50: 0, p95: 0, p99: 0, max: 0, min: 0 };
+    }
+    const sorted = [...latencies].sort((a, b) => a - b);
+    const sum = latencies.reduce((a, b) => a + b, 0);
+    return {
+      mean: sum / latencies.length,
+      p50: sorted[Math.floor(sorted.length * 0.5)],
+      p95: sorted[Math.floor(sorted.length * 0.95)],
+      p99: sorted[Math.floor(sorted.length * 0.99)],
+      max: sorted[sorted.length - 1],
+      min: sorted[0]
+    };
+  }
+  reset() {
+    this.metrics = this.initializeMetrics();
+    this.logger.info("Metrics", "Metrics reset");
+  }
+};
+var HealthChecker = class {
+  metrics;
+  logger = Logger.getInstance();
+  version = "0.2.0-rc.0";
+  constructor(metrics) {
+    this.metrics = metrics;
+  }
+  getHealthStatus() {
+    const metrics = this.metrics.getMetrics();
+    const latencyStats = this.metrics.getLatencyStats();
+    const memoryHealthy = metrics.memoryUsageMB < 500;
+    const latencyHealthy = latencyStats.p99 < 1e4;
+    const errorRateHealthy = this.getErrorRate() < 0.01;
+    const circuitBreakersHealthy = metrics.circuitBreakerTrips === 0;
+    const allHealthy = memoryHealthy && latencyHealthy && errorRateHealthy && circuitBreakersHealthy;
+    const someHealthy = memoryHealthy && latencyHealthy;
+    let status;
+    if (allHealthy) {
+      status = "HEALTHY";
+    } else if (someHealthy) {
+      status = "DEGRADED";
+    } else {
+      status = "UNHEALTHY";
+    }
+    return {
+      status,
+      uptime: metrics.uptimeMs,
+      version: this.version,
+      timestamp: Date.now(),
+      checks: {
+        memory: memoryHealthy,
+        latency: latencyHealthy,
+        errorRate: errorRateHealthy,
+        circuitBreakers: circuitBreakersHealthy
+      },
+      metrics: {
+        messagesProcessed: metrics.messagesProcessed,
+        agentsConnected: metrics.agentsConnected,
+        coordinationLatencyUs: latencyStats,
+        memoryUsageMB: metrics.memoryUsageMB,
+        errorsByType: metrics.errorsByType
+      }
+    };
+  }
+  getErrorRate() {
+    const metrics = this.metrics.getMetrics();
+    const totalErrors = Object.values(metrics.errorsByType).reduce((sum, count) => sum + count, 0);
+    const totalOperations = metrics.messagesProcessed + totalErrors;
+    return totalOperations > 0 ? totalErrors / totalOperations : 0;
+  }
+  startHealthCheck(intervalMs = 3e4) {
+    setInterval(() => {
+      const status = this.getHealthStatus();
+      this.logger.info("Health", `Health status: ${status.status}`, {
+        uptime: status.uptime,
+        checks: status.checks,
+        messagesProcessed: status.metrics.messagesProcessed
+      });
+      if (status.status === "UNHEALTHY") {
+        this.logger.error("Health", "System is unhealthy", void 0, {
+          checks: status.checks,
+          metrics: status.metrics
+        });
+      }
+    }, intervalMs);
+  }
+};
+var Profiler = class {
+  static sessions = /* @__PURE__ */ new Map();
+  logger = Logger.getInstance();
+  static startSession(sessionId) {
+    this.sessions.set(sessionId, {
+      startTime: performance.now(),
+      events: []
+    });
+    this.getLogger().debug("Profiler", `Started profiling session: ${sessionId}`);
+  }
+  static recordEvent(sessionId, event, data) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      this.getLogger().warn("Profiler", `No active session: ${sessionId}`);
+      return;
+    }
+    session.events.push({
+      time: performance.now() - session.startTime,
+      event,
+      data
+    });
+  }
+  static endSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      this.getLogger().warn("Profiler", `No active session: ${sessionId}`);
+      return [];
+    }
+    this.sessions.delete(sessionId);
+    this.getLogger().debug("Profiler", `Ended profiling session: ${sessionId}`, {
+      duration: performance.now() - session.startTime,
+      eventCount: session.events.length
+    });
+    return session.events;
+  }
+  static getLogger() {
+    return Logger.getInstance();
+  }
+};
+function createProductionLogger(config) {
+  const logger = Logger.getInstance();
+  if (config?.level !== void 0) {
+    logger.setLogLevel(config.level);
+  }
+  if (config?.enableConsole === false) {
+    logger.setLogCallback(() => {
+    });
+  }
+  return logger;
+}
+function createMetricsCollector(autoUpdateMs) {
+  const collector = new MetricsCollector();
+  if (autoUpdateMs) {
+    setInterval(() => {
+      collector.updateMemoryUsage();
+    }, autoUpdateMs);
+  }
+  return collector;
+}
+
+// src/bitmask.ts
+var BITMASK_WIDTH = 64;
+var EMERGENCY_RANGE = [56, 63];
+var HIGH_FREQ_RANGE = [0, 47];
+var MED_FREQ_RANGE = [48, 55];
+var SINGLE_BIT_TO_POSITION = new Map(
+  Array.from({ length: BITMASK_WIDTH }, (_, i) => [1n << BigInt(i), i])
+);
+function empty() {
+  return 0n;
+}
+function setBit(mask, position) {
+  if (position < 0 || position >= BITMASK_WIDTH) {
+    throw new RangeError(`Bit position ${position} out of range [0, ${BITMASK_WIDTH - 1}]`);
+  }
+  return mask | 1n << BigInt(position);
+}
+function clearBit(mask, position) {
+  if (position < 0 || position >= BITMASK_WIDTH) {
+    throw new RangeError(`Bit position ${position} out of range [0, ${BITMASK_WIDTH - 1}]`);
+  }
+  return mask & ~(1n << BigInt(position));
+}
+function testBit(mask, position) {
+  if (position < 0 || position >= BITMASK_WIDTH) {
+    throw new RangeError(`Bit position ${position} out of range [0, ${BITMASK_WIDTH - 1}]`);
+  }
+  return (mask & 1n << BigInt(position)) !== 0n;
+}
+function popcount(mask) {
+  let count = 0;
+  let m = mask;
+  while (m > 0n) {
+    m &= m - 1n;
+    count++;
+  }
+  return count;
+}
+function activeBits(mask) {
+  const bits = [];
+  forEachSetBit(mask, (bit) => bits.push(bit));
+  return bits;
+}
+function forEachSetBit(mask, fn) {
+  if (mask < 0n) {
+    throw new RangeError("Bitmask must be non-negative");
+  }
+  let m = mask;
+  while (m !== 0n) {
+    const leastSignificantBit = m & -m;
+    const position = SINGLE_BIT_TO_POSITION.get(leastSignificantBit);
+    if (position === void 0) {
+      throw new Error(`Invalid 64-bit mask: ${mask.toString()}`);
+    }
+    fn(position);
+    m ^= leastSignificantBit;
+  }
+}
+function merge(a, b) {
+  return a | b;
+}
+function intersect(a, b) {
+  return a & b;
+}
+function delta(prev, next) {
+  return prev ^ next;
+}
+function hammingDistance(a, b) {
+  return popcount(a ^ b);
+}
+function hasEmergency(mask) {
+  const emergencyMask = 0xFFn << 56n;
+  return (mask & emergencyMask) !== 0n;
+}
+function emergencyBits(mask) {
+  return mask & 0xFFn << 56n;
+}
+function toBytes(mask) {
+  const buf = new Uint8Array(8);
+  let m = mask;
+  for (let i = 0; i < 8; i++) {
+    buf[i] = Number(m & 0xFFn);
+    m >>= 8n;
+  }
+  return buf;
+}
+function fromBytes(buf) {
+  if (buf.length < 8) {
+    throw new Error(`Expected 8 bytes, got ${buf.length}`);
+  }
+  let mask = 0n;
+  for (let i = 7; i >= 0; i--) {
+    mask = mask << 8n | BigInt(buf[i]);
+  }
+  return mask;
+}
+function encode(features, schema, options = {}) {
+  let mask = 0n;
+  let mapped = 0;
+  let unmapped = 0;
+  const unknownFeatures = [];
+  for (const feature of features) {
+    const bit = schema.get(feature);
+    if (bit !== void 0) {
+      mask |= 1n << BigInt(bit);
+      mapped++;
+    } else {
+      unmapped++;
+      unknownFeatures.push(feature);
+    }
+  }
+  if (options.throwOnUnknownFeatures && unknownFeatures.length > 0) {
+    const uniqueUnknown = [...new Set(unknownFeatures)];
+    throw new Error(
+      `Unknown features (${uniqueUnknown.length}): ${uniqueUnknown.join(", ")}`
+    );
+  }
+  return { mask, mapped, unmapped };
+}
+function decode(mask, reverseSchema) {
+  const features = [];
+  for (let i = 0; i < BITMASK_WIDTH; i++) {
+    if (mask & 1n << BigInt(i)) {
+      const feats = reverseSchema.get(i);
+      if (feats) {
+        features.push(...feats);
+      }
+    }
+  }
+  return features;
+}
+
+// src/schema.ts
+var MAX_EMERGENCY_FEATURES = EMERGENCY_RANGE[1] - EMERGENCY_RANGE[0] + 1;
+var MAX_REGULAR_FEATURES = HIGH_FREQ_RANGE[1] - HIGH_FREQ_RANGE[0] + 1 + (MED_FREQ_RANGE[1] - MED_FREQ_RANGE[0] + 1);
+var FNV_OFFSET_64 = 0xcbf29ce484222325n;
+var FNV_PRIME_64 = 0x100000001b3n;
+var MASK_64 = (1n << 64n) - 1n;
+var SchemaManager = class {
+  _version = 0;
+  _featureToBit = /* @__PURE__ */ new Map();
+  _bitToFeatures = /* @__PURE__ */ new Map();
+  _activationCounts = /* @__PURE__ */ new Map();
+  _totalActivations = 0;
+  _emergencyFeatures;
+  _emergencyPrefix;
+  _maxFeatures;
+  constructor(config = {}) {
+    this._maxFeatures = config.maxFeatures ?? BITMASK_WIDTH;
+    this._emergencyPrefix = config.emergencyPrefix ?? "EMERGENCY_";
+    this._emergencyFeatures = new Set(config.emergencyFeatures ?? []);
+  }
+  /** Current schema version. */
+  get version() {
+    return this._version;
+  }
+  /** Read-only view of feature → bit mapping. */
+  get featureToBit() {
+    return this._featureToBit;
+  }
+  /** Read-only view of bit → features mapping. */
+  get bitToFeatures() {
+    return this._bitToFeatures;
+  }
+  /** Number of actively mapped features. */
+  get activeFeatureCount() {
+    return this._featureToBit.size;
+  }
+  /** Deterministic fingerprint of current schema mapping and version. */
+  get fingerprint() {
+    return this._computeFingerprint(
+      this._version,
+      this._featureToBit,
+      this._emergencyPrefix,
+      this._emergencyFeatures
+    );
+  }
+  /** Check if a feature is an emergency feature. */
+  isEmergency(feature) {
+    return this._emergencyFeatures.has(feature) || feature.startsWith(this._emergencyPrefix);
+  }
+  /**
+   * Register a feature in the schema.
+   * Emergency features are pinned to bits 56-63.
+   * Regular features fill bits 0-55 in order.
+   *
+   * Returns the assigned bit position, or -1 if schema is full.
+   */
+  register(feature) {
+    const existing = this._featureToBit.get(feature);
+    if (existing !== void 0) return existing;
+    if (this._featureToBit.size >= this._maxFeatures) return -1;
+    if (this.isEmergency(feature)) {
+      return this._registerEmergency(feature);
+    }
+    return this._registerRegular(feature);
+  }
+  /**
+   * Register multiple features at once.
+   * Returns a map of feature → assigned bit position.
+   */
+  registerAll(features) {
+    const result = /* @__PURE__ */ new Map();
+    for (const feature of features) {
+      result.set(feature, this.register(feature));
+    }
+    return result;
+  }
+  /**
+   * Record feature activations for frequency tracking.
+   * Call this every coordination round with the observed features.
+   */
+  recordActivations(features) {
+    for (const feature of features) {
+      const count = this._activationCounts.get(feature) ?? 0;
+      this._activationCounts.set(feature, count + 1);
+      this._totalActivations++;
+    }
+  }
+  /**
+   * Frequency-based pruning (Section 3.3).
+   *
+   * Sorts features by activation frequency, retains:
+   * - All emergency features in bits 56-63 (never pruned)
+   * - Top 48 regular features in bits 0-47 (high-frequency)
+   * - Next 8 regular features in bits 48-55 (medium-frequency)
+   *
+   * Increments schema version.
+   */
+  prune() {
+    const knownFeatures = this._collectKnownFeatures();
+    const emergencyList = knownFeatures.filter((feature) => this.isEmergency(feature)).sort((a, b) => this._compareByFrequencyThenName(a, b));
+    const regularList = knownFeatures.filter((feature) => !this.isEmergency(feature)).sort((a, b) => this._compareByFrequencyThenName(a, b));
+    const newFeatureToBit = /* @__PURE__ */ new Map();
+    const newBitToFeatures = /* @__PURE__ */ new Map();
+    const [emergStart] = EMERGENCY_RANGE;
+    for (let i = 0; i < Math.min(emergencyList.length, MAX_EMERGENCY_FEATURES); i++) {
+      const bit = emergStart + i;
+      const feature = emergencyList[i];
+      newFeatureToBit.set(feature, bit);
+      newBitToFeatures.set(bit, [feature]);
+    }
+    const [highStart] = HIGH_FREQ_RANGE;
+    const highCount = HIGH_FREQ_RANGE[1] - HIGH_FREQ_RANGE[0] + 1;
+    for (let i = 0; i < Math.min(regularList.length, highCount); i++) {
+      const bit = highStart + i;
+      const feature = regularList[i];
+      newFeatureToBit.set(feature, bit);
+      newBitToFeatures.set(bit, [feature]);
+    }
+    const [medStart] = MED_FREQ_RANGE;
+    for (let i = highCount; i < Math.min(regularList.length, MAX_REGULAR_FEATURES); i++) {
+      const bit = medStart + (i - highCount);
+      const feature = regularList[i];
+      newFeatureToBit.set(feature, bit);
+      newBitToFeatures.set(bit, [feature]);
+    }
+    const excludedFeatures = [
+      ...regularList.slice(MAX_REGULAR_FEATURES),
+      ...emergencyList.slice(MAX_EMERGENCY_FEATURES)
+    ];
+    const mappingChanged = !this._mapsEqual(this._featureToBit, newFeatureToBit);
+    if (mappingChanged) {
+      this._featureToBit = newFeatureToBit;
+      this._bitToFeatures = newBitToFeatures;
+      this._version++;
+    }
+    return {
+      pruned: excludedFeatures.length,
+      retained: this._featureToBit.size,
+      version: this._version,
+      excludedFeatures
+    };
+  }
+  /** Get a serializable snapshot of the current schema state. */
+  snapshot() {
+    let emergencyCount = 0;
+    for (const [feat] of this._featureToBit) {
+      if (this.isEmergency(feat)) emergencyCount++;
+    }
+    return {
+      version: this._version,
+      featureToBit: new Map(this._featureToBit),
+      bitToFeatures: new Map(
+        [...this._bitToFeatures].map(([k, v]) => [k, [...v]])
+      ),
+      totalTracked: this._activationCounts.size,
+      activeFeatures: this._featureToBit.size,
+      emergencyCount
+    };
+  }
+  /**
+   * Export canonical schema state for distribution.
+   * Entries are sorted by bit (then feature) for deterministic serialization.
+   */
+  exportSchema() {
+    const entries = [...this._featureToBit.entries()].sort((a, b) => {
+      if (a[1] !== b[1]) return a[1] - b[1];
+      return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
+    }).map(([feature, bit]) => [feature, bit]);
+    return {
+      version: this._version,
+      entries,
+      emergencyPrefix: this._emergencyPrefix,
+      emergencyFeatures: [...this._emergencyFeatures].sort(
+        (a, b) => a < b ? -1 : a > b ? 1 : 0
+      ),
+      fingerprint: this.fingerprint
+    };
+  }
+  /**
+   * Import an exported schema state.
+   * Replaces active mappings and resets activation counters.
+   */
+  importSchema(schema) {
+    this._assertExportedSchema(schema);
+    const newFeatureToBit = /* @__PURE__ */ new Map();
+    const newBitToFeatures = /* @__PURE__ */ new Map();
+    for (const [feature, bit] of schema.entries) {
+      newFeatureToBit.set(feature, bit);
+      newBitToFeatures.set(bit, [feature]);
+    }
+    const expectedFingerprint = this._computeFingerprint(
+      schema.version,
+      newFeatureToBit,
+      schema.emergencyPrefix,
+      new Set(schema.emergencyFeatures)
+    );
+    if (schema.fingerprint !== expectedFingerprint) {
+      throw new Error(
+        `Schema fingerprint mismatch: expected ${expectedFingerprint}, got ${schema.fingerprint}`
+      );
+    }
+    this._featureToBit = newFeatureToBit;
+    this._bitToFeatures = newBitToFeatures;
+    this._emergencyPrefix = schema.emergencyPrefix;
+    this._emergencyFeatures = new Set(schema.emergencyFeatures);
+    this._activationCounts.clear();
+    this._totalActivations = 0;
+    this._version = schema.version;
+  }
+  /** Get activation frequency for a feature. */
+  getFrequency(feature) {
+    return this._activationCounts.get(feature) ?? 0;
+  }
+  /** Get all features ranked by activation frequency. */
+  getRankedFeatures() {
+    const ranked = [];
+    for (const [feature, count] of this._activationCounts) {
+      ranked.push({
+        feature,
+        count,
+        bit: this._featureToBit.get(feature)
+      });
+    }
+    ranked.sort((a, b) => b.count - a.count);
+    return ranked;
+  }
+  /** Reset all activation counts (but keep schema mappings). */
+  resetCounts() {
+    this._activationCounts.clear();
+    this._totalActivations = 0;
+  }
+  /**
+   * Collision probability for a specific feature:
+   * P(collision) = 1 - (1 - 1/64)^(m - 1)
+   * where m is active feature count.
+   */
+  get theoreticalCollisionRate() {
+    const m = this._featureToBit.size;
+    if (m <= 1) return 0;
+    return 1 - Math.pow(1 - 1 / BITMASK_WIDTH, m - 1);
+  }
+  /**
+   * Expected excluded feature count under uniform assignment:
+   * E[excluded] = m - 64 * (1 - (1 - 1/64)^m)
+   */
+  expectedExcludedFeatures(featureCount = this._featureToBit.size) {
+    if (!Number.isInteger(featureCount) || featureCount < 0) {
+      throw new RangeError(
+        `featureCount must be a non-negative integer, got ${featureCount}`
+      );
+    }
+    if (featureCount === 0) return 0;
+    return featureCount - BITMASK_WIDTH * (1 - Math.pow(1 - 1 / BITMASK_WIDTH, featureCount));
+  }
+  // ── Private ──
+  _registerEmergency(feature) {
+    const [start, end] = EMERGENCY_RANGE;
+    for (let bit = start; bit <= end; bit++) {
+      if (!this._bitToFeatures.has(bit)) {
+        this._featureToBit.set(feature, bit);
+        this._bitToFeatures.set(bit, [feature]);
+        this._version++;
+        return bit;
+      }
+    }
+    return -1;
+  }
+  _registerRegular(feature) {
+    const [highStart, highEnd] = HIGH_FREQ_RANGE;
+    for (let bit = highStart; bit <= highEnd; bit++) {
+      if (!this._bitToFeatures.has(bit)) {
+        this._featureToBit.set(feature, bit);
+        this._bitToFeatures.set(bit, [feature]);
+        this._version++;
+        return bit;
+      }
+    }
+    const [medStart, medEnd] = MED_FREQ_RANGE;
+    for (let bit = medStart; bit <= medEnd; bit++) {
+      if (!this._bitToFeatures.has(bit)) {
+        this._featureToBit.set(feature, bit);
+        this._bitToFeatures.set(bit, [feature]);
+        this._version++;
+        return bit;
+      }
+    }
+    return -1;
+  }
+  _collectKnownFeatures() {
+    const all = /* @__PURE__ */ new Set();
+    for (const feature of this._activationCounts.keys()) all.add(feature);
+    for (const feature of this._featureToBit.keys()) all.add(feature);
+    for (const feature of this._emergencyFeatures) all.add(feature);
+    return [...all];
+  }
+  _compareByFrequencyThenName(a, b) {
+    const countA = this._activationCounts.get(a) ?? 0;
+    const countB = this._activationCounts.get(b) ?? 0;
+    if (countA !== countB) return countB - countA;
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  }
+  _mapsEqual(a, b) {
+    if (a.size !== b.size) return false;
+    for (const [feature, bit] of a) {
+      if (b.get(feature) !== bit) return false;
+    }
+    return true;
+  }
+  _assertExportedSchema(schema) {
+    if (!Number.isInteger(schema.version) || schema.version < 0) {
+      throw new RangeError(`Schema version must be a non-negative integer, got ${schema.version}`);
+    }
+    if (typeof schema.fingerprint !== "string" || schema.fingerprint.length === 0) {
+      throw new TypeError("Schema fingerprint must be a non-empty string");
+    }
+    const seenFeatures = /* @__PURE__ */ new Set();
+    const seenBits = /* @__PURE__ */ new Set();
+    for (const [feature, bit] of schema.entries) {
+      if (!feature || typeof feature !== "string") {
+        throw new TypeError(`Invalid feature name in schema export: ${String(feature)}`);
+      }
+      if (!Number.isInteger(bit) || bit < 0 || bit >= BITMASK_WIDTH) {
+        throw new RangeError(`Invalid bit position in schema export: ${bit}`);
+      }
+      if (seenFeatures.has(feature)) {
+        throw new Error(`Duplicate feature in schema export: ${feature}`);
+      }
+      if (seenBits.has(bit)) {
+        throw new Error(`Duplicate bit in schema export: ${bit}`);
+      }
+      seenFeatures.add(feature);
+      seenBits.add(bit);
+    }
+  }
+  _computeFingerprint(version, mapping, emergencyPrefix, emergencyFeatures) {
+    const canonicalEntries = [...mapping.entries()].sort((a, b) => {
+      if (a[1] !== b[1]) return a[1] - b[1];
+      if (a[0] < b[0]) return -1;
+      if (a[0] > b[0]) return 1;
+      return 0;
+    }).map(([feature, bit]) => `${bit}:${feature}`).join("|");
+    const canonicalEmergency = [...emergencyFeatures].sort((a, b) => a < b ? -1 : a > b ? 1 : 0).join("|");
+    const canonical = `v=${version};ep=${emergencyPrefix};ef=${canonicalEmergency};m=${canonicalEntries}`;
+    let hash = FNV_OFFSET_64;
+    for (const char of canonical) {
+      hash ^= BigInt(char.codePointAt(0) ?? 0);
+      hash = hash * FNV_PRIME_64 & MASK_64;
+    }
+    return hash.toString(16).padStart(16, "0");
+  }
+};
+
+// src/coordinator.ts
+var Coordinator = class {
+  _buffer = [];
+  _seenAgents = /* @__PURE__ */ new Set();
+  _schemaVersion;
+  _deadlineMs;
+  _staleMessagePolicy;
+  _onTelemetry;
+  _roundStartTime = 0;
+  _aggregationCount = 0;
+  _droppedStaleMessages = 0;
+  constructor(config = {}) {
+    this._deadlineMs = config.deadlineMs ?? 15;
+    this._schemaVersion = config.schemaVersion;
+    this._staleMessagePolicy = config.staleMessagePolicy ?? "accept";
+    this._onTelemetry = config.onTelemetry;
+  }
+  /** Number of messages in current buffer. */
+  get bufferedCount() {
+    return this._buffer.length;
+  }
+  /** Total aggregation rounds performed. */
+  get aggregationCount() {
+    return this._aggregationCount;
+  }
+  /** Update expected schema version. */
+  set schemaVersion(version) {
+    this._schemaVersion = version;
+  }
+  /** Start a new coordination round. Clears the buffer. */
+  startRound() {
+    this._buffer = [];
+    this._seenAgents.clear();
+    this._roundStartTime = performance.now();
+    this._droppedStaleMessages = 0;
+  }
+  /**
+   * Receive a message from an agent.
+   * Returns false if the message was dropped (deadline exceeded or duplicate agent).
+   */
+  receive(message) {
+    if (this._roundStartTime > 0) {
+      const elapsed = performance.now() - this._roundStartTime;
+      if (elapsed > this._deadlineMs) {
+        this._emitTelemetry({
+          type: "message_dropped",
+          agentId: message.agentId,
+          reason: "deadline"
+        });
+        return false;
+      }
+    }
+    const isStale = this._schemaVersion !== void 0 && message.schemaVersion !== this._schemaVersion;
+    if (isStale) {
+      if (this._staleMessagePolicy === "drop") {
+        this._droppedStaleMessages++;
+        this._emitTelemetry({
+          type: "message_dropped",
+          agentId: message.agentId,
+          reason: "stale"
+        });
+        return false;
+      }
+      if (this._staleMessagePolicy === "warn") {
+        console.warn(
+          `adaptive-bitmask: stale schema version from agent ${message.agentId} (expected ${this._schemaVersion}, got ${message.schemaVersion})`
+        );
+      }
+    }
+    if (this._seenAgents.has(message.agentId)) {
+      const idx = this._buffer.findIndex((m) => m.agentId === message.agentId);
+      if (idx !== -1) {
+        this._buffer[idx] = message;
+      }
+      this._emitTelemetry({
+        type: "message_accepted",
+        agentId: message.agentId,
+        stale: isStale,
+        replaced: true
+      });
+      return true;
+    }
+    this._seenAgents.add(message.agentId);
+    this._buffer.push(message);
+    this._emitTelemetry({
+      type: "message_accepted",
+      agentId: message.agentId,
+      stale: isStale,
+      replaced: false
+    });
+    return true;
+  }
+  /**
+   * Receive multiple messages at once.
+   * Returns number of messages accepted.
+   */
+  receiveAll(messages) {
+    let accepted = 0;
+    for (const msg of messages) {
+      if (this.receive(msg)) accepted++;
+    }
+    return accepted;
+  }
+  /**
+   * Aggregate all buffered messages into a consensus result.
+   * Clears the buffer after aggregation.
+   */
+  aggregate() {
+    const t0 = performance.now();
+    let aggregated = 0n;
+    const bitVotes = /* @__PURE__ */ new Map();
+    let staleCount = 0;
+    const uniqueAgents = /* @__PURE__ */ new Set();
+    for (const msg of this._buffer) {
+      uniqueAgents.add(msg.agentId);
+      if (this._schemaVersion !== void 0 && msg.schemaVersion !== this._schemaVersion) {
+        staleCount++;
+      }
+      aggregated |= msg.mask;
+      forEachSetBit(msg.mask, (bit) => {
+        bitVotes.set(bit, (bitVotes.get(bit) ?? 0) + 1);
+      });
+    }
+    const messageCount = this._buffer.length;
+    const confidence = /* @__PURE__ */ new Map();
+    for (const [bit, votes] of bitVotes) {
+      confidence.set(bit, messageCount > 0 ? votes / messageCount : 0);
+    }
+    const elapsed = (performance.now() - t0) * 1e3;
+    this._aggregationCount++;
+    this._buffer = [];
+    this._seenAgents.clear();
+    const result = {
+      aggregatedMask: aggregated,
+      confidence,
+      messageCount,
+      uniqueAgents: uniqueAgents.size,
+      staleMessages: staleCount,
+      droppedStaleMessages: this._droppedStaleMessages,
+      aggregationTimeUs: elapsed
+    };
+    this._emitTelemetry({ type: "round_aggregated", result });
+    return result;
+  }
+  _emitTelemetry(event) {
+    this._onTelemetry?.(event);
+  }
+};
+
+// src/arbiter.ts
+var Arbiter = class {
+  _weights;
+  _weightSum;
+  _executeThreshold;
+  _synthesizeThreshold;
+  _emergencyOverride;
+  _onTelemetry;
+  _decisionCount = 0;
+  constructor(config = {}) {
+    this._executeThreshold = config.executeThreshold ?? 0.55;
+    this._synthesizeThreshold = config.synthesizeThreshold ?? 0.4;
+    this._emergencyOverride = config.emergencyOverride ?? true;
+    this._onTelemetry = config.onTelemetry;
+    this._weights = new Float64Array(BITMASK_WIDTH);
+    if (config.weights) {
+      if (config.weights.length !== BITMASK_WIDTH) {
+        throw new Error(`Weight vector must have ${BITMASK_WIDTH} elements, got ${config.weights.length}`);
+      }
+      this._weights.set(config.weights);
+    } else {
+      this._weights.fill(1);
+    }
+    this._weightSum = this._weights.reduce((sum, w) => sum + w, 0);
+  }
+  /** Number of decisions made since creation. */
+  get decisionCount() {
+    return this._decisionCount;
+  }
+  /** Set the weight for a specific bit position. */
+  setWeight(position, weight) {
+    if (position < 0 || position >= BITMASK_WIDTH) {
+      throw new RangeError(`Position ${position} out of range`);
+    }
+    this._weightSum -= this._weights[position];
+    this._weights[position] = weight;
+    this._weightSum += weight;
+  }
+  /** Get the current weight vector (copy). */
+  get weights() {
+    return Array.from(this._weights);
+  }
+  /**
+   * Score an aggregated bitmask and produce a decision.
+   *
+   * @param aggregatedMask — OR-aggregated mask from all agents
+   * @param confidence — Optional per-bit confidence (fraction of agents that set each bit)
+   */
+  score(aggregatedMask, confidence) {
+    const t0 = performance.now();
+    const active = activeBits(aggregatedMask);
+    const emergency = hasEmergency(aggregatedMask);
+    if (emergency && this._emergencyOverride) {
+      const elapsed2 = (performance.now() - t0) * 1e3;
+      this._decisionCount++;
+      const result2 = {
+        decision: "REJECT",
+        rawScore: 0,
+        confidenceScore: 0,
+        finalScore: 0,
+        activeBitCount: active.length,
+        hasEmergency: true,
+        scoringTimeUs: elapsed2
+      };
+      this._emitTelemetry({ type: "decision", result: result2 });
+      return result2;
+    }
+    let numerator = 0;
+    for (const bit of active) {
+      numerator += this._weights[bit];
+    }
+    const rawScore = this._weightSum > 0 ? numerator / this._weightSum : 0;
+    let confidenceScore = rawScore;
+    if (confidence && confidence.size > 0) {
+      let confNumerator = 0;
+      let confDenominator = 0;
+      for (const bit of active) {
+        const conf = confidence.get(bit) ?? 0;
+        confNumerator += conf * this._weights[bit];
+        confDenominator += this._weights[bit];
+      }
+      confidenceScore = confDenominator > 0 ? confNumerator / confDenominator : rawScore;
+    }
+    const finalScore = Math.min(1, rawScore * 0.6 + confidenceScore * 0.4);
+    let decision;
+    if (finalScore >= this._executeThreshold) {
+      decision = "EXECUTE";
+    } else if (finalScore >= this._synthesizeThreshold) {
+      decision = "SYNTHESIZE";
+    } else {
+      decision = "REJECT";
+    }
+    const elapsed = (performance.now() - t0) * 1e3;
+    this._decisionCount++;
+    const result = {
+      decision,
+      rawScore,
+      confidenceScore,
+      finalScore,
+      activeBitCount: active.length,
+      hasEmergency: emergency,
+      scoringTimeUs: elapsed
+    };
+    this._emitTelemetry({ type: "decision", result });
+    return result;
+  }
+  /**
+   * Convenience: aggregate messages then score.
+   * OR-merges all message masks, computes per-bit confidence,
+   * validates schema versions, then runs scoring.
+   */
+  scoreMessages(messages, expectedSchemaVersion) {
+    if (messages.length === 0) {
+      return {
+        decision: "REJECT",
+        rawScore: 0,
+        confidenceScore: 0,
+        finalScore: 0,
+        activeBitCount: 0,
+        hasEmergency: false,
+        scoringTimeUs: 0,
+        staleCount: 0
+      };
+    }
+    let aggregated = 0n;
+    const bitVotes = /* @__PURE__ */ new Map();
+    let staleCount = 0;
+    for (const msg of messages) {
+      if (expectedSchemaVersion !== void 0 && msg.schemaVersion !== expectedSchemaVersion) {
+        staleCount++;
+      }
+      aggregated |= msg.mask;
+      forEachSetBit(msg.mask, (bit) => {
+        bitVotes.set(bit, (bitVotes.get(bit) ?? 0) + 1);
+      });
+    }
+    const confidence = /* @__PURE__ */ new Map();
+    for (const [bit, votes] of bitVotes) {
+      confidence.set(bit, votes / messages.length);
+    }
+    const result = this.score(aggregated, confidence);
+    this._emitTelemetry({
+      type: "score_messages",
+      messageCount: messages.length,
+      staleCount,
+      result
+    });
+    return { ...result, staleCount };
+  }
+  /**
+   * Paper-canonical strategy ranking and decision logic (Section 6).
+   * Uses ŝ_final = 0.6*ŝ_raw + 0.4*c, then applies:
+   * - EXECUTE if lead > 15 points
+   * - SYNTHESIZE if top strategies are within threshold
+   * - REJECT if top score < 40%
+   */
+  scoreStrategies(candidates, options = {}) {
+    if (candidates.length === 0) {
+      const emptyResult = {
+        decision: "REJECT",
+        leadScore: 0,
+        rankings: []
+      };
+      this._emitTelemetry({ type: "strategy_decision", result: emptyResult });
+      return emptyResult;
+    }
+    const leadThreshold = options.leadThreshold ?? 0.15;
+    const rejectThreshold = options.rejectThreshold ?? 0.4;
+    const rankings = candidates.map((candidate) => {
+      const confidence = candidate.confidence ?? options.globalConfidence;
+      const scored = this._scoreMaskComponents(candidate.mask, confidence);
+      return {
+        id: candidate.id,
+        mask: candidate.mask,
+        rawScore: scored.rawScore,
+        confidenceScore: scored.confidenceScore,
+        finalScore: scored.finalScore
+      };
+    }).sort((a, b) => {
+      if (b.finalScore !== a.finalScore) return b.finalScore - a.finalScore;
+      if (a.id < b.id) return -1;
+      if (a.id > b.id) return 1;
+      return 0;
+    });
+    const top1 = rankings[0];
+    const top2 = rankings[1];
+    const leadScore = top2 ? top1.finalScore - top2.finalScore : top1.finalScore;
+    let result;
+    if (top1.finalScore < rejectThreshold) {
+      result = {
+        decision: "REJECT",
+        leadScore,
+        rankings
+      };
+    } else if (leadScore > leadThreshold) {
+      result = {
+        decision: "EXECUTE",
+        selectedStrategyId: top1.id,
+        leadScore,
+        rankings
+      };
+    } else {
+      const contenders = rankings.slice(0, Math.min(3, rankings.length)).filter((candidate) => top1.finalScore - candidate.finalScore <= leadThreshold);
+      const contenderMasks = contenders.length >= 2 ? contenders.map((candidate) => candidate.mask) : rankings.slice(0, Math.min(2, rankings.length)).map((candidate) => candidate.mask);
+      result = {
+        decision: "SYNTHESIZE",
+        synthesizedMask: this._synthesizeMask(contenderMasks),
+        leadScore,
+        rankings
+      };
+    }
+    this._decisionCount++;
+    this._emitTelemetry({ type: "strategy_decision", result });
+    return result;
+  }
+  _scoreMaskComponents(mask, confidence) {
+    if (hasEmergency(mask) && this._emergencyOverride) {
+      return { rawScore: 0, confidenceScore: 0, finalScore: 0 };
+    }
+    const active = activeBits(mask);
+    let numerator = 0;
+    for (const bit of active) {
+      numerator += this._weights[bit];
+    }
+    const rawScore = this._weightSum > 0 ? numerator / this._weightSum : 0;
+    let confidenceScore = rawScore;
+    if (confidence && confidence.size > 0) {
+      let confNumerator = 0;
+      let confDenominator = 0;
+      for (const bit of active) {
+        const conf = confidence.get(bit) ?? 0;
+        confNumerator += conf * this._weights[bit];
+        confDenominator += this._weights[bit];
+      }
+      confidenceScore = confDenominator > 0 ? confNumerator / confDenominator : rawScore;
+    }
+    return {
+      rawScore,
+      confidenceScore,
+      finalScore: Math.min(1, rawScore * 0.6 + confidenceScore * 0.4)
+    };
+  }
+  _synthesizeMask(masks) {
+    if (masks.length === 0) return 0n;
+    const votes = /* @__PURE__ */ new Map();
+    for (const mask of masks) {
+      forEachSetBit(mask, (bit) => {
+        votes.set(bit, (votes.get(bit) ?? 0) + 1);
+      });
+    }
+    const requiredVotes = Math.floor(masks.length / 2) + 1;
+    let synthesized = 0n;
+    for (const [bit, count] of votes) {
+      if (count >= requiredVotes) {
+        synthesized |= 1n << BigInt(bit);
+      }
+    }
+    return synthesized;
+  }
+  _emitTelemetry(event) {
+    this._onTelemetry?.(event);
+  }
+};
+function createFinancialArbiter(overrides) {
+  const weights = new Array(BITMASK_WIDTH).fill(0.08);
+  weights[0] = 0.25;
+  weights[1] = 0.25;
+  weights[2] = 0.2;
+  weights[3] = 0.2;
+  weights[8] = 0.2;
+  weights[10] = 0.18;
+  weights[12] = 0.15;
+  weights[13] = 0.22;
+  for (let i = 48; i < 56; i++) weights[i] = 0.12;
+  for (let i = 56; i < 64; i++) weights[i] = 0.45;
+  return new Arbiter({ weights, ...overrides });
+}
+function createRoboticArbiter(overrides) {
+  const weights = new Array(BITMASK_WIDTH).fill(0.1);
+  weights[0] = 0.3;
+  weights[4] = 0.25;
+  weights[10] = 0.2;
+  for (let i = 56; i < 64; i++) weights[i] = 0.45;
+  return new Arbiter({ weights, emergencyOverride: true, ...overrides });
+}
+
+// src/SharedCognition.ts
+var SharedCognition = class {
+  schema;
+  coordinator;
+  arbiter;
+  autoRegister;
+  constructor(config = {}) {
+    this.schema = new SchemaManager(config.schema);
+    this.coordinator = new Coordinator(config.coordinator);
+    this.arbiter = new Arbiter(config.arbiter);
+    this.autoRegister = config.autoRegister ?? true;
+  }
+  /**
+   * Process a single coordination tick across the entire swarm.
+   * 
+   * 1. Encodes all agent string observations into 64-bit masks
+   * 2. Routes through the Meta-Coordinator
+   * 3. Arbitrates a final decision
+   * 
+   * @param agentObservations Array of string feature arrays, one per agent
+   * @returns The unified swarm decision and latency
+   */
+  processSwarmTick(agentObservations) {
+    const startMs = performance.now();
+    if (this.autoRegister) {
+      const uniqueFeatures = /* @__PURE__ */ new Set();
+      for (const obs of agentObservations) {
+        for (const feature of obs) {
+          uniqueFeatures.add(feature);
+        }
+      }
+      this.schema.registerAll(Array.from(uniqueFeatures));
+    }
+    for (const obs of agentObservations) {
+      this.schema.recordActivations(obs);
+    }
+    this.coordinator.startRound();
+    this.coordinator.schemaVersion = this.schema.version;
+    let agentId = 0;
+    for (const obs of agentObservations) {
+      const { mask } = encode(obs, this.schema.featureToBit);
+      const msg = BitmaskMessage.now(mask, agentId++, this.schema.version);
+      this.coordinator.receive(msg);
+    }
+    const { aggregatedMask, confidence } = this.coordinator.aggregate();
+    const arbiterResult = this.arbiter.score(aggregatedMask, confidence);
+    const activeFeatures = decode(aggregatedMask, this.schema.bitToFeatures);
+    const latencyMs = performance.now() - startMs;
+    return {
+      decision: arbiterResult.decision,
+      finalScore: arbiterResult.finalScore,
+      latencyMs,
+      activeFeatures,
+      arbiterResult
+    };
+  }
+};
+
+// src/envelope.ts
+function createEnvelope(message, schemaFingerprint, roundId) {
+  if (!schemaFingerprint) {
+    throw new Error("schemaFingerprint is required");
+  }
+  return {
+    schemaFingerprint,
+    roundId,
+    payload: message.toBytes()
+  };
+}
+function decodeEnvelope(envelope, expectedSchemaFingerprint) {
+  if (!envelope.schemaFingerprint) {
+    throw new Error("Envelope schemaFingerprint is required");
+  }
+  if (expectedSchemaFingerprint && envelope.schemaFingerprint !== expectedSchemaFingerprint) {
+    throw new Error(
+      `Schema fingerprint mismatch: expected ${expectedSchemaFingerprint}, got ${envelope.schemaFingerprint}`
+    );
+  }
+  return BitmaskMessage.deserialize(envelope.payload);
+}
+
+export {
+  MESSAGE_SIZE_BYTES,
+  BitmaskMessage,
+  AdaptiveBitmaskError,
+  ValidationError,
+  SchemaValidationError,
+  MessageValidationError,
+  RuntimeError,
+  CoordinatorError,
+  ArbiterError,
+  NetworkError,
+  TimeoutError,
+  SystemError,
+  MemoryError,
+  Validator,
+  CircuitBreaker,
+  TimeoutManager,
+  RecoveryManager,
+  WebSocketTransport,
+  createWebSocketTransport,
+  HttpTransport,
+  createHttpTransport,
+  LogLevel,
+  Logger,
+  MetricsCollector,
+  HealthChecker,
+  Profiler,
+  createProductionLogger,
+  createMetricsCollector,
+  BITMASK_WIDTH,
+  EMERGENCY_RANGE,
+  HIGH_FREQ_RANGE,
+  MED_FREQ_RANGE,
+  empty,
+  setBit,
+  clearBit,
+  testBit,
+  popcount,
+  activeBits,
+  forEachSetBit,
+  merge,
+  intersect,
+  delta,
+  hammingDistance,
+  hasEmergency,
+  emergencyBits,
+  toBytes,
+  fromBytes,
+  encode,
+  decode,
+  SchemaManager,
+  Coordinator,
+  Arbiter,
+  createFinancialArbiter,
+  createRoboticArbiter,
+  SharedCognition,
+  createEnvelope,
+  decodeEnvelope
+};