@lytjs/devtools-extension 6.4.0 → 6.6.0

package/dist/index.cjs

@@ -0,0 +1,1703 @@
+'use strict';
+
+var reactivity = require('@lytjs/reactivity');
+var commonString = require('@lytjs/common-string');
+
+// src/state.ts
+var devtoolsState = reactivity.signal({
+  enabled: false,
+  connected: false,
+  recording: false
+});
+var stateSubscribers = /* @__PURE__ */ new Set();
+function getState() {
+  return devtoolsState();
+}
+function enable() {
+  devtoolsState.set({ ...devtoolsState(), enabled: true });
+}
+function disable() {
+  devtoolsState.set({ ...devtoolsState(), enabled: false });
+}
+function setConnected(connected) {
+  devtoolsState.set({ ...devtoolsState(), connected });
+}
+function startRecording() {
+  devtoolsState.set({ ...devtoolsState(), recording: true });
+}
+function stopRecording() {
+  devtoolsState.set({ ...devtoolsState(), recording: false });
+}
+function subscribeState(callback) {
+  let isActive2 = true;
+  const stopEffect = reactivity.effect(() => {
+    const currentState = devtoolsState();
+    if (isActive2) {
+      callback(currentState);
+    }
+  });
+  const cleanup = () => {
+    if (isActive2) {
+      isActive2 = false;
+      stateSubscribers.delete(cleanup);
+      stopEffect();
+    }
+  };
+  stateSubscribers.add(cleanup);
+  return cleanup;
+}
+function clearStateSubscribers() {
+  stateSubscribers.forEach((callback) => callback(devtoolsState()));
+  stateSubscribers.clear();
+}
+
+// src/component-tree.ts
+var components = /* @__PURE__ */ new Map();
+var idCounter = 0;
+function generateComponentId() {
+  return `component-${++idCounter}-${Date.now().toString(36)}`;
+}
+function registerComponent(info) {
+  components.set(info.id, info);
+  if (info.parentId) {
+    const parent = components.get(info.parentId);
+    if (parent && !parent.children.includes(info.id)) {
+      parent.children.push(info.id);
+    }
+  }
+}
+function unregisterComponent(id) {
+  const component = components.get(id);
+  if (component?.parentId) {
+    const parent = components.get(component.parentId);
+    if (parent) {
+      parent.children = parent.children.filter((cid) => cid !== id);
+    }
+  }
+  components.delete(id);
+}
+function getComponentById2(id) {
+  return components.get(id);
+}
+function getAllComponents() {
+  return Array.from(components.values());
+}
+function getRootComponents() {
+  return Array.from(components.values()).filter((c) => !c.parentId);
+}
+function clearComponents() {
+  components.clear();
+}
+function getComponentCount() {
+  return components.size;
+}
+function buildComponentTree() {
+  const roots = [];
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const component of components.values()) {
+    const node = {
+      id: component.id,
+      name: component.name,
+      type: "component",
+      children: [],
+      props: component.props || {},
+      emits: [],
+      slots: Object.keys(component.slots || {})
+    };
+    nodeMap.set(component.id, node);
+  }
+  for (const component of components.values()) {
+    const node = nodeMap.get(component.id);
+    if (!node) continue;
+    if (component.parentId) {
+      const parent = nodeMap.get(component.parentId);
+      if (parent) {
+        node.parent = component.parentId;
+        parent.children.push(node);
+      }
+    } else {
+      roots.push(node);
+    }
+  }
+  return roots;
+}
+function getComponentTree() {
+  return buildComponentTree();
+}
+function clearComponentRegistry() {
+  components.clear();
+  idCounter = 0;
+}
+function autoRegisterFromInstance(instance) {
+  const id = generateComponentId();
+  const name = instance.type || instance.name || "Anonymous";
+  const props = {};
+  if (instance.props) {
+    for (const [key, value] of Object.entries(instance.props)) {
+      if (typeof value !== "function") {
+        props[key] = value;
+      }
+    }
+  }
+  const info = {
+    id,
+    name,
+    parentId: instance.parent,
+    children: [],
+    props,
+    slots: instance.slots
+  };
+  registerComponent(info);
+  if (instance.children && Array.isArray(instance.children)) {
+    for (const child of instance.children) {
+      const childId = autoRegisterFromInstance({ ...child, parent: id });
+      if (!info.children.includes(childId)) {
+        info.children.push(childId);
+      }
+    }
+  }
+  return id;
+}
+
+// src/signals.ts
+var signals = /* @__PURE__ */ new Map();
+var signalIdCounter = 0;
+function generateSignalId() {
+  return `signal-${++signalIdCounter}-${Date.now().toString(36)}`;
+}
+function registerSignal(info) {
+  signals.set(info.id, info);
+}
+function unregisterSignal(id) {
+  signals.delete(id);
+}
+function getSignals() {
+  return Array.from(signals.values());
+}
+function getSignalById(id) {
+  return signals.get(id);
+}
+function getSignalValue(id) {
+  const signal2 = signals.get(id);
+  return signal2?.value;
+}
+function setSignalValue(id, value) {
+  const signal2 = signals.get(id);
+  if (!signal2) return false;
+  signal2.value = value;
+  return true;
+}
+function getSignalsByComponent(componentId) {
+  return Array.from(signals.values()).filter((s) => s.componentId === componentId);
+}
+function clearSignals() {
+  signals.clear();
+}
+function clearSignalRegistry() {
+  signals.clear();
+  signalIdCounter = 0;
+}
+
+// src/events.ts
+var events = [];
+var maxEvents = 1e3;
+var isRecording = false;
+var eventSubscribers = [];
+function setMaxEvents(max) {
+  maxEvents = max;
+}
+function recordEvent(typeOrEvent, data) {
+  let record;
+  if (typeof typeOrEvent === "string") {
+    record = {
+      id: `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+      timestamp: Date.now(),
+      type: typeOrEvent,
+      data
+    };
+  } else {
+    record = {
+      ...typeOrEvent,
+      id: `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+      timestamp: Date.now()
+    };
+  }
+  events.push(record);
+  if (events.length > maxEvents) {
+    events.splice(0, events.length - maxEvents);
+  }
+  eventSubscribers.forEach((callback) => {
+    try {
+      callback(record);
+    } catch (e) {
+      console.error("[DevTools Events] Subscriber error:", e);
+    }
+  });
+  return record;
+}
+function getEvents() {
+  return [...events];
+}
+function getEventsByComponent(componentId) {
+  return events.filter((e) => e.componentId === componentId);
+}
+function getEventsByType(type) {
+  return events.filter((e) => e.type === type);
+}
+function clearEvents() {
+  events.length = 0;
+}
+function getEventStats() {
+  const stats = {};
+  events.forEach((e) => {
+    stats[e.type] = (stats[e.type] || 0) + 1;
+  });
+  return stats;
+}
+function startRecording2() {
+  isRecording = true;
+}
+function stopRecording2() {
+  isRecording = false;
+}
+function isEventRecording() {
+  return isRecording;
+}
+function subscribeEvents(callback) {
+  eventSubscribers.push(callback);
+  return () => {
+    const index = eventSubscribers.indexOf(callback);
+    if (index > -1) {
+      eventSubscribers.splice(index, 1);
+    }
+  };
+}
+function getEventCount() {
+  return events.length;
+}
+
+// src/snapshots.ts
+var snapshots = /* @__PURE__ */ new Map();
+var snapshotIdCounter = 0;
+function generateSnapshotId() {
+  return `snapshot-${++snapshotIdCounter}-${Date.now().toString(36)}`;
+}
+function takeSnapshot(components2, signals2, events2) {
+  const snapshot = {
+    id: generateSnapshotId(),
+    timestamp: Date.now(),
+    components: components2 || [],
+    signals: signals2 || [],
+    events: events2 || []
+  };
+  snapshots.set(snapshot.id, snapshot);
+  return snapshot;
+}
+function createSnapshot(id, data, description) {
+  const snapshot = {
+    id,
+    timestamp: Date.now(),
+    components: [],
+    signals: Object.entries(data).map(([name, value]) => ({
+      id: `signal-${name}`,
+      name,
+      type: "signal",
+      value,
+      dependencies: [],
+      dependents: []
+    })),
+    events: description ? [
+      {
+        id: `event-${Date.now()}`,
+        type: "store:mutation",
+        timestamp: Date.now(),
+        payload: { description }
+      }
+    ] : []
+  };
+  snapshots.set(id, snapshot);
+  return snapshot;
+}
+function getSnapshot(id) {
+  return snapshots.get(id);
+}
+function getSnapshotById(id) {
+  return snapshots.get(id);
+}
+function getAllSnapshots() {
+  return Array.from(snapshots.values()).sort((a, b) => a.timestamp - b.timestamp);
+}
+function getSnapshots() {
+  return getAllSnapshots();
+}
+function deleteSnapshot(id) {
+  return snapshots.delete(id);
+}
+function clearSnapshots() {
+  snapshots.clear();
+}
+function exportSnapshots() {
+  return JSON.stringify(getAllSnapshots(), null, 2);
+}
+function importSnapshots(json) {
+  try {
+    const parsed = JSON.parse(json);
+    parsed.forEach((s) => snapshots.set(s.id, s));
+    return parsed;
+  } catch (e) {
+    console.error("[DevTools Snapshots] Import failed:", e);
+    return [];
+  }
+}
+function restoreSnapshot(snapshot) {
+  try {
+    if (!snapshot.signals || snapshot.signals.length === 0) {
+      console.warn("[DevTools Snapshots] No signals to restore in snapshot:", snapshot.id);
+      return true;
+    }
+    let allSuccess = true;
+    for (const signalInfo of snapshot.signals) {
+      try {
+        const success = setSignalValue(signalInfo.id, signalInfo.value);
+        if (!success) {
+          console.warn(
+            `[DevTools Snapshots] Failed to restore signal "${signalInfo.name}" (id: ${signalInfo.id}): not found in registry`
+          );
+          allSuccess = false;
+        }
+      } catch (err) {
+        console.error(`[DevTools Snapshots] Error restoring signal "${signalInfo.name}":`, err);
+        allSuccess = false;
+      }
+    }
+    console.warn("[DevTools Snapshots] Snapshot restored:", snapshot.id);
+    return allSuccess;
+  } catch (e) {
+    console.error("[DevTools Snapshots] Restore failed:", e);
+    return false;
+  }
+}
+
+// src/bridge.ts
+var handlers = /* @__PURE__ */ new Map();
+var genericHandlers = /* @__PURE__ */ new Set();
+var isActive = false;
+function onPanelMessage(typeOrHandler, handler) {
+  if (typeof typeOrHandler === "function") {
+    genericHandlers.add(typeOrHandler);
+    return () => {
+      genericHandlers.delete(typeOrHandler);
+    };
+  }
+  const type = typeOrHandler;
+  if (!handler) {
+    throw new Error("Handler is required when specifying a message type");
+  }
+  if (!handlers.has(type)) {
+    handlers.set(type, /* @__PURE__ */ new Set());
+  }
+  handlers.get(type).add(handler);
+  return () => {
+    handlers.get(type)?.delete(handler);
+  };
+}
+function sendToPanel(message) {
+  const typeHandlers = handlers.get(message.type);
+  if (typeHandlers) {
+    typeHandlers.forEach((handler) => {
+      try {
+        handler(message);
+      } catch (e) {
+        console.error("[DevTools Bridge] Handler error:", e);
+      }
+    });
+  }
+  genericHandlers.forEach((handler) => {
+    try {
+      handler(message);
+    } catch (e) {
+      console.error("[DevTools Bridge] Generic handler error:", e);
+    }
+  });
+}
+function broadcastToPanel(message) {
+  handlers.forEach((typeHandlers, type) => {
+    if (type !== message.type) return;
+    typeHandlers.forEach((handler) => {
+      try {
+        handler(message);
+      } catch (e) {
+        console.error("[DevTools Bridge] Broadcast error:", e);
+      }
+    });
+  });
+  genericHandlers.forEach((handler) => {
+    try {
+      handler(message);
+    } catch (e) {
+      console.error("[DevTools Bridge] Generic broadcast error:", e);
+    }
+  });
+}
+function clearHandlers() {
+  handlers.clear();
+  genericHandlers.clear();
+}
+function activateBridge() {
+  isActive = true;
+}
+function deactivateBridge() {
+  isActive = false;
+}
+function isBridgeActive() {
+  return isActive;
+}
+
+// src/api.ts
+function createDevToolsAPI() {
+  return {
+    getState() {
+      return getState();
+    },
+    enable() {
+      enable();
+    },
+    disable() {
+      disable();
+    },
+    getComponentTree() {
+      return getComponentTree();
+    },
+    getComponentById(id) {
+      return getComponentById2(id);
+    },
+    getSignals() {
+      return getSignals();
+    },
+    getSignalValue(id) {
+      const signalInfo = getSignalById(id);
+      return signalInfo?.value;
+    },
+    startRecording() {
+      startRecording2();
+    },
+    stopRecording() {
+      stopRecording2();
+    },
+    getEvents(filter) {
+      const allEvents = getEvents();
+      if (!filter) return allEvents;
+      return allEvents.filter((e) => filter.includes(e.type));
+    },
+    clearEvents() {
+      clearEvents();
+    },
+    takeSnapshot() {
+      return takeSnapshot();
+    },
+    restoreSnapshot(snapshot) {
+      restoreSnapshot(snapshot);
+    },
+    getSnapshots() {
+      return getSnapshots();
+    },
+    sendToPanel(message) {
+      sendToPanel(message);
+    },
+    onPanelMessage(handler) {
+      return onPanelMessage(handler);
+    }
+  };
+}
+function trackStoreMutation(storeId, type, payload) {
+  if (!isEventRecording()) return;
+  recordEvent("store:mutation", { storeId, mutationType: type, payload });
+}
+function registerStoreSignals(storeId, state) {
+  const signalIds = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(state)) {
+    const id = commonString.generateId("signal");
+    const name = `${storeId}.${key}`;
+    registerSignal({ id, name, type: "signal", value });
+    signalIds.set(key, id);
+  }
+  return signalIds;
+}
+function unregisterStoreSignals(signalIds) {
+  for (const id of signalIds.values()) {
+    unregisterSignal(id);
+  }
+}
+
+// src/router-integration.ts
+function trackRouterNavigation(from, to) {
+  if (!isEventRecording()) return;
+  recordEvent("router:navigation", {
+    from: { path: from.path, fullPath: from.fullPath },
+    to: { path: to.path, fullPath: to.fullPath }
+  });
+}
+
+// src/panel/state-editor.ts
+var editorState = {
+  selectedComponentId: null,
+  expandedPaths: /* @__PURE__ */ new Set(),
+  editHistory: []
+};
+function extractComponentState(componentId) {
+  const component = getComponentById(componentId);
+  if (!component) return null;
+  const state = {};
+  const props = {};
+  for (const [key, value] of Object.entries(component.props || {})) {
+    props[key] = {
+      type: "primitive",
+      value,
+      editable: true,
+      path: `props.${key}`
+    };
+  }
+  const signals2 = getSignals();
+  for (const signal2 of signals2) {
+    if (isSignalBelongsToComponent(
+      signal2,
+      componentId
+    )) {
+      state[signal2.name] = {
+        type: signal2.type,
+        value: signal2.value,
+        editable: signal2.type !== "computed",
+        path: signal2.name
+      };
+    }
+  }
+  return {
+    componentId,
+    componentName: component.name,
+    state,
+    props
+  };
+}
+function isSignalBelongsToComponent(signal2, componentId) {
+  const signalWithMeta = signal2;
+  if (signalWithMeta.componentId === componentId) {
+    return true;
+  }
+  const component = getComponentById(componentId);
+  if (component && signal2.name.startsWith(`${component.name}_`)) {
+    return true;
+  }
+  return false;
+}
+function applyStateEdit(componentId, path, value) {
+  try {
+    const oldValue = getStateValue(componentId, path);
+    const signalId = findSignalIdForPath(componentId, path);
+    if (!signalId) {
+      return {
+        success: false,
+        error: `Signal not found for path: ${path}`
+      };
+    }
+    const success = setSignalValue(signalId, value);
+    if (!success) {
+      return {
+        success: false,
+        error: "Failed to set signal value"
+      };
+    }
+    const record = {
+      id: `edit-${Date.now()}`,
+      timestamp: Date.now(),
+      componentId,
+      path,
+      oldValue,
+      newValue: value
+    };
+    editorState.editHistory.push(record);
+    recordEvent("signal:changed", {
+      signalId,
+      path,
+      oldValue,
+      newValue: value,
+      componentId
+    });
+    sendToPanel({
+      type: "STATE_EDITED",
+      payload: {
+        componentId,
+        path,
+        oldValue,
+        newValue: value,
+        timestamp: record.timestamp
+      }
+    });
+    return {
+      success: true,
+      oldValue,
+      newValue: value
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function getStateValue(componentId, path) {
+  const componentState = extractComponentState(componentId);
+  if (!componentState) return void 0;
+  const parts = path.split(".");
+  let current = componentState.state;
+  for (const part of parts) {
+    if (current && typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function findSignalIdForPath(componentId, path) {
+  const signals2 = getSignals();
+  const component = getComponentById(componentId);
+  for (const signal2 of signals2) {
+    if (isSignalBelongsToComponent(
+      signal2,
+      componentId
+    )) {
+      const stateName = component ? signal2.name.substring(component.name.length + 1) : signal2.name;
+      if (stateName === path || signal2.name === path) {
+        return signal2.id;
+      }
+    }
+  }
+  return null;
+}
+function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current) || typeof current[part] !== "object") {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const lastPart = parts[parts.length - 1];
+  current[lastPart] = value;
+  return true;
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current && typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function parseValue(input, targetType) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed === "true" || trimmed === "false" || trimmed === "null" || /^-?\d+(\.\d+)?$/.test(trimmed)) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+    }
+  }
+  switch (targetType) {
+    case "number":
+      return parseFloat(trimmed) || 0;
+    case "boolean":
+      return trimmed === "true" || trimmed === "1";
+    case "string":
+    default:
+      return trimmed;
+  }
+}
+function formatValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return `"${value}"`;
+  if (typeof value === "function") return "\u0192()";
+  if (Array.isArray(value)) return `Array(${value.length})`;
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return "{...}";
+    }
+  }
+  return String(value);
+}
+function getEditHistory() {
+  return [...editorState.editHistory];
+}
+function clearEditHistory() {
+  editorState.editHistory = [];
+}
+function undoLastEdit() {
+  const lastEdit = editorState.editHistory.pop();
+  if (!lastEdit) {
+    return { success: false, error: "No edits to undo" };
+  }
+  return applyStateEdit(lastEdit.componentId, lastEdit.path, lastEdit.oldValue);
+}
+function initStateEditor() {
+  const unsubscribe = onPanelMessage((message) => {
+    const msg = message;
+    switch (msg.type) {
+      case "GET_COMPONENT_STATE":
+        handleGetComponentState(msg.data);
+        break;
+      case "EDIT_STATE":
+        handleEditState(msg.data);
+        break;
+      case "GET_EDIT_HISTORY":
+        sendToPanel({
+          type: "EDIT_HISTORY",
+          payload: getEditHistory()
+        });
+        break;
+      case "UNDO_LAST_EDIT":
+        handleUndoLastEdit();
+        break;
+    }
+  });
+  return unsubscribe;
+}
+function handleGetComponentState(data) {
+  if (!data?.componentId) return;
+  const state = extractComponentState(data.componentId);
+  sendToPanel({
+    type: "COMPONENT_STATE",
+    payload: state
+  });
+}
+function handleEditState(data) {
+  if (!data) return;
+  const result = applyStateEdit(data.componentId, data.path, data.value);
+  sendToPanel({
+    type: "STATE_EDIT_RESULT",
+    payload: {
+      ...result,
+      componentId: data.componentId,
+      path: data.path
+    }
+  });
+}
+function handleUndoLastEdit() {
+  const result = undoLastEdit();
+  sendToPanel({
+    type: "UNDO_RESULT",
+    payload: result
+  });
+}
+
+// src/panel/time-travel.ts
+var timeTravelState = {
+  isRecording: false,
+  currentIndex: -1,
+  history: [],
+  maxHistorySize: 1e3
+};
+var recordingStartTime = 0;
+var unsubscribeEvents = null;
+function startHistoryRecording() {
+  if (timeTravelState.isRecording) return;
+  timeTravelState.isRecording = true;
+  recordingStartTime = Date.now();
+  unsubscribeEvents = subscribeEvents((event) => {
+    const eventWithPayload = event;
+    addHistoryEntry({
+      type: "event",
+      description: formatEventDescription(eventWithPayload),
+      data: { event: eventWithPayload }
+    });
+  });
+  const snapshot = takeSnapshot();
+  addHistoryEntry({
+    type: "snapshot",
+    description: "Initial state",
+    data: { snapshot }
+  });
+  sendToPanel({
+    type: "TIME_TRAVEL_STATUS",
+    payload: { isRecording: true, currentIndex: timeTravelState.currentIndex }
+  });
+}
+function stopHistoryRecording() {
+  if (!timeTravelState.isRecording) return;
+  timeTravelState.isRecording = false;
+  if (unsubscribeEvents) {
+    unsubscribeEvents();
+    unsubscribeEvents = null;
+  }
+  sendToPanel({
+    type: "TIME_TRAVEL_STATUS",
+    payload: { isRecording: false, currentIndex: timeTravelState.currentIndex }
+  });
+}
+function addHistoryEntry(entry) {
+  const historyEntry = {
+    ...entry,
+    id: `history-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+    timestamp: Date.now(),
+    index: timeTravelState.history.length
+  };
+  timeTravelState.history.push(historyEntry);
+  if (timeTravelState.history.length > timeTravelState.maxHistorySize) {
+    timeTravelState.history.shift();
+    timeTravelState.history.forEach((h, i) => {
+      h.index = i;
+    });
+  }
+  timeTravelState.currentIndex = timeTravelState.history.length - 1;
+  sendToPanel({
+    type: "HISTORY_UPDATED",
+    payload: {
+      entry: historyEntry,
+      totalEntries: timeTravelState.history.length,
+      currentIndex: timeTravelState.currentIndex
+    }
+  });
+}
+function formatEventDescription(event) {
+  switch (event.type) {
+    case "component:created":
+      return `Component created: ${event.payload?.name || "Unknown"}`;
+    case "component:mounted":
+      return `Component mounted: ${event.payload?.name || "Unknown"}`;
+    case "component:updated":
+      return `Component updated: ${event.payload?.name || "Unknown"}`;
+    case "component:unmounted":
+      return `Component unmounted: ${event.payload?.name || "Unknown"}`;
+    case "signal:changed":
+      return `State changed: ${event.payload?.path || "Unknown"}`;
+    case "store:mutation":
+      return `Store mutation: ${event.payload?.type || "Unknown"}`;
+    case "router:navigation":
+      return `Navigation: ${event.payload?.to || "Unknown"}`;
+    case "error:captured":
+      return `Error: ${event.payload?.message || "Unknown"}`;
+    default:
+      return `Event: ${event.type}`;
+  }
+}
+function jumpToHistory(index) {
+  if (index < 0 || index >= timeTravelState.history.length) {
+    return false;
+  }
+  const entry = timeTravelState.history[index];
+  timeTravelState.currentIndex = index;
+  if (entry.data.snapshot) {
+    restoreSnapshot(entry.data.snapshot);
+  } else if (entry.data.event?.type === "signal:changed") {
+    const payload = entry.data.event.payload;
+    if (payload?.signalId && payload?.newValue !== void 0) {
+      setSignalValue(payload.signalId, payload.newValue);
+    }
+  }
+  sendToPanel({
+    type: "TIME_TRAVEL_JUMP",
+    payload: {
+      index,
+      entry,
+      canGoBack: index > 0,
+      canGoForward: index < timeTravelState.history.length - 1
+    }
+  });
+  return true;
+}
+function goBack() {
+  if (timeTravelState.currentIndex <= 0) {
+    return false;
+  }
+  return jumpToHistory(timeTravelState.currentIndex - 1);
+}
+function goForward() {
+  if (timeTravelState.currentIndex >= timeTravelState.history.length - 1) {
+    return false;
+  }
+  return jumpToHistory(timeTravelState.currentIndex + 1);
+}
+function goToStart() {
+  if (timeTravelState.history.length === 0) {
+    return false;
+  }
+  return jumpToHistory(0);
+}
+function goToEnd() {
+  if (timeTravelState.history.length === 0) {
+    return false;
+  }
+  return jumpToHistory(timeTravelState.history.length - 1);
+}
+function getHistory() {
+  return [...timeTravelState.history];
+}
+function getCurrentIndex() {
+  return timeTravelState.currentIndex;
+}
+function clearHistory() {
+  timeTravelState.history = [];
+  timeTravelState.currentIndex = -1;
+  clearEvents();
+  sendToPanel({
+    type: "HISTORY_CLEARED",
+    payload: {}
+  });
+}
+function exportHistory() {
+  const exportData = {
+    version: "1.0.0",
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    history: timeTravelState.history,
+    snapshots: getSnapshots(),
+    metadata: {
+      totalEvents: timeTravelState.history.filter((h) => h.type === "event").length,
+      recordingDuration: recordingStartTime ? Date.now() - recordingStartTime : 0
+    }
+  };
+  return JSON.stringify(exportData, null, 2);
+}
+function importHistory(json) {
+  try {
+    const data = JSON.parse(json);
+    if (!data.version || !data.history) {
+      throw new Error("Invalid export format");
+    }
+    clearHistory();
+    timeTravelState.history = data.history.map((h, i) => ({
+      ...h,
+      index: i
+    }));
+    timeTravelState.currentIndex = timeTravelState.history.length - 1;
+    sendToPanel({
+      type: "HISTORY_IMPORTED",
+      payload: {
+        totalEntries: timeTravelState.history.length,
+        currentIndex: timeTravelState.currentIndex
+      }
+    });
+    return true;
+  } catch (error) {
+    sendToPanel({
+      type: "HISTORY_IMPORT_ERROR",
+      payload: { error: error instanceof Error ? error.message : String(error) }
+    });
+    return false;
+  }
+}
+function downloadHistory(filename) {
+  if (typeof document === "undefined" || typeof Blob === "undefined" || typeof URL === "undefined") {
+    console.warn("[DevTools TimeTravel] downloadHistory is only available in browser environment");
+    return;
+  }
+  const data = exportHistory();
+  const blob = new Blob([data], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename || `lytjs-history-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.json`;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}
+function compareSnapshots(snapshot1, snapshot2) {
+  const diffs = [];
+  const signals1 = new Map(snapshot1.signals.map((s) => [s.id, s]));
+  const signals2 = new Map(snapshot2.signals.map((s) => [s.id, s]));
+  for (const [id, signal2] of signals2) {
+    const signal1 = signals1.get(id);
+    if (!signal1) {
+      diffs.push({
+        path: `signals.${signal2.name}`,
+        oldValue: void 0,
+        newValue: signal2.value
+      });
+    } else if (JSON.stringify(signal1.value) !== JSON.stringify(signal2.value)) {
+      diffs.push({
+        path: `signals.${signal2.name}`,
+        oldValue: signal1.value,
+        newValue: signal2.value
+      });
+    }
+  }
+  for (const [id, signal1] of signals1) {
+    if (!signals2.has(id)) {
+      diffs.push({
+        path: `signals.${signal1.name}`,
+        oldValue: signal1.value,
+        newValue: void 0
+      });
+    }
+  }
+  return diffs;
+}
+function getStateDiffForEntry(index) {
+  if (index <= 0 || index >= timeTravelState.history.length) {
+    return [];
+  }
+  const currentEntry = timeTravelState.history[index];
+  const previousEntry = timeTravelState.history[index - 1];
+  if (currentEntry.data.snapshot && previousEntry.data.snapshot) {
+    return compareSnapshots(previousEntry.data.snapshot, currentEntry.data.snapshot);
+  }
+  return currentEntry.data.stateDiff || [];
+}
+function initTimeTravel() {
+  const unsubscribe = onPanelMessage((message) => {
+    const msg = message;
+    switch (msg.type) {
+      case "START_TIME_TRAVEL_RECORDING":
+        startHistoryRecording();
+        break;
+      case "STOP_TIME_TRAVEL_RECORDING":
+        stopHistoryRecording();
+        break;
+      case "JUMP_TO_HISTORY":
+        handleJumpToHistory(msg.data);
+        break;
+      case "GO_BACK":
+        handleGoBack();
+        break;
+      case "GO_FORWARD":
+        handleGoForward();
+        break;
+      case "GO_TO_START":
+        handleGoToStart();
+        break;
+      case "GO_TO_END":
+        handleGoToEnd();
+        break;
+      case "GET_HISTORY":
+        sendToPanel({
+          type: "HISTORY_LIST",
+          payload: {
+            history: getHistory(),
+            currentIndex: getCurrentIndex(),
+            isRecording: timeTravelState.isRecording
+          }
+        });
+        break;
+      case "CLEAR_HISTORY":
+        clearHistory();
+        break;
+      case "EXPORT_HISTORY":
+        handleExportHistory();
+        break;
+      case "IMPORT_HISTORY":
+        handleImportHistory(msg.data);
+        break;
+      case "GET_STATE_DIFF":
+        handleGetStateDiff(msg.data);
+        break;
+    }
+  });
+  return unsubscribe;
+}
+function handleJumpToHistory(data) {
+  if (data) {
+    const success = jumpToHistory(data.index);
+    sendToPanel({
+      type: "JUMP_RESULT",
+      payload: { success, index: data.index }
+    });
+  }
+}
+function handleGoBack() {
+  const success = goBack();
+  sendToPanel({
+    type: "NAVIGATION_RESULT",
+    payload: { direction: "back", success, currentIndex: getCurrentIndex() }
+  });
+}
+function handleGoForward() {
+  const success = goForward();
+  sendToPanel({
+    type: "NAVIGATION_RESULT",
+    payload: { direction: "forward", success, currentIndex: getCurrentIndex() }
+  });
+}
+function handleGoToStart() {
+  const success = goToStart();
+  sendToPanel({
+    type: "NAVIGATION_RESULT",
+    payload: { direction: "start", success, currentIndex: getCurrentIndex() }
+  });
+}
+function handleGoToEnd() {
+  const success = goToEnd();
+  sendToPanel({
+    type: "NAVIGATION_RESULT",
+    payload: { direction: "end", success, currentIndex: getCurrentIndex() }
+  });
+}
+function handleExportHistory() {
+  const data = exportHistory();
+  sendToPanel({
+    type: "HISTORY_EXPORTED",
+    payload: { json: data }
+  });
+}
+function handleImportHistory(data) {
+  if (data?.json) {
+    const success = importHistory(data.json);
+    sendToPanel({
+      type: "HISTORY_IMPORT_RESULT",
+      payload: { success }
+    });
+  }
+}
+function handleGetStateDiff(data) {
+  if (data) {
+    const diffs = getStateDiffForEntry(data.index);
+    sendToPanel({
+      type: "STATE_DIFF",
+      payload: { index: data.index, diffs }
+    });
+  }
+}
+
+// src/panel/performance.ts
+var performanceConfig = {
+  maxRenderHistory: 50,
+  slowRenderThreshold: 16,
+  // 60fps = 16.67ms per frame
+  timelineMaxSize: 100,
+  updateInterval: 1e3
+};
+var componentPerformanceMap = /* @__PURE__ */ new Map();
+var performanceTimeline = [];
+var isMonitoring = false;
+var updateIntervalId = null;
+var frameCount = 0;
+var lastFpsUpdate = 0;
+var currentFps = 0;
+function recordComponentRender(componentId, componentName, renderTime) {
+  if (!isMonitoring) return;
+  const existing = componentPerformanceMap.get(componentId);
+  const now = Date.now();
+  if (existing) {
+    existing.renderCount++;
+    existing.totalRenderTime += renderTime;
+    existing.averageRenderTime = existing.totalRenderTime / existing.renderCount;
+    existing.lastRenderTime = renderTime;
+    existing.minRenderTime = Math.min(existing.minRenderTime, renderTime);
+    existing.maxRenderTime = Math.max(existing.maxRenderTime, renderTime);
+    existing.lastRenderTimestamp = now;
+    existing.renderTimes.push(renderTime);
+    if (existing.renderTimes.length > performanceConfig.maxRenderHistory) {
+      existing.renderTimes.shift();
+    }
+    existing.updateFrequency = calculateUpdateFrequency(existing);
+  } else {
+    const performance2 = {
+      componentId,
+      componentName,
+      renderCount: 1,
+      totalRenderTime: renderTime,
+      averageRenderTime: renderTime,
+      lastRenderTime: renderTime,
+      minRenderTime: renderTime,
+      maxRenderTime: renderTime,
+      renderTimes: [renderTime],
+      lastRenderTimestamp: now,
+      updateFrequency: "low"
+    };
+    componentPerformanceMap.set(componentId, performance2);
+  }
+  if (renderTime > performanceConfig.slowRenderThreshold) {
+    recordEvent("error:captured", {
+      type: "slow-render",
+      componentId,
+      componentName,
+      renderTime
+    });
+  }
+}
+function calculateUpdateFrequency(performance2) {
+  const recentRenders = performance2.renderTimes.length;
+  const avgTime = performance2.averageRenderTime;
+  if (recentRenders > 30 || avgTime > 50) return "extreme";
+  if (recentRenders > 15 || avgTime > 30) return "high";
+  if (recentRenders > 5 || avgTime > 16) return "medium";
+  return "low";
+}
+function getComponentPerformance(componentId) {
+  return componentPerformanceMap.get(componentId);
+}
+function getAllComponentPerformance() {
+  return Array.from(componentPerformanceMap.values());
+}
+function clearComponentPerformance() {
+  componentPerformanceMap.clear();
+}
+function startPerformanceMonitoring() {
+  if (isMonitoring) return;
+  isMonitoring = true;
+  lastFpsUpdate = performance.now();
+  frameCount = 0;
+  if (typeof requestAnimationFrame !== "undefined") {
+    requestAnimationFrame(updateFps);
+  }
+  updateIntervalId = setInterval(() => {
+    updatePerformanceMetrics();
+  }, performanceConfig.updateInterval);
+  sendToPanel({
+    type: "PERFORMANCE_MONITORING_STATUS",
+    payload: { isMonitoring: true }
+  });
+}
+function stopPerformanceMonitoring() {
+  if (!isMonitoring) return;
+  isMonitoring = false;
+  if (updateIntervalId) {
+    clearInterval(updateIntervalId);
+    updateIntervalId = null;
+  }
+  sendToPanel({
+    type: "PERFORMANCE_MONITORING_STATUS",
+    payload: { isMonitoring: false }
+  });
+}
+function isPerformanceMonitoring() {
+  return isMonitoring;
+}
+function updateFps() {
+  if (!isMonitoring) return;
+  frameCount++;
+  const now = performance.now();
+  if (now - lastFpsUpdate >= 1e3) {
+    currentFps = Math.round(frameCount * 1e3 / (now - lastFpsUpdate));
+    frameCount = 0;
+    lastFpsUpdate = now;
+  }
+  if (typeof requestAnimationFrame !== "undefined") {
+    requestAnimationFrame(updateFps);
+  }
+}
+function updatePerformanceMetrics() {
+  if (!isMonitoring) return;
+  const metrics = collectPerformanceMetrics();
+  const slowRenders = findSlowRenders();
+  const entry = {
+    timestamp: Date.now(),
+    metrics,
+    slowRenders
+  };
+  performanceTimeline.push(entry);
+  if (performanceTimeline.length > performanceConfig.timelineMaxSize) {
+    performanceTimeline.shift();
+  }
+  sendToPanel({
+    type: "PERFORMANCE_METRICS",
+    payload: {
+      metrics,
+      slowRenders,
+      timeline: getPerformanceTimelineSummary()
+    }
+  });
+}
+function collectPerformanceMetrics() {
+  const components2 = getAllComponentPerformance();
+  const totalRenders = components2.reduce((sum, c) => sum + c.renderCount, 0);
+  const avgRenderTime = components2.length > 0 ? components2.reduce((sum, c) => sum + c.averageRenderTime, 0) / components2.length : 0;
+  return {
+    timestamp: Date.now(),
+    totalComponents: components2.length,
+    totalRenders,
+    averageRenderTime: Math.round(avgRenderTime * 100) / 100,
+    memoryUsage: getMemoryInfo(),
+    fps: currentFps
+  };
+}
+function getMemoryInfo() {
+  const perf = performance;
+  if (typeof performance !== "undefined" && perf.memory) {
+    const mem = perf.memory;
+    return {
+      usedJSHeapSize: mem.usedJSHeapSize,
+      totalJSHeapSize: mem.totalJSHeapSize,
+      jsHeapSizeLimit: mem.jsHeapSizeLimit
+    };
+  }
+  return void 0;
+}
+function findSlowRenders() {
+  const slowRenders = [];
+  for (const perf of componentPerformanceMap.values()) {
+    if (perf.lastRenderTime > performanceConfig.slowRenderThreshold) {
+      slowRenders.push({
+        componentId: perf.componentId,
+        componentName: perf.componentName,
+        renderTime: perf.lastRenderTime,
+        timestamp: perf.lastRenderTimestamp
+      });
+    }
+  }
+  return slowRenders.sort((a, b) => b.renderTime - a.renderTime).slice(0, 10);
+}
+function getRenderHeatmap() {
+  const components2 = getAllComponentPerformance();
+  if (components2.length === 0) return [];
+  const maxRenders = Math.max(...components2.map((c) => c.renderCount), 1);
+  const maxAvgTime = Math.max(...components2.map((c) => c.averageRenderTime), 1);
+  return components2.map((c) => {
+    const countIntensity = c.renderCount / maxRenders;
+    const timeIntensity = Math.min(c.averageRenderTime / maxAvgTime, 1);
+    const intensity = countIntensity * 0.5 + timeIntensity * 0.5;
+    return {
+      componentId: c.componentId,
+      componentName: c.componentName,
+      intensity: Math.round(intensity * 100) / 100,
+      renderCount: c.renderCount,
+      frequency: c.updateFrequency
+    };
+  }).sort((a, b) => b.intensity - a.intensity);
+}
+function getPerformanceTimeline() {
+  return [...performanceTimeline];
+}
+function getPerformanceTimelineSummary() {
+  return {
+    timestamps: performanceTimeline.map((e) => e.timestamp),
+    fps: performanceTimeline.map((e) => e.metrics.fps || 0),
+    memory: performanceTimeline.map((e) => e.metrics.memoryUsage?.usedJSHeapSize || 0),
+    renderCounts: performanceTimeline.map((e) => e.metrics.totalRenders)
+  };
+}
+function clearPerformanceTimeline() {
+  performanceTimeline.length = 0;
+}
+function getMemoryTrend() {
+  const entries = performanceTimeline.filter((e) => e.metrics.memoryUsage);
+  return {
+    timestamps: entries.map((e) => e.timestamp),
+    used: entries.map((e) => e.metrics.memoryUsage.usedJSHeapSize / 1024 / 1024),
+    // MB
+    total: entries.map((e) => e.metrics.memoryUsage.totalJSHeapSize / 1024 / 1024),
+    // MB
+    limit: entries.map((e) => e.metrics.memoryUsage.jsHeapSizeLimit / 1024 / 1024)
+    // MB
+  };
+}
+function suggestGarbageCollection() {
+  const globalWithGC = globalThis;
+  if (typeof globalWithGC.gc === "function") {
+    try {
+      globalWithGC.gc();
+      sendToPanel({
+        type: "GC_SUGGESTED",
+        payload: { success: true }
+      });
+    } catch (e) {
+      sendToPanel({
+        type: "GC_SUGGESTED",
+        payload: { success: false, error: String(e) }
+      });
+    }
+  } else {
+    sendToPanel({
+      type: "GC_SUGGESTED",
+      payload: { success: false, error: "GC not available" }
+    });
+  }
+}
+function updatePerformanceConfig(config) {
+  Object.assign(performanceConfig, config);
+  sendToPanel({
+    type: "PERFORMANCE_CONFIG_UPDATED",
+    payload: performanceConfig
+  });
+}
+function getPerformanceConfig() {
+  return { ...performanceConfig };
+}
+function initPerformancePanel() {
+  const unsubscribe = onPanelMessage((message) => {
+    const msg = message;
+    switch (msg.type) {
+      case "START_PERFORMANCE_MONITORING":
+        startPerformanceMonitoring();
+        break;
+      case "STOP_PERFORMANCE_MONITORING":
+        stopPerformanceMonitoring();
+        break;
+      case "GET_PERFORMANCE_METRICS":
+        handleGetPerformanceMetrics();
+        break;
+      case "GET_RENDER_HEATMAP":
+        handleGetRenderHeatmap();
+        break;
+      case "GET_COMPONENT_PERFORMANCE":
+        handleGetComponentPerformance(msg.data);
+        break;
+      case "GET_PERFORMANCE_TIMELINE":
+        handleGetPerformanceTimeline();
+        break;
+      case "GET_MEMORY_TREND":
+        handleGetMemoryTrend();
+        break;
+      case "CLEAR_PERFORMANCE_DATA":
+        clearComponentPerformance();
+        clearPerformanceTimeline();
+        sendToPanel({ type: "PERFORMANCE_DATA_CLEARED", payload: {} });
+        break;
+      case "SUGGEST_GC":
+        suggestGarbageCollection();
+        break;
+      case "UPDATE_PERFORMANCE_CONFIG":
+        if (msg.data) {
+          updatePerformanceConfig(msg.data);
+        }
+        break;
+      case "GET_PERFORMANCE_CONFIG":
+        sendToPanel({
+          type: "PERFORMANCE_CONFIG",
+          payload: getPerformanceConfig()
+        });
+        break;
+    }
+  });
+  return unsubscribe;
+}
+function handleGetPerformanceMetrics() {
+  const metrics = collectPerformanceMetrics();
+  const slowRenders = findSlowRenders();
+  sendToPanel({
+    type: "PERFORMANCE_METRICS",
+    payload: {
+      metrics,
+      slowRenders,
+      isMonitoring
+    }
+  });
+}
+function handleGetRenderHeatmap() {
+  const heatmap = getRenderHeatmap();
+  sendToPanel({
+    type: "RENDER_HEATMAP",
+    payload: heatmap
+  });
+}
+function handleGetComponentPerformance(data) {
+  if (!data?.componentId) return;
+  const performance2 = getComponentPerformance(data.componentId);
+  sendToPanel({
+    type: "COMPONENT_PERFORMANCE",
+    payload: performance2
+  });
+}
+function handleGetPerformanceTimeline() {
+  sendToPanel({
+    type: "PERFORMANCE_TIMELINE",
+    payload: getPerformanceTimelineSummary()
+  });
+}
+function handleGetMemoryTrend() {
+  sendToPanel({
+    type: "MEMORY_TREND",
+    payload: getMemoryTrend()
+  });
+}
+
+// src/panel/index.ts
+var panelState = {
+  isInitialized: false,
+  activeTab: "components",
+  selectedComponentId: null,
+  isRecording: false
+};
+var cleanupFunctions = [];
+function initDevToolsPanel() {
+  if (panelState.isInitialized) return;
+  enable();
+  setConnected(true);
+  cleanupFunctions.push(initStateEditor());
+  cleanupFunctions.push(initTimeTravel());
+  cleanupFunctions.push(initPerformancePanel());
+  cleanupFunctions.push(initPanelMessageHandler());
+  panelState.isInitialized = true;
+  sendInitialData();
+}
+function cleanupDevToolsPanel() {
+  if (!panelState.isInitialized) return;
+  cleanupFunctions.forEach((cleanup) => cleanup());
+  cleanupFunctions.length = 0;
+  setConnected(false);
+  panelState.isInitialized = false;
+}
+function initPanelMessageHandler() {
+  return onPanelMessage((message) => {
+    const msg = message;
+    switch (msg.type) {
+      case "SWITCH_TAB":
+        if (msg.data && typeof msg.data === "object") {
+          panelState.activeTab = msg.data.tab;
+        }
+        break;
+      case "SELECT_COMPONENT":
+        if (msg.data && typeof msg.data === "object") {
+          panelState.selectedComponentId = msg.data.componentId;
+        }
+        break;
+      case "START_RECORDING":
+        panelState.isRecording = true;
+        startRecording2();
+        break;
+      case "STOP_RECORDING":
+        panelState.isRecording = false;
+        stopRecording2();
+        break;
+      case "REFRESH_DATA":
+      case "GET_ALL_DATA":
+        sendInitialData();
+        break;
+    }
+  });
+}
+function sendInitialData() {
+  sendToPanel({
+    type: "INITIAL_DATA",
+    payload: {
+      state: getState(),
+      componentTree: getComponentTree(),
+      signals: getSignals(),
+      snapshots: getSnapshots(),
+      events: getEvents()
+    }
+  });
+}
+function getPanelState() {
+  return { ...panelState };
+}
+function isPanelInitialized() {
+  return panelState.isInitialized;
+}
+function setActiveTab(tab) {
+  panelState.activeTab = tab;
+}
+function getActiveTab() {
+  return panelState.activeTab;
+}
+
+exports.activateBridge = activateBridge;
+exports.applyStateEdit = applyStateEdit;
+exports.autoRegisterFromInstance = autoRegisterFromInstance;
+exports.broadcastToPanel = broadcastToPanel;
+exports.buildComponentTree = buildComponentTree;
+exports.cleanupDevToolsPanel = cleanupDevToolsPanel;
+exports.clearComponentPerformance = clearComponentPerformance;
+exports.clearComponentRegistry = clearComponentRegistry;
+exports.clearComponents = clearComponents;
+exports.clearEditHistory = clearEditHistory;
+exports.clearEvents = clearEvents;
+exports.clearHandlers = clearHandlers;
+exports.clearHistory = clearHistory;
+exports.clearPerformanceTimeline = clearPerformanceTimeline;
+exports.clearSignalRegistry = clearSignalRegistry;
+exports.clearSignals = clearSignals;
+exports.clearSnapshots = clearSnapshots;
+exports.clearStateSubscribers = clearStateSubscribers;
+exports.compareSnapshots = compareSnapshots;
+exports.createDevToolsAPI = createDevToolsAPI;
+exports.createSnapshot = createSnapshot;
+exports.deactivateBridge = deactivateBridge;
+exports.deleteSnapshot = deleteSnapshot;
+exports.disable = disable;
+exports.downloadHistory = downloadHistory;
+exports.enable = enable;
+exports.exportHistory = exportHistory;
+exports.exportSnapshots = exportSnapshots;
+exports.extractComponentState = extractComponentState;
+exports.formatValue = formatValue;
+exports.generateComponentId = generateComponentId;
+exports.generateSignalId = generateSignalId;
+exports.getActiveTab = getActiveTab;
+exports.getAllComponentPerformance = getAllComponentPerformance;
+exports.getAllComponents = getAllComponents;
+exports.getAllSnapshots = getAllSnapshots;
+exports.getComponentById = getComponentById2;
+exports.getComponentCount = getComponentCount;
+exports.getComponentPerformance = getComponentPerformance;
+exports.getComponentTree = getComponentTree;
+exports.getCurrentIndex = getCurrentIndex;
+exports.getEditHistory = getEditHistory;
+exports.getEventCount = getEventCount;
+exports.getEventStats = getEventStats;
+exports.getEvents = getEvents;
+exports.getEventsByComponent = getEventsByComponent;
+exports.getEventsByType = getEventsByType;
+exports.getHistory = getHistory;
+exports.getMemoryTrend = getMemoryTrend;
+exports.getNestedValue = getNestedValue;
+exports.getPanelState = getPanelState;
+exports.getPerformanceConfig = getPerformanceConfig;
+exports.getPerformanceTimeline = getPerformanceTimeline;
+exports.getRenderHeatmap = getRenderHeatmap;
+exports.getRootComponents = getRootComponents;
+exports.getSignalById = getSignalById;
+exports.getSignalValue = getSignalValue;
+exports.getSignals = getSignals;
+exports.getSignalsByComponent = getSignalsByComponent;
+exports.getSnapshot = getSnapshot;
+exports.getSnapshotById = getSnapshotById;
+exports.getSnapshots = getSnapshots;
+exports.getState = getState;
+exports.getStateDiffForEntry = getStateDiffForEntry;
+exports.goBack = goBack;
+exports.goForward = goForward;
+exports.goToEnd = goToEnd;
+exports.goToStart = goToStart;
+exports.importHistory = importHistory;
+exports.importSnapshots = importSnapshots;
+exports.initDevToolsPanel = initDevToolsPanel;
+exports.initPerformancePanel = initPerformancePanel;
+exports.initStateEditor = initStateEditor;
+exports.initTimeTravel = initTimeTravel;
+exports.isBridgeActive = isBridgeActive;
+exports.isEventRecording = isEventRecording;
+exports.isPanelInitialized = isPanelInitialized;
+exports.isPerformanceMonitoring = isPerformanceMonitoring;
+exports.jumpToHistory = jumpToHistory;
+exports.onPanelMessage = onPanelMessage;
+exports.parseValue = parseValue;
+exports.recordComponentRender = recordComponentRender;
+exports.recordEvent = recordEvent;
+exports.registerComponent = registerComponent;
+exports.registerSignal = registerSignal;
+exports.registerStoreSignals = registerStoreSignals;
+exports.restoreSnapshot = restoreSnapshot;
+exports.sendToPanel = sendToPanel;
+exports.setActiveTab = setActiveTab;
+exports.setConnected = setConnected;
+exports.setMaxEvents = setMaxEvents;
+exports.setNestedValue = setNestedValue;
+exports.setSignalValue = setSignalValue;
+exports.startEventRecording = startRecording2;
+exports.startHistoryRecording = startHistoryRecording;
+exports.startPerformanceMonitoring = startPerformanceMonitoring;
+exports.startStateRecording = startRecording;
+exports.stopEventRecording = stopRecording2;
+exports.stopHistoryRecording = stopHistoryRecording;
+exports.stopPerformanceMonitoring = stopPerformanceMonitoring;
+exports.stopStateRecording = stopRecording;
+exports.subscribeEvents = subscribeEvents;
+exports.subscribeState = subscribeState;
+exports.suggestGarbageCollection = suggestGarbageCollection;
+exports.takeSnapshot = takeSnapshot;
+exports.trackRouterNavigation = trackRouterNavigation;
+exports.trackStoreMutation = trackStoreMutation;
+exports.undoLastEdit = undoLastEdit;
+exports.unregisterComponent = unregisterComponent;
+exports.unregisterSignal = unregisterSignal;
+exports.unregisterStoreSignals = unregisterStoreSignals;
+exports.updatePerformanceConfig = updatePerformanceConfig;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map