state-surgeon 1.0.0

package/dist/recorder/index.js

@@ -0,0 +1,882 @@
+'use strict';
+
+var express = require('express');
+var ws = require('ws');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var express__default = /*#__PURE__*/_interopDefault(express);
+
+// src/recorder/api.ts
+function createAPIRoutes(store, reconstructor) {
+  const router = express.Router();
+  router.get("/health", (_req, res) => {
+    res.json({ status: "ok", timestamp: Date.now() });
+  });
+  router.get("/sessions", (req, res) => {
+    try {
+      const appId = req.query.appId;
+      const sessions = store.getSessions(appId);
+      res.json({ sessions });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/sessions/:sessionId", (req, res) => {
+    try {
+      const session = store.getSession(req.params.sessionId);
+      if (!session) {
+        return res.status(404).json({ error: "Session not found" });
+      }
+      res.json({ session });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.delete("/sessions/:sessionId", (req, res) => {
+    try {
+      const deleted = store.deleteSession(req.params.sessionId);
+      res.json({ deleted });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/sessions/:sessionId/timeline", (req, res) => {
+    try {
+      const timeline = store.getTimeline(req.params.sessionId);
+      res.json({ timeline, count: timeline.length });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/mutations", (req, res) => {
+    try {
+      const options = {
+        sessionId: req.query.sessionId,
+        startTime: req.query.startTime ? Number(req.query.startTime) : void 0,
+        endTime: req.query.endTime ? Number(req.query.endTime) : void 0,
+        source: req.query.source,
+        component: req.query.component,
+        limit: req.query.limit ? Number(req.query.limit) : 100,
+        offset: req.query.offset ? Number(req.query.offset) : 0,
+        sortOrder: req.query.sortOrder || "asc"
+      };
+      const mutations = store.queryMutations(options);
+      res.json({ mutations, count: mutations.length });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/mutations/:mutationId", (req, res) => {
+    try {
+      const mutation = store.getMutation(req.params.mutationId);
+      if (!mutation) {
+        return res.status(404).json({ error: "Mutation not found" });
+      }
+      res.json({ mutation });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/mutations/:mutationId/state", async (req, res) => {
+    try {
+      const state = await reconstructor.getStateAtMutation(req.params.mutationId);
+      res.json({ state });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/mutations/:mutationId/chain", async (req, res) => {
+    try {
+      const maxDepth = req.query.maxDepth ? Number(req.query.maxDepth) : 100;
+      const chain = await reconstructor.findCausalChain(req.params.mutationId, maxDepth);
+      res.json({ chain });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/sessions/:sessionId/path", async (req, res) => {
+    try {
+      const path = req.query.path;
+      if (!path) {
+        return res.status(400).json({ error: "Path is required" });
+      }
+      const mutations = await reconstructor.findMutationsForPath(req.params.sessionId, path);
+      res.json({ mutations, count: mutations.length });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/sessions/:sessionId/summary", async (req, res) => {
+    try {
+      const startTime = Number(req.query.startTime);
+      const endTime = Number(req.query.endTime);
+      if (isNaN(startTime) || isNaN(endTime)) {
+        return res.status(400).json({ error: "startTime and endTime are required" });
+      }
+      const summary = await reconstructor.summarizeTimeRange(
+        req.params.sessionId,
+        startTime,
+        endTime
+      );
+      res.json({ summary });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.get("/stats", (_req, res) => {
+    try {
+      const stats = store.getStats();
+      res.json({ stats });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  router.delete("/clear", (_req, res) => {
+    try {
+      store.clear();
+      reconstructor.clearCache();
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ error: String(error) });
+    }
+  });
+  return router;
+}
+
+// src/core/diff.ts
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      clonedMap.set(deepClone(key), deepClone(value));
+    });
+    return clonedMap;
+  }
+  if (obj instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clonedSet.add(deepClone(value));
+    });
+    return clonedSet;
+  }
+  const cloned = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = deepClone(obj[key]);
+    }
+  }
+  return cloned;
+}
+function calculateDiff(before, after, path = "") {
+  const diffs = [];
+  if (before === after) {
+    return diffs;
+  }
+  if (before === null || before === void 0 || typeof before !== "object") {
+    if (after === null || after === void 0 || typeof after !== "object") {
+      if (before !== after) {
+        if (before === void 0) {
+          diffs.push({ path: path || "root", operation: "ADD", newValue: after });
+        } else if (after === void 0) {
+          diffs.push({ path: path || "root", operation: "REMOVE", oldValue: before });
+        } else {
+          diffs.push({ path: path || "root", operation: "UPDATE", oldValue: before, newValue: after });
+        }
+      }
+      return diffs;
+    }
+    diffs.push({ path: path || "root", operation: "UPDATE", oldValue: before, newValue: after });
+    return diffs;
+  }
+  if (after === null || after === void 0 || typeof after !== "object") {
+    diffs.push({ path: path || "root", operation: "UPDATE", oldValue: before, newValue: after });
+    return diffs;
+  }
+  if (Array.isArray(before) || Array.isArray(after)) {
+    if (!Array.isArray(before) || !Array.isArray(after)) {
+      diffs.push({ path: path || "root", operation: "UPDATE", oldValue: before, newValue: after });
+      return diffs;
+    }
+    const maxLength = Math.max(before.length, after.length);
+    for (let i = 0; i < maxLength; i++) {
+      const itemPath = path ? `${path}[${i}]` : `[${i}]`;
+      if (i >= before.length) {
+        diffs.push({ path: itemPath, operation: "ADD", newValue: after[i] });
+      } else if (i >= after.length) {
+        diffs.push({ path: itemPath, operation: "REMOVE", oldValue: before[i] });
+      } else {
+        diffs.push(...calculateDiff(before[i], after[i], itemPath));
+      }
+    }
+    return diffs;
+  }
+  const beforeObj = before;
+  const afterObj = after;
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(beforeObj), ...Object.keys(afterObj)]);
+  for (const key of allKeys) {
+    const keyPath = path ? `${path}.${key}` : key;
+    const beforeValue = beforeObj[key];
+    const afterValue = afterObj[key];
+    if (!(key in beforeObj)) {
+      diffs.push({ path: keyPath, operation: "ADD", newValue: afterValue });
+    } else if (!(key in afterObj)) {
+      diffs.push({ path: keyPath, operation: "REMOVE", oldValue: beforeValue });
+    } else {
+      diffs.push(...calculateDiff(beforeValue, afterValue, keyPath));
+    }
+  }
+  return diffs;
+}
+function getValueAtPath(obj, path) {
+  if (!path || path === "root") return obj;
+  const parts = parsePath(path);
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function parsePath(path) {
+  const parts = [];
+  let current = "";
+  let inBracket = false;
+  for (const char of path) {
+    if (char === "." && !inBracket) {
+      if (current) parts.push(current);
+      current = "";
+    } else if (char === "[") {
+      if (current) parts.push(current);
+      current = "";
+      inBracket = true;
+    } else if (char === "]") {
+      if (current) parts.push(current);
+      current = "";
+      inBracket = false;
+    } else {
+      current += char;
+    }
+  }
+  if (current) parts.push(current);
+  return parts;
+}
+
+// src/recorder/reconstructor.ts
+var TimelineReconstructor = class {
+  constructor(store) {
+    this.stateCache = /* @__PURE__ */ new Map();
+    this.maxCacheSize = 1e3;
+    this.store = store;
+  }
+  /**
+   * Reconstructs the state at a specific mutation
+   */
+  async getStateAtMutation(mutationId) {
+    const cached = this.stateCache.get(mutationId);
+    if (cached !== void 0) {
+      return deepClone(cached);
+    }
+    const targetMutation = this.store.getMutation(mutationId);
+    if (!targetMutation) {
+      throw new Error(`Mutation not found: ${mutationId}`);
+    }
+    const timeline = this.store.getTimeline(targetMutation.sessionId);
+    const targetIndex = timeline.findIndex((m) => m.id === mutationId);
+    if (targetIndex === -1) {
+      throw new Error(`Mutation not in timeline: ${mutationId}`);
+    }
+    let state = {};
+    for (let i = 0; i <= targetIndex; i++) {
+      const mutation = timeline[i];
+      state = mutation.nextState;
+      this.cacheState(mutation.id, state);
+    }
+    return deepClone(state);
+  }
+  /**
+   * Reconstructs the state at a specific timestamp
+   */
+  async getStateAtTime(sessionId, timestamp) {
+    const timeline = this.store.getTimeline(sessionId);
+    let lastMutation = null;
+    for (const mutation of timeline) {
+      if (mutation.timestamp <= timestamp) {
+        lastMutation = mutation;
+      } else {
+        break;
+      }
+    }
+    if (!lastMutation) {
+      return {};
+    }
+    return this.getStateAtMutation(lastMutation.id);
+  }
+  /**
+   * Finds the causal chain leading to a mutation
+   */
+  async findCausalChain(mutationId, maxDepth = 100) {
+    const chain = [];
+    let currentId = mutationId;
+    let depth = 0;
+    while (currentId && depth < maxDepth) {
+      const mutation = this.store.getMutation(currentId);
+      if (!mutation) break;
+      chain.push(mutation);
+      if (mutation.parentMutationId) {
+        currentId = mutation.parentMutationId;
+      } else if (mutation.causes && mutation.causes.length > 0) {
+        currentId = mutation.causes[0];
+      } else {
+        break;
+      }
+      depth++;
+    }
+    return {
+      mutations: chain.reverse(),
+      rootCause: chain[0]
+    };
+  }
+  /**
+   * Binary search to find when state became invalid
+   */
+  async findStateCorruption(sessionId, validator) {
+    const timeline = this.store.getTimeline(sessionId);
+    if (timeline.length === 0) {
+      return null;
+    }
+    let left = 0;
+    let right = timeline.length - 1;
+    let firstBad = null;
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2);
+      const state = await this.getStateAtMutation(timeline[mid].id);
+      const isValid = validator(state);
+      if (isValid) {
+        left = mid + 1;
+      } else {
+        firstBad = mid;
+        right = mid - 1;
+      }
+    }
+    return firstBad !== null ? timeline[firstBad] : null;
+  }
+  /**
+   * Finds all mutations that touched a specific path
+   */
+  async findMutationsForPath(sessionId, path) {
+    const timeline = this.store.getTimeline(sessionId);
+    const result = [];
+    for (const mutation of timeline) {
+      if (mutation.diff) {
+        for (const diff of mutation.diff) {
+          if (diff.path === path || diff.path.startsWith(path + ".") || diff.path.startsWith(path + "[")) {
+            result.push(mutation);
+            break;
+          }
+        }
+      } else {
+        const prevValue = getValueAtPath(mutation.previousState, path);
+        const nextValue = getValueAtPath(mutation.nextState, path);
+        if (prevValue !== nextValue) {
+          result.push(mutation);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Compares two sessions to find divergence points
+   */
+  async compareSessions(sessionId1, sessionId2) {
+    const timeline1 = this.store.getTimeline(sessionId1);
+    const timeline2 = this.store.getTimeline(sessionId2);
+    let divergencePoint;
+    const minLength = Math.min(timeline1.length, timeline2.length);
+    for (let i = 0; i < minLength; i++) {
+      const state1 = await this.getStateAtMutation(timeline1[i].id);
+      const state2 = await this.getStateAtMutation(timeline2[i].id);
+      if (JSON.stringify(state1) !== JSON.stringify(state2)) {
+        divergencePoint = i;
+        break;
+      }
+    }
+    const actions1 = new Set(timeline1.map((m) => `${m.actionType}:${JSON.stringify(m.actionPayload)}`));
+    const actions2 = new Set(timeline2.map((m) => `${m.actionType}:${JSON.stringify(m.actionPayload)}`));
+    const session1Only = timeline1.filter(
+      (m) => !actions2.has(`${m.actionType}:${JSON.stringify(m.actionPayload)}`)
+    );
+    const session2Only = timeline2.filter(
+      (m) => !actions1.has(`${m.actionType}:${JSON.stringify(m.actionPayload)}`)
+    );
+    return {
+      divergencePoint,
+      session1Only,
+      session2Only
+    };
+  }
+  /**
+   * Generates a summary of what happened in a time range
+   */
+  async summarizeTimeRange(sessionId, startTime, endTime) {
+    const mutations = this.store.queryMutations({
+      sessionId,
+      startTime,
+      endTime
+    });
+    const componentBreakdown = {};
+    const sourceBreakdown = {};
+    const pathsSet = /* @__PURE__ */ new Set();
+    for (const mutation of mutations) {
+      const component = mutation.component || "unknown";
+      componentBreakdown[component] = (componentBreakdown[component] || 0) + 1;
+      sourceBreakdown[mutation.source] = (sourceBreakdown[mutation.source] || 0) + 1;
+      if (mutation.diff) {
+        for (const diff of mutation.diff) {
+          pathsSet.add(diff.path);
+        }
+      }
+    }
+    return {
+      mutationCount: mutations.length,
+      componentBreakdown,
+      sourceBreakdown,
+      pathsChanged: Array.from(pathsSet)
+    };
+  }
+  /**
+   * Clears the state cache
+   */
+  clearCache() {
+    this.stateCache.clear();
+  }
+  cacheState(mutationId, state) {
+    if (this.stateCache.size >= this.maxCacheSize) {
+      const firstKey = this.stateCache.keys().next().value;
+      if (firstKey) {
+        this.stateCache.delete(firstKey);
+      }
+    }
+    this.stateCache.set(mutationId, deepClone(state));
+  }
+};
+
+// src/recorder/store.ts
+var MutationStore = class {
+  constructor(options = {}) {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.mutations = /* @__PURE__ */ new Map();
+    this.totalMutationCount = 0;
+    this.options = {
+      maxMutationsPerSession: options.maxMutationsPerSession ?? 1e4,
+      maxTotalMutations: options.maxTotalMutations ?? 1e5,
+      sessionTimeout: options.sessionTimeout ?? 30 * 60 * 1e3,
+      // 30 minutes
+      debug: options.debug ?? false
+    };
+  }
+  /**
+   * Creates or updates a session
+   */
+  registerSession(sessionId, appId, metadata) {
+    let session = this.sessions.get(sessionId);
+    if (!session) {
+      session = {
+        id: sessionId,
+        appId,
+        startTime: /* @__PURE__ */ new Date(),
+        metadata,
+        mutationCount: 0
+      };
+      this.sessions.set(sessionId, session);
+      this.mutations.set(sessionId, []);
+      this.log("Session registered:", sessionId);
+    }
+    return session;
+  }
+  /**
+   * Ends a session
+   */
+  endSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.endTime = /* @__PURE__ */ new Date();
+      this.log("Session ended:", sessionId);
+    }
+  }
+  /**
+   * Stores a mutation
+   */
+  storeMutation(mutation) {
+    const sessionId = mutation.sessionId;
+    if (!this.sessions.has(sessionId)) {
+      this.registerSession(sessionId, "unknown");
+    }
+    let sessionMutations = this.mutations.get(sessionId);
+    if (!sessionMutations) {
+      sessionMutations = [];
+      this.mutations.set(sessionId, sessionMutations);
+    }
+    if (!mutation.diff && mutation.previousState !== void 0 && mutation.nextState !== void 0) {
+      mutation.diff = calculateDiff(mutation.previousState, mutation.nextState);
+    }
+    if (sessionMutations.length >= this.options.maxMutationsPerSession) {
+      sessionMutations.shift();
+      this.totalMutationCount--;
+    }
+    if (this.totalMutationCount >= this.options.maxTotalMutations) {
+      this.evictOldestMutations();
+    }
+    sessionMutations.push(mutation);
+    this.totalMutationCount++;
+    const session = this.sessions.get(sessionId);
+    session.mutationCount++;
+    this.log("Mutation stored:", mutation.id);
+  }
+  /**
+   * Stores multiple mutations at once
+   */
+  storeMutations(mutations) {
+    for (const mutation of mutations) {
+      this.storeMutation(mutation);
+    }
+  }
+  /**
+   * Gets a session by ID
+   */
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  /**
+   * Gets all sessions
+   */
+  getSessions(appId) {
+    const sessions = Array.from(this.sessions.values());
+    if (appId) {
+      return sessions.filter((s) => s.appId === appId);
+    }
+    return sessions;
+  }
+  /**
+   * Gets a specific mutation by ID
+   */
+  getMutation(mutationId) {
+    for (const sessionMutations of this.mutations.values()) {
+      const mutation = sessionMutations.find((m) => m.id === mutationId);
+      if (mutation) return mutation;
+    }
+    return void 0;
+  }
+  /**
+   * Queries mutations with filters
+   */
+  queryMutations(options = {}) {
+    let results = [];
+    if (options.sessionId) {
+      const sessionMutations = this.mutations.get(options.sessionId);
+      if (sessionMutations) {
+        results = [...sessionMutations];
+      }
+    } else {
+      for (const sessionMutations of this.mutations.values()) {
+        results.push(...sessionMutations);
+      }
+    }
+    if (options.startTime !== void 0) {
+      results = results.filter((m) => m.timestamp >= options.startTime);
+    }
+    if (options.endTime !== void 0) {
+      results = results.filter((m) => m.timestamp <= options.endTime);
+    }
+    if (options.source) {
+      results = results.filter((m) => m.source === options.source);
+    }
+    if (options.component) {
+      results = results.filter((m) => m.component === options.component);
+    }
+    results.sort((a, b) => {
+      const order = options.sortOrder === "desc" ? -1 : 1;
+      return (a.logicalClock - b.logicalClock) * order;
+    });
+    if (options.offset !== void 0) {
+      results = results.slice(options.offset);
+    }
+    if (options.limit !== void 0) {
+      results = results.slice(0, options.limit);
+    }
+    return results;
+  }
+  /**
+   * Gets the timeline for a session
+   */
+  getTimeline(sessionId) {
+    const mutations = this.mutations.get(sessionId) || [];
+    return [...mutations].sort((a, b) => a.logicalClock - b.logicalClock);
+  }
+  /**
+   * Deletes a session and its mutations
+   */
+  deleteSession(sessionId) {
+    const sessionMutations = this.mutations.get(sessionId);
+    if (sessionMutations) {
+      this.totalMutationCount -= sessionMutations.length;
+    }
+    this.mutations.delete(sessionId);
+    return this.sessions.delete(sessionId);
+  }
+  /**
+   * Clears all data
+   */
+  clear() {
+    this.sessions.clear();
+    this.mutations.clear();
+    this.totalMutationCount = 0;
+    this.log("Store cleared");
+  }
+  /**
+   * Gets store statistics
+   */
+  getStats() {
+    const mutationsPerSession = {};
+    for (const [sessionId, mutations] of this.mutations.entries()) {
+      mutationsPerSession[sessionId] = mutations.length;
+    }
+    return {
+      sessionCount: this.sessions.size,
+      totalMutations: this.totalMutationCount,
+      mutationsPerSession
+    };
+  }
+  /**
+   * Evicts oldest mutations when capacity is exceeded
+   */
+  evictOldestMutations() {
+    let oldestSession = null;
+    let oldestTime = Infinity;
+    for (const [sessionId, session] of this.sessions.entries()) {
+      if (session.startTime.getTime() < oldestTime) {
+        oldestTime = session.startTime.getTime();
+        oldestSession = sessionId;
+      }
+    }
+    if (oldestSession) {
+      const mutations = this.mutations.get(oldestSession);
+      if (mutations && mutations.length > 0) {
+        mutations.shift();
+        this.totalMutationCount--;
+        this.log("Evicted oldest mutation from:", oldestSession);
+      }
+    }
+  }
+  log(...args) {
+    if (this.options.debug) {
+      console.log("[MutationStore]", ...args);
+    }
+  }
+};
+
+// src/recorder/server.ts
+function createRecorderServer(options = {}) {
+  const port = options.port ?? 8080;
+  const wsPort = options.wsPort ?? 8081;
+  const apiPath = options.apiPath ?? "/api";
+  const debug = options.debug ?? false;
+  const store = new MutationStore(options.storeOptions);
+  const reconstructor = new TimelineReconstructor(store);
+  const app = express__default.default();
+  app.use(express__default.default.json({ limit: "10mb" }));
+  if (options.cors !== false) {
+    app.use((_req, res, next) => {
+      res.header("Access-Control-Allow-Origin", "*");
+      res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+      res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
+      next();
+    });
+  }
+  app.use(apiPath, createAPIRoutes(store, reconstructor));
+  app.get("/_surgeon", (_req, res) => {
+    res.send(`
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>State Surgeon Dashboard</title>
+          <style>
+            body { font-family: system-ui, sans-serif; padding: 2rem; background: #1a1a2e; color: #eee; }
+            h1 { color: #00d9ff; }
+            .stats { background: #16213e; padding: 1rem; border-radius: 8px; margin: 1rem 0; }
+            pre { background: #0f0f23; padding: 1rem; border-radius: 4px; overflow: auto; }
+          </style>
+        </head>
+        <body>
+          <h1>\u{1F52C} State Surgeon Dashboard</h1>
+          <p>Recorder is running. Connect your application to start capturing mutations.</p>
+          <div class="stats">
+            <h3>Quick Stats</h3>
+            <div id="stats">Loading...</div>
+          </div>
+          <h3>Recent Sessions</h3>
+          <pre id="sessions">Loading...</pre>
+          <script>
+            async function loadData() {
+              try {
+                const statsRes = await fetch('${apiPath}/stats');
+                const stats = await statsRes.json();
+                document.getElementById('stats').innerHTML =
+                  '<pre>' + JSON.stringify(stats, null, 2) + '</pre>';
+
+                const sessionsRes = await fetch('${apiPath}/sessions');
+                const sessions = await sessionsRes.json();
+                document.getElementById('sessions').textContent =
+                  JSON.stringify(sessions, null, 2);
+              } catch (e) {
+                document.getElementById('stats').textContent = 'Error loading stats';
+              }
+            }
+            loadData();
+            setInterval(loadData, 5000);
+          </script>
+        </body>
+      </html>
+    `);
+  });
+  const httpServer = app.listen(0);
+  httpServer.close();
+  let wss;
+  const clients = /* @__PURE__ */ new Map();
+  function log(...args) {
+    if (debug) {
+      console.log("[State Surgeon Recorder]", ...args);
+    }
+  }
+  function handleMessage(ws, message) {
+    log("Received message:", message.type);
+    switch (message.type) {
+      case "REGISTER_SESSION": {
+        const payload = message.payload;
+        store.registerSession(payload.sessionId, payload.appId, {
+          userAgent: payload.userAgent,
+          url: payload.url
+        });
+        clients.set(ws, { sessionId: payload.sessionId });
+        ws.send(JSON.stringify({
+          type: "SESSION_CONFIRMED",
+          payload: { sessionId: payload.sessionId }
+        }));
+        log("Session registered:", payload.sessionId);
+        break;
+      }
+      case "MUTATION_RECORDED": {
+        const mutation = message.payload;
+        store.storeMutation(mutation);
+        ws.send(JSON.stringify({
+          type: "MUTATION_ACKNOWLEDGED",
+          payload: { mutationId: mutation.id, receivedAt: Date.now() }
+        }));
+        break;
+      }
+      case "MUTATION_BATCH": {
+        const payload = message.payload;
+        store.storeMutations(payload.mutations);
+        ws.send(JSON.stringify({
+          type: "BATCH_ACKNOWLEDGED",
+          payload: { count: payload.mutations.length, receivedAt: Date.now() }
+        }));
+        log("Batch received:", payload.mutations.length, "mutations");
+        break;
+      }
+      case "END_SESSION": {
+        const clientInfo = clients.get(ws);
+        if (clientInfo?.sessionId) {
+          store.endSession(clientInfo.sessionId);
+          log("Session ended:", clientInfo.sessionId);
+        }
+        break;
+      }
+      default:
+        log("Unknown message type:", message.type);
+    }
+  }
+  const server = {
+    app,
+    httpServer: null,
+    wss: null,
+    store,
+    reconstructor,
+    async start() {
+      return new Promise((resolve) => {
+        server.httpServer = app.listen(port, () => {
+          log(`HTTP server listening on port ${port}`);
+        });
+        wss = new ws.WebSocketServer({ port: wsPort });
+        server.wss = wss;
+        wss.on("connection", (ws) => {
+          log("Client connected");
+          clients.set(ws, {});
+          ws.on("message", (data) => {
+            try {
+              const message = JSON.parse(data.toString());
+              handleMessage(ws, message);
+            } catch (error) {
+              log("Error parsing message:", error);
+            }
+          });
+          ws.on("close", () => {
+            const clientInfo = clients.get(ws);
+            if (clientInfo?.sessionId) {
+              store.endSession(clientInfo.sessionId);
+            }
+            clients.delete(ws);
+            log("Client disconnected");
+          });
+          ws.on("error", (error) => {
+            log("WebSocket error:", error);
+          });
+        });
+        wss.on("listening", () => {
+          log(`WebSocket server listening on port ${wsPort}`);
+          resolve();
+        });
+      });
+    },
+    async stop() {
+      return new Promise((resolve) => {
+        for (const ws of clients.keys()) {
+          ws.close();
+        }
+        clients.clear();
+        if (wss) {
+          wss.close(() => {
+            log("WebSocket server closed");
+          });
+        }
+        if (server.httpServer) {
+          server.httpServer.close(() => {
+            log("HTTP server closed");
+            resolve();
+          });
+        } else {
+          resolve();
+        }
+      });
+    }
+  };
+  return server;
+}
+
+exports.MutationStore = MutationStore;
+exports.TimelineReconstructor = TimelineReconstructor;
+exports.createAPIRoutes = createAPIRoutes;
+exports.createRecorderServer = createRecorderServer;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map