@vobs/devtools 1.0.0 → 1.2.0

package/dist/index.js

@@ -0,0 +1,1837 @@
+import 'axios';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// packages/reactivity/src/debug.ts
+var activeDebugHooks = null;
+var signalNames = /* @__PURE__ */ new WeakMap();
+function setDebugHooks(hooks) {
+  const previous = activeDebugHooks;
+  activeDebugHooks = hooks;
+  return previous;
+}
+__name(setDebugHooks, "setDebugHooks");
+function getDebugHooks() {
+  return activeDebugHooks;
+}
+__name(getDebugHooks, "getDebugHooks");
+function hasDebugHooks() {
+  return activeDebugHooks !== null;
+}
+__name(hasDebugHooks, "hasDebugHooks");
+function getSignalDebugName(signal) {
+  return signalNames.get(signal);
+}
+__name(getSignalDebugName, "getSignalDebugName");
+function invokeDebug(name, ...args) {
+  const callback = activeDebugHooks?.[name];
+  if (!callback) return;
+  try {
+    callback(...args);
+  } catch {
+  }
+}
+__name(invokeDebug, "invokeDebug");
+
+// packages/reactivity/src/owner.ts
+var ownerNames = /* @__PURE__ */ new WeakMap();
+function getOwnerDebugName(owner) {
+  return ownerNames.get(owner);
+}
+__name(getOwnerDebugName, "getOwnerDebugName");
+function untrack(fn) {
+  try {
+    return fn();
+  } finally {
+  }
+}
+__name(untrack, "untrack");
+
+// packages/reactivity/src/scheduler.ts
+var _Scheduler = class _Scheduler {
+  constructor() {
+    this.dirtyEffects = /* @__PURE__ */ new Set();
+    this.lowPriorityEffects = /* @__PURE__ */ new Set();
+    // flush 不可重入（flushing 标志保证），缓冲数组可在轮次间安全复用，避免每轮分配。
+    this.normalBuffer = [];
+    this.lowBuffer = [];
+    this.flushing = false;
+    this.scheduled = false;
+    this.batchDepth = 0;
+  }
+  schedule(effect2) {
+    if (effect2.disposed) return;
+    this.dirtyEffects.add(effect2);
+    this.lowPriorityEffects.delete(effect2);
+    this.ensureScheduled();
+  }
+  /** Queue an effect behind normal updates while preserving deterministic order. */
+  scheduleLow(effect2) {
+    if (effect2.disposed) return;
+    if (!this.dirtyEffects.has(effect2)) this.lowPriorityEffects.add(effect2);
+    this.ensureScheduled();
+  }
+  ensureScheduled() {
+    if (this.batchDepth === 0 && !this.flushing && !this.scheduled) {
+      this.scheduled = true;
+      queueMicrotask(() => {
+        this.scheduled = false;
+        this.flush();
+      });
+    }
+  }
+  remove(effect2) {
+    this.dirtyEffects.delete(effect2);
+    this.lowPriorityEffects.delete(effect2);
+  }
+  batch(fn) {
+    this.batchDepth++;
+    try {
+      return fn();
+    } finally {
+      this.batchDepth--;
+      if (this.batchDepth === 0) this.flush();
+    }
+  }
+  flush() {
+    if (this.flushing || this.batchDepth > 0) return;
+    this.flushing = true;
+    const debugEnabled = hasDebugHooks();
+    if (debugEnabled) invokeDebug("flushStart");
+    let rounds = 0;
+    let firstError;
+    let hasError = false;
+    try {
+      while (this.dirtyEffects.size > 0 || this.lowPriorityEffects.size > 0) {
+        if (++rounds > 100) {
+          this.dirtyEffects.clear();
+          this.lowPriorityEffects.clear();
+          throw new Error("Vobs: \u54CD\u5E94\u5F0F\u66F4\u65B0\u8D85\u8FC7 100 \u8F6E\uFF0C\u53EF\u80FD\u5B58\u5728\u5FAA\u73AF\u4F9D\u8D56");
+        }
+        this.collectRunnable(this.dirtyEffects, this.normalBuffer);
+        this.collectRunnable(this.lowPriorityEffects, this.lowBuffer);
+        sortEffects(this.normalBuffer);
+        sortEffects(this.lowBuffer);
+        for (const effect2 of this.normalBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        for (const effect2 of this.lowBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        this.normalBuffer.length = 0;
+        this.lowBuffer.length = 0;
+      }
+    } finally {
+      this.normalBuffer.length = 0;
+      this.lowBuffer.length = 0;
+      this.flushing = false;
+      if (debugEnabled) invokeDebug("flushEnd");
+    }
+    if (hasError) throw firstError;
+  }
+  /** 收集未 disposed 的 effect 并清空源集合；run() 期间新调度的 effect 留给下一轮。 */
+  collectRunnable(source, target) {
+    for (const effect2 of source) {
+      if (!effect2.disposed) target.push(effect2);
+    }
+    source.clear();
+  }
+};
+__name(_Scheduler, "Scheduler");
+function sortEffects(effects) {
+  if (effects.length > 1) {
+    effects.sort((a, b) => b.depth - a.depth || a.order - b.order);
+  }
+}
+__name(sortEffects, "sortEffects");
+
+// packages/runtime/src/debug.ts
+var activeRuntimeDebugHooks = null;
+var activeRuntimeDebugContext = null;
+function setRuntimeDebugHooks(hooks) {
+  const previous = activeRuntimeDebugHooks;
+  activeRuntimeDebugHooks = hooks;
+  return previous;
+}
+__name(setRuntimeDebugHooks, "setRuntimeDebugHooks");
+function getRuntimeDebugHooks() {
+  return activeRuntimeDebugHooks;
+}
+__name(getRuntimeDebugHooks, "getRuntimeDebugHooks");
+function getRuntimeDebugContext() {
+  return activeRuntimeDebugContext;
+}
+__name(getRuntimeDebugContext, "getRuntimeDebugContext");
+
+// packages/runtime/src/hmr.ts
+var globalTarget = globalThis;
+var hmrGlobal = globalTarget.__VOBS_HMR__ ?? { modules: /* @__PURE__ */ new Map() };
+globalTarget.__VOBS_HMR__ = hmrGlobal;
+
+// packages/runtime/src/error.ts
+var _VobsError = class _VobsError extends Error {
+  constructor(options) {
+    super(options.message);
+    this.name = "VobsError";
+    this.code = options.code;
+    this.severity = options.severity ?? "error";
+    this.layer = options.layer ?? "runtime";
+    this.cause = options.cause;
+    this.fix = options.fix;
+    this.location = options.location;
+    this.trace = options.trace;
+    this.example = options.example;
+    this.docs = options.docs;
+    this.codeFrame = options.codeFrame;
+  }
+};
+__name(_VobsError, "VobsError");
+var VobsError = _VobsError;
+function isVobsError(value) {
+  return value instanceof VobsError || Boolean(value && typeof value === "object" && typeof value.code === "string" && typeof value.message === "string" && typeof value.layer === "string");
+}
+__name(isVobsError, "isVobsError");
+function normalizeVobsError(value, defaults = {}) {
+  if (value instanceof VobsError) return value;
+  if (value instanceof Error) {
+    const metadata = value;
+    const code = defaults.code ?? (typeof metadata.vobsCode === "string" ? metadata.vobsCode : void 0);
+    if (code) defineErrorMetadata(value, "code", code);
+    defineErrorMetadata(value, "severity", defaults.severity ?? "error");
+    defineErrorMetadata(value, "layer", defaults.layer ?? "runtime");
+    const fix = defaults.fix ?? (typeof metadata.vobsHint === "string" ? metadata.vobsHint : void 0);
+    if (fix) defineErrorMetadata(value, "fix", fix);
+    const source = metadata.vobsSource;
+    if (source && typeof source === "object" && typeof source.file === "string" && typeof source.line === "number" && typeof source.column === "number") {
+      defineErrorMetadata(value, "location", source);
+    }
+    return value;
+  }
+  if (isVobsError(value)) {
+    const candidate = value;
+    return new VobsError({
+      code: candidate.code,
+      message: candidate.message,
+      severity: candidate.severity ?? defaults.severity,
+      layer: candidate.layer ?? defaults.layer,
+      cause: candidate.cause,
+      fix: candidate.fix ?? defaults.fix,
+      location: candidate.location,
+      trace: candidate.trace,
+      example: candidate.example,
+      docs: candidate.docs,
+      codeFrame: candidate.codeFrame
+    });
+  }
+  const message = String(value);
+  return new VobsError({
+    code: defaults.code ?? "VOBS_UNKNOWN",
+    message,
+    severity: defaults.severity ?? "error",
+    layer: defaults.layer ?? "runtime",
+    cause: void 0,
+    fix: defaults.fix
+  });
+}
+__name(normalizeVobsError, "normalizeVobsError");
+function defineErrorMetadata(target, key, value) {
+  if (key in target) return;
+  try {
+    Object.defineProperty(target, key, { configurable: true, enumerable: false, value, writable: true });
+  } catch {
+  }
+}
+__name(defineErrorMetadata, "defineErrorMetadata");
+
+// packages/vobs/src/app.ts
+function createInjectionKey(description) {
+  return Symbol(description);
+}
+__name(createInjectionKey, "createInjectionKey");
+
+// packages/http/src/debug.ts
+var activeHTTPDebugHooks = null;
+function setHTTPDebugHooks(hooks) {
+  const previous = activeHTTPDebugHooks;
+  activeHTTPDebugHooks = hooks;
+  return previous;
+}
+__name(setHTTPDebugHooks, "setHTTPDebugHooks");
+function getHTTPDebugHooks() {
+  return activeHTTPDebugHooks;
+}
+__name(getHTTPDebugHooks, "getHTTPDebugHooks");
+
+// packages/devtools/src/index.ts
+var DEVTOOLS_REACTIVITY_EVENTS = [
+  "owner-created",
+  "owner-named",
+  "owner-disposed",
+  "signal-created",
+  "signal-named",
+  "signal-update",
+  "signal-disposed",
+  "effect-created",
+  "effect-invalidated",
+  "effect-run-start",
+  "effect-run",
+  "effect-disposed",
+  "memo-created",
+  "memo-update",
+  "update"
+];
+var DEVTOOLS_EVENTS = [...DEVTOOLS_REACTIVITY_EVENTS, "lifecycle", "dom-update", "network-request", "router", "error", "collection", "collection-cleared", "extension"];
+var activeDevTools = null;
+function createDevTools(options = {}) {
+  activeDevTools?.dispose();
+  const owners = /* @__PURE__ */ new Map();
+  const ownerIds = /* @__PURE__ */ new WeakMap();
+  const signals = /* @__PURE__ */ new Map();
+  const signalIds = /* @__PURE__ */ new WeakMap();
+  const effects = /* @__PURE__ */ new Map();
+  const effectIds = /* @__PURE__ */ new WeakMap();
+  const memoSignalIds = /* @__PURE__ */ new WeakMap();
+  const edges = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
+  const updates = [];
+  const lifecycleEvents = [];
+  const networkRequests = /* @__PURE__ */ new Map();
+  const errors = /* @__PURE__ */ new Map();
+  const inspectors = /* @__PURE__ */ new Map();
+  const timelines = /* @__PURE__ */ new Map();
+  const metrics = /* @__PURE__ */ new Map();
+  let routerContext = null;
+  const routerStops = /* @__PURE__ */ new Map();
+  let nextErrorId = 1;
+  let collectionPaused = false;
+  const pendingUpdates = [];
+  const updateDurations = [];
+  const maxUpdates = Math.max(1, Math.floor(options.maxUpdates ?? 100));
+  const slowUpdateThreshold = Math.max(0, options.slowUpdateThreshold ?? 16);
+  let nextId = 1;
+  let updateCount = 0;
+  let effectExecutionCount = 0;
+  let disposed = false;
+  let pendingFlushScheduled = false;
+  let activeEffectId = null;
+  const privacy = normalizePrivacyOptions(options.privacy);
+  const allowMutations = options.allowMutations === true;
+  function now() {
+    return typeof performance === "undefined" ? Date.now() : performance.now();
+  }
+  __name(now, "now");
+  function emit(event, ...args) {
+    if (collectionPaused && event !== "collection" && event !== "collection-cleared") return;
+    const callbacks = [
+      ...listeners.get(event) ?? [],
+      ...listeners.get("*") ?? []
+    ];
+    for (const callback of callbacks) {
+      try {
+        callback(...args);
+      } catch {
+      }
+    }
+  }
+  __name(emit, "emit");
+  function safeExtensionCall(read, fallback) {
+    try {
+      return read();
+    } catch {
+      return fallback;
+    }
+  }
+  __name(safeExtensionCall, "safeExtensionCall");
+  function getExtensionSnapshot() {
+    const extensionMetrics = {};
+    const extensionTimelineEvents = {};
+    for (const [id, timeline] of timelines) {
+      const events = safeExtensionCall(() => timeline.getEvents?.() ?? [], []);
+      extensionTimelineEvents[id] = events.map((event) => ({
+        ...event,
+        data: serializeForDevTools(event.data, /* @__PURE__ */ new Set(), 0, privacy)
+      })).slice(-maxUpdates);
+    }
+    for (const [id, metric] of metrics) {
+      const value = safeExtensionCall(() => metric.read(), 0);
+      extensionMetrics[id] = typeof value === "number" || typeof value === "string" ? value : 0;
+    }
+    return {
+      inspectors: [...inspectors.keys()],
+      timelines: [...timelines.keys()],
+      timelineEvents: extensionTimelineEvents,
+      metrics: extensionMetrics
+    };
+  }
+  __name(getExtensionSnapshot, "getExtensionSnapshot");
+  function recordLifecycle(type, targetId, name, ownerId, status) {
+    if (disposed || collectionPaused || isInternalOwnerId(targetId) || ownerId !== void 0 && isInternalOwnerId(ownerId)) return;
+    const event = {
+      id: `lifecycle-${nextId++}`,
+      type,
+      timestamp: now(),
+      targetId,
+      name,
+      ownerId,
+      status
+    };
+    lifecycleEvents.push(event);
+    while (lifecycleEvents.length > maxUpdates) lifecycleEvents.shift();
+    emit("lifecycle", event);
+  }
+  __name(recordLifecycle, "recordLifecycle");
+  function reportError(phase, error, context = {}) {
+    if (collectionPaused) return;
+    const debugError = toDebugError(error, phase);
+    const metadata = classifyError(phase, error, context);
+    const code = context.code ?? debugError.code ?? metadata.code;
+    const hint = context.hint ?? debugError.hint ?? metadata.hint;
+    const origin = context.origin ?? metadata.origin;
+    const ownerId = context.ownerId ?? readErrorProperty(error, "vobsOwnerId");
+    const component = context.component ?? readErrorProperty(error, "vobsComponent");
+    const source = context.source ?? debugError.source ?? readErrorProperty(error, "vobsSource");
+    const activeRoute = context.route ?? getRuntimeDebugContext()?.route ?? routerContext?.route;
+    const activeNavigationId = context.navigationId ?? getRuntimeDebugContext()?.navigationId ?? routerContext?.navigationId;
+    const key = diagnosticErrorKey({ origin, code, name: debugError.name, message: debugError.message, source, component });
+    const previous = errors.get(key);
+    const nowValue = Date.now();
+    const trace = previous ? {
+      ...previous,
+      ...context,
+      phase,
+      phases: previous.phases.includes(phase) ? previous.phases : [...previous.phases, phase],
+      lastOccurredAt: nowValue,
+      count: previous.count + 1,
+      code,
+      hint,
+      origin,
+      handled: context.handled ?? previous.handled,
+      recovery: mergeRecovery(previous.recovery, context.recovery),
+      ownerId: ownerId ?? previous.ownerId,
+      component: component ?? previous.component,
+      source: source ?? previous.source,
+      updateId: context.updateId ?? previous.updateId,
+      effectId: context.effectId ?? previous.effectId,
+      requestId: context.requestId ?? previous.requestId,
+      route: activeRoute ?? previous.route,
+      navigationId: activeNavigationId ?? previous.navigationId
+    } : {
+      ...debugError,
+      ...context,
+      source,
+      code,
+      hint,
+      id: nextErrorId++,
+      phase,
+      phases: [phase],
+      origin,
+      handled: context.handled ?? false,
+      recovery: context.recovery ?? "propagated",
+      firstOccurredAt: nowValue,
+      lastOccurredAt: nowValue,
+      count: 1,
+      ownerId,
+      component,
+      route: activeRoute,
+      navigationId: activeNavigationId
+    };
+    errors.set(key, trace);
+    while (errors.size > maxUpdates) {
+      const oldest = errors.keys().next().value;
+      if (typeof oldest !== "string") break;
+      errors.delete(oldest);
+    }
+    emit("error", trace);
+  }
+  __name(reportError, "reportError");
+  function ensureOwner(owner) {
+    const existingId = ownerIds.get(owner);
+    if (existingId) {
+      const existing = owners.get(existingId);
+      if (existing) return existing;
+    }
+    const record = {
+      owner,
+      id: owner.id,
+      parentId: owner.parent?.id ?? null,
+      name: getOwnerDebugName(owner) ?? (owner.parent ? "Owner" : "App"),
+      disposed: owner.disposed
+    };
+    ownerIds.set(owner, record.id);
+    owners.set(record.id, record);
+    return record;
+  }
+  __name(ensureOwner, "ensureOwner");
+  function isInternalOwnerId(ownerId) {
+    const visited = /* @__PURE__ */ new Set();
+    let current = ownerId === void 0 ? null : ownerId;
+    while (current && !visited.has(current)) {
+      visited.add(current);
+      const record = owners.get(current);
+      if (!record) return false;
+      if (debugComponentName(record.name).startsWith("DevTools")) return true;
+      current = record.parentId;
+    }
+    return false;
+  }
+  __name(isInternalOwnerId, "isInternalOwnerId");
+  function isInternalSignal(record) {
+    return isInternalOwnerId(record.ownerId);
+  }
+  __name(isInternalSignal, "isInternalSignal");
+  function isNoisyViewportSignal(record) {
+    return record.explicitName && (record.name === "layout.viewport.width" || record.name === "layout.viewport.height");
+  }
+  __name(isNoisyViewportSignal, "isNoisyViewportSignal");
+  function hasMeaningfulDomUpdate(updates2) {
+    return updates2.some((update) => update.operation === "insert" || update.operation === "remove" || !Object.is(update.previousValue, update.nextValue));
+  }
+  __name(hasMeaningfulDomUpdate, "hasMeaningfulDomUpdate");
+  function isInternalEffect(record) {
+    return isInternalOwnerId(record.ownerId);
+  }
+  __name(isInternalEffect, "isInternalEffect");
+  function errorComponentForOwner(ownerId) {
+    if (!ownerId) return void 0;
+    const record = owners.get(ownerId);
+    if (!record) return void 0;
+    if (record.name !== "Owner" && record.name !== "dynamic") return record.name;
+    return errorComponentForOwner(record.parentId ?? void 0);
+  }
+  __name(errorComponentForOwner, "errorComponentForOwner");
+  function ensureSignal(signal, owner = null) {
+    const existingId = signalIds.get(signal);
+    if (existingId) {
+      const existing = signals.get(existingId);
+      if (existing) return existing;
+    }
+    const id = `signal-${nextId++}`;
+    const explicitName = getSignalDebugName(signal);
+    const ownerName = owner ? getOwnerDebugName(owner) : void 0;
+    const record = {
+      signal,
+      id,
+      ownerId: owner ? ensureOwner(owner).id : null,
+      createdAt: Date.now(),
+      name: explicitName ?? (ownerName ? `${ownerName} state` : "runtime state"),
+      explicitName: explicitName !== void 0,
+      kind: "state",
+      disposed: false
+    };
+    signalIds.set(signal, id);
+    signals.set(id, record);
+    return record;
+  }
+  __name(ensureSignal, "ensureSignal");
+  function ensureEffect(effect2, owner = null) {
+    const existingId = effectIds.get(effect2);
+    if (existingId) {
+      const existing = effects.get(existingId);
+      if (existing) return existing;
+    }
+    const id = `effect-${nextId++}`;
+    const record = {
+      effect: effect2,
+      id,
+      ownerId: owner ? ensureOwner(owner).id : null,
+      status: "dirty",
+      executionCount: 0,
+      lastExecutionTime: 0,
+      lastRunStatus: void 0,
+      lastDuration: 0,
+      lastUpdateId: void 0,
+      lastError: void 0,
+      lastDomUpdates: 0,
+      runningSince: null,
+      disposed: effect2.disposed
+    };
+    effectIds.set(effect2, id);
+    effects.set(id, record);
+    return record;
+  }
+  __name(ensureEffect, "ensureEffect");
+  function ensureDependencySignal(dependency) {
+    const existingId = signalIds.get(dependency);
+    if (existingId) return signals.get(existingId) ?? null;
+    if (!("value" in dependency)) return null;
+    return ensureSignal(dependency);
+  }
+  __name(ensureDependencySignal, "ensureDependencySignal");
+  function edgeKey(from, to) {
+    return `${from}->${to}`;
+  }
+  __name(edgeKey, "edgeKey");
+  function trackDependency2(dependency, subscriber) {
+    const source = ensureDependencySignal(dependency);
+    if (!source) return;
+    const memoId = memoSignalIds.get(subscriber);
+    const effectId = effectIds.get(subscriber);
+    const targetId = memoId ?? effectId;
+    if (!targetId) return;
+    const type = memoId ? source.kind === "memo" ? "memo-to-memo" : "state-to-memo" : source.kind === "memo" ? "memo-to-effect" : "state-to-effect";
+    edges.set(edgeKey(source.id, targetId), {
+      from: source.id,
+      to: targetId,
+      type
+    });
+  }
+  __name(trackDependency2, "trackDependency");
+  function collectEffectIds(signalId) {
+    const effectsForSignal = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const visit = /* @__PURE__ */ __name((sourceId) => {
+      if (visited.has(sourceId)) return;
+      visited.add(sourceId);
+      for (const edge of edges.values()) {
+        if (edge.from !== sourceId) continue;
+        if (effects.has(edge.to)) {
+          const effect2 = effects.get(edge.to);
+          if (effect2 && !isInternalEffect(effect2)) effectsForSignal.add(edge.to);
+        } else visit(edge.to);
+      }
+    }, "visit");
+    visit(signalId);
+    return effectsForSignal;
+  }
+  __name(collectEffectIds, "collectEffectIds");
+  function collectAffectedSignals(signalId) {
+    const affected = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    const visit = /* @__PURE__ */ __name((sourceId) => {
+      if (visited.has(sourceId)) return;
+      visited.add(sourceId);
+      if (signals.has(sourceId)) affected.add(sourceId);
+      for (const edge of edges.values()) {
+        if (edge.from === sourceId && signals.has(edge.to)) visit(edge.to);
+      }
+    }, "visit");
+    visit(signalId);
+    return affected;
+  }
+  __name(collectAffectedSignals, "collectAffectedSignals");
+  function untrackDependency(dependency, subscriber) {
+    const source = ensureDependencySignal(dependency);
+    if (!source) return;
+    const targetId = memoSignalIds.get(subscriber) ?? effectIds.get(subscriber);
+    if (targetId) edges.delete(edgeKey(source.id, targetId));
+  }
+  __name(untrackDependency, "untrackDependency");
+  function signalInfo(record, readValue = true) {
+    return {
+      id: record.id,
+      name: record.name,
+      value: readValue ? serializeForDevTools(readSignal(record.signal), /* @__PURE__ */ new Set(), 0, privacy) : void 0,
+      component: record.ownerId ? owners.get(record.ownerId)?.name ?? "unknown" : "unknown",
+      subscribers: [...edges.values()].filter((edge) => edge.from === record.id).length,
+      createdAt: record.createdAt,
+      kind: record.kind
+    };
+  }
+  __name(signalInfo, "signalInfo");
+  function readSignal(signal) {
+    try {
+      return untrack(() => signal.value);
+    } catch (error) {
+      return { type: "thrown", message: toErrorMessage(error) };
+    }
+  }
+  __name(readSignal, "readSignal");
+  function effectInfo(record) {
+    const component = record.ownerId ? owners.get(record.ownerId)?.name ?? "unknown" : "runtime";
+    return {
+      id: record.id,
+      name: `${debugComponentName(component)} effect`,
+      component,
+      dependencies: [...edges.values()].filter((edge) => edge.to === record.id).map((edge) => edge.from),
+      status: record.status,
+      executionCount: record.executionCount,
+      lastExecutionTime: record.lastExecutionTime,
+      lastRunStatus: record.lastRunStatus,
+      lastDuration: record.lastDuration,
+      lastUpdateId: record.lastUpdateId,
+      lastError: record.lastError,
+      lastDomUpdates: record.lastDomUpdates
+    };
+  }
+  __name(effectInfo, "effectInfo");
+  function removeEdgesFor(ids) {
+    for (const [key, edge] of edges) {
+      if (ids.has(edge.from) || ids.has(edge.to)) edges.delete(key);
+    }
+  }
+  __name(removeEdgesFor, "removeEdgesFor");
+  function cleanupSignalRecord(record) {
+    if (signals.get(record.id) !== record) return;
+    removeEdgesFor(/* @__PURE__ */ new Set([record.id]));
+    signals.delete(record.id);
+  }
+  __name(cleanupSignalRecord, "cleanupSignalRecord");
+  function cleanupEffectRecord(record) {
+    if (effects.get(record.id) !== record) return;
+    removeEdgesFor(/* @__PURE__ */ new Set([record.id]));
+    effects.delete(record.id);
+  }
+  __name(cleanupEffectRecord, "cleanupEffectRecord");
+  function cleanupOwnerRecord(record) {
+    if (owners.get(record.id) !== record) return;
+    const removedIds = /* @__PURE__ */ new Set([record.id]);
+    for (const [id, signal] of signals) {
+      if (signal.ownerId === record.id) {
+        removedIds.add(id);
+        signals.delete(id);
+      }
+    }
+    for (const [id, effect2] of effects) {
+      if (effect2.ownerId === record.id) {
+        removedIds.add(id);
+        effects.delete(id);
+      }
+    }
+    removeEdgesFor(removedIds);
+    owners.delete(record.id);
+  }
+  __name(cleanupOwnerRecord, "cleanupOwnerRecord");
+  function debugComponentName(value) {
+    const separator = value.indexOf(" (");
+    return separator > 0 ? value.slice(0, separator) : value;
+  }
+  __name(debugComponentName, "debugComponentName");
+  function buildComponentNode(record, activeIds) {
+    const componentEffects = [...effects.values()].filter((effect2) => !effect2.disposed && effect2.ownerId === record.id);
+    const componentEffectIds = new Set(componentEffects.map((effect2) => effect2.id));
+    const componentUpdates = updates.filter((update) => update.effects.some((effect2) => componentEffectIds.has(effect2.effectId)));
+    return {
+      id: record.id,
+      name: record.name,
+      ownerId: record.id,
+      signals: [...signals.values()].filter((signal) => !signal.disposed && signal.ownerId === record.id).map((signal) => signal.id),
+      effects: componentEffects.map((effect2) => effect2.id),
+      recentUpdates: componentUpdates.slice(-10).map((update) => update.id),
+      domUpdates: componentUpdates.reduce((count, update) => count + update.domUpdates.length, 0),
+      children: [...owners.values()].filter((child) => !child.disposed && child.parentId === record.id && activeIds.has(child.id)).map((child) => buildComponentNode(child, activeIds)),
+      mounted: !record.disposed
+    };
+  }
+  __name(buildComponentNode, "buildComponentNode");
+  function recordUpdate(pending) {
+    if (disposed || collectionPaused || isInternalSignal(pending.signal)) return;
+    if (isNoisyViewportSignal(pending.signal) && !hasMeaningfulDomUpdate(pending.domUpdates)) return;
+    const duration = Math.max(0, now() - pending.timestamp);
+    const trace = {
+      id: pending.id,
+      signalId: pending.signal.id,
+      signalName: pending.signal.name,
+      previousValue: serializeForDevTools(pending.previousValue, /* @__PURE__ */ new Set(), 0, privacy),
+      nextValue: serializeForDevTools(pending.nextValue, /* @__PURE__ */ new Set(), 0, privacy),
+      timestamp: pending.timestamp,
+      effects: [...pending.executions.values()],
+      affectedSignals: [...pending.affectedSignals],
+      affectedEffects: [...pending.effectIds],
+      domUpdates: pending.domUpdates.slice(),
+      status: pending.status,
+      error: pending.error,
+      duration,
+      route: pending.context.route,
+      navigationId: pending.context.navigationId,
+      requestIds: [...pending.context.requestIds]
+    };
+    updates.push(trace);
+    while (updates.length > maxUpdates) updates.shift();
+    updateDurations.push(duration);
+    while (updateDurations.length > maxUpdates) updateDurations.shift();
+    updateCount++;
+    emit("update", trace);
+  }
+  __name(recordUpdate, "recordUpdate");
+  function onFlushEnd() {
+    const current = pendingUpdates.splice(0);
+    for (const pending of current) recordUpdate(pending);
+  }
+  __name(onFlushEnd, "onFlushEnd");
+  function schedulePendingFlush() {
+    if (pendingFlushScheduled) return;
+    pendingFlushScheduled = true;
+    queueMicrotask(() => {
+      if (disposed) {
+        pendingUpdates.length = 0;
+        return;
+      }
+      pendingFlushScheduled = false;
+      for (let index = pendingUpdates.length - 1; index >= 0; index--) {
+        const pending = pendingUpdates[index];
+        if (!pending || pending.effectIds.size > 0) continue;
+        pendingUpdates.splice(index, 1);
+        recordUpdate(pending);
+      }
+    });
+  }
+  __name(schedulePendingFlush, "schedulePendingFlush");
+  const hooks = {
+    ownerCreated(owner) {
+      const record = ensureOwner(owner);
+      recordLifecycle("owner-created", record.id, record.name, record.parentId ?? void 0);
+      emit("owner-created", record);
+    },
+    ownerNamed(owner, name) {
+      const record = ensureOwner(owner);
+      record.name = name;
+      if (isInternalOwnerId(record.id)) return;
+      for (const signal of signals.values()) {
+        if (signal.ownerId === record.id && !signal.explicitName) signal.name = `${name} state`;
+      }
+      recordLifecycle("owner-named", record.id, name, record.parentId ?? void 0);
+      emit("owner-named", record);
+    },
+    ownerDisposed(owner) {
+      const record = ensureOwner(owner);
+      record.disposed = true;
+      const internal = isInternalOwnerId(record.id);
+      if (!internal) {
+        recordLifecycle("owner-disposed", record.id, record.name, record.parentId ?? void 0);
+        emit("owner-disposed", record);
+      }
+      cleanupOwnerRecord(record);
+    },
+    signalCreated(signal, owner) {
+      const record = ensureSignal(signal, owner);
+      if (isInternalSignal(record)) return;
+      recordLifecycle("signal-created", record.id, record.name, record.ownerId ?? void 0);
+      emit("signal-created", signalInfo(record, false));
+    },
+    signalNamed(signal, name) {
+      const record = ensureSignal(signal);
+      record.name = name;
+      record.explicitName = true;
+      if (isInternalSignal(record)) return;
+      recordLifecycle("signal-named", record.id, name, record.ownerId ?? void 0);
+      emit("signal-named", signalInfo(record));
+    },
+    signalRead(signal, subscriber) {
+      ensureSignal(signal);
+      emit("signal-read", signal, subscriber);
+    },
+    signalChanged(signal, previousValue, nextValue) {
+      const record = ensureSignal(signal);
+      if (isInternalSignal(record)) return;
+      let pending = pendingUpdates.find((item) => item.signal.signal === signal);
+      if (pending) {
+        pending.nextValue = nextValue;
+      } else {
+        pending = {
+          id: `update-${nextId++}`,
+          signal: record,
+          timestamp: now(),
+          previousValue,
+          nextValue,
+          affectedSignals: collectAffectedSignals(record.id),
+          effectIds: collectEffectIds(record.id),
+          executions: /* @__PURE__ */ new Map(),
+          domUpdates: [],
+          status: "completed",
+          error: void 0,
+          context: {
+            route: getRuntimeDebugContext()?.route,
+            navigationId: getRuntimeDebugContext()?.navigationId,
+            requestIds: new Set(
+              [] 
+            )
+          }
+        };
+        pendingUpdates.push(pending);
+      }
+      emit("signal-update", {
+        ...signalInfo(record),
+        previousValue: serializeForDevTools(previousValue, /* @__PURE__ */ new Set(), 0, privacy),
+        nextValue: serializeForDevTools(nextValue, /* @__PURE__ */ new Set(), 0, privacy),
+        updateId: pending.id
+      });
+      recordLifecycle("signal-changed", record.id, record.name, record.ownerId ?? void 0);
+      if (pending.effectIds.size === 0) schedulePendingFlush();
+    },
+    signalDisposed(signal) {
+      const record = ensureSignal(signal);
+      record.disposed = true;
+      const internal = isInternalSignal(record);
+      if (!internal) {
+        recordLifecycle("signal-disposed", record.id, record.name, record.ownerId ?? void 0);
+        emit("signal-disposed", record);
+      }
+      cleanupSignalRecord(record);
+    },
+    dependencyTracked(dependency, subscriber) {
+      trackDependency2(dependency, subscriber);
+    },
+    dependencyUntracked(dependency, subscriber) {
+      untrackDependency(dependency, subscriber);
+    },
+    effectCreated(effect2, owner) {
+      const record = ensureEffect(effect2, owner);
+      if (isInternalEffect(record)) return;
+      recordLifecycle("effect-created", record.id, effectInfo(record).name, record.ownerId ?? void 0);
+      emit("effect-created", effectInfo(record));
+    },
+    effectInvalidated(effect2) {
+      const record = ensureEffect(effect2);
+      if (isInternalEffect(record)) return;
+      record.status = "dirty";
+      recordLifecycle("effect-invalidated", record.id, effectInfo(record).name, record.ownerId ?? void 0);
+      emit("effect-invalidated", effectInfo(record));
+    },
+    effectRunStart(effect2) {
+      const record = ensureEffect(effect2);
+      if (isInternalEffect(record)) return;
+      record.status = "running";
+      record.runningSince = now();
+      activeEffectId = record.id;
+      recordLifecycle("effect-run-start", record.id, effectInfo(record).name, record.ownerId ?? void 0);
+      emit("effect-run-start", effectInfo(record));
+    },
+    effectRunEnd(effect2, error, handled = false) {
+      const record = ensureEffect(effect2);
+      if (isInternalEffect(record)) return;
+      const end = now();
+      const duration = record.runningSince === null ? 0 : Math.max(0, end - record.runningSince);
+      const runStatus = error === void 0 ? "success" : "error";
+      const debugError = error === void 0 ? void 0 : toDebugError(error, "effect");
+      record.status = runStatus;
+      record.runningSince = null;
+      record.executionCount++;
+      record.lastExecutionTime = end;
+      record.lastRunStatus = runStatus;
+      record.lastDuration = duration;
+      record.lastError = debugError;
+      effectExecutionCount++;
+      const execution = {
+        effectId: record.id,
+        component: record.ownerId ? owners.get(record.ownerId)?.name ?? "unknown" : "unknown",
+        duration,
+        domUpdates: 0,
+        status: runStatus,
+        error: debugError
+      };
+      for (const pending of pendingUpdates) {
+        if (!pending.effectIds.has(record.id)) continue;
+        const domUpdates = pending.domUpdates.filter((update) => update.effectId === record.id).length;
+        const completedExecution = { ...execution, domUpdates };
+        pending.executions.set(record.id, completedExecution);
+        if (error !== void 0) {
+          pending.status = "error";
+          pending.error = debugError;
+        }
+        record.lastUpdateId = pending.id;
+        record.lastDomUpdates = domUpdates;
+      }
+      activeEffectId = null;
+      if (error !== void 0) {
+        const update = [...pendingUpdates].reverse().find((item) => item.effectIds.has(record.id));
+        const errorOwnerId = readErrorProperty(error, "vobsOwnerId");
+        const errorComponent = readErrorProperty(error, "vobsComponent");
+        reportError("effect", error, {
+          effectId: record.id,
+          updateId: update?.id,
+          ownerId: errorOwnerId ?? record.ownerId ?? void 0,
+          component: errorComponent ?? errorComponentForOwner(record.ownerId ?? void 0),
+          handled,
+          recovery: handled ? "handled" : "propagated"
+        });
+      }
+      recordLifecycle("effect-run", record.id, effectInfo(record).name, record.ownerId ?? void 0, runStatus);
+      emit("effect-run", execution);
+    },
+    effectDisposed(effect2) {
+      const record = ensureEffect(effect2);
+      const internal = isInternalEffect(record);
+      record.disposed = true;
+      record.status = "idle";
+      if (!internal) {
+        recordLifecycle("effect-disposed", record.id, effectInfo(record).name, record.ownerId ?? void 0);
+        emit("effect-disposed", record);
+      }
+      cleanupEffectRecord(record);
+    },
+    memoCreated(signal, subscriber, owner) {
+      const record = ensureSignal(signal, owner);
+      record.kind = "memo";
+      memoSignalIds.set(subscriber, record.id);
+      if (isInternalSignal(record)) return;
+      recordLifecycle("memo-created", record.id, record.name, record.ownerId ?? void 0);
+      emit("memo-created", signalInfo(record));
+    },
+    memoInvalidated(signal) {
+      const record = ensureSignal(signal);
+      if (isInternalSignal(record)) return;
+      recordLifecycle("memo-invalidated", record.id, record.name, record.ownerId ?? void 0);
+      emit("memo-update", signalInfo(record));
+    },
+    flushEnd: onFlushEnd
+  };
+  const runtimeHooks = {
+    domMutation(mutation) {
+      if (!activeEffectId) return;
+      const effect2 = effects.get(activeEffectId);
+      if (!effect2 || isInternalEffect(effect2)) return;
+      const safeMutation = {
+        ...mutation,
+        previousValue: privacy.redactDomValues ? privacy.replacement : serializeForDevTools(mutation.previousValue, /* @__PURE__ */ new Set(), 0, privacy),
+        nextValue: privacy.redactDomValues ? privacy.replacement : serializeForDevTools(mutation.nextValue, /* @__PURE__ */ new Set(), 0, privacy),
+        effectId: activeEffectId,
+        route: getRuntimeDebugContext()?.route,
+        navigationId: getRuntimeDebugContext()?.navigationId,
+        requestId: getRuntimeDebugContext()?.dataRequestId
+      };
+      for (const pending of pendingUpdates) {
+        if (pending.effectIds.has(activeEffectId)) {
+          pending.domUpdates.push(safeMutation);
+          if (safeMutation.route) pending.context = { ...pending.context, route: safeMutation.route };
+          if (safeMutation.navigationId !== void 0) pending.context = { ...pending.context, navigationId: safeMutation.navigationId };
+          if (safeMutation.requestId !== void 0) pending.context.requestIds.add(safeMutation.requestId);
+        }
+      }
+      emit("dom-update", safeMutation);
+    },
+    hydrationMismatch(event) {
+      reportError("hydration", Object.assign(new Error(event.message), {
+        name: "HydrationMismatchError",
+        vobsCode: "VOBS_HYDRATION_MISMATCH",
+        vobsHydration: event
+      }), {
+        route: getRuntimeDebugContext()?.route,
+        navigationId: getRuntimeDebugContext()?.navigationId
+      });
+    },
+    error(event) {
+      const owner = ensureOwner(event.owner);
+      const errorOwnerId = readErrorProperty(event.error, "vobsOwnerId");
+      const errorComponent = readErrorProperty(event.error, "vobsComponent");
+      reportError(event.phase === "boundary" ? "boundary" : "event", event.error, {
+        ownerId: errorOwnerId ?? owner.id,
+        component: errorComponent ?? errorComponentForOwner(owner.id ?? void 0) ?? owner.name,
+        handled: event.handled,
+        recovery: event.recovery
+      });
+    }
+  };
+  const httpHooks = {
+    request(event) {
+      if (collectionPaused) return;
+      const previous = networkRequests.get(event.id);
+      const trace = {
+        id: event.id,
+        url: event.url,
+        method: event.method,
+        status: event.status,
+        headers: redactHeaders(event.headers, privacy),
+        requestBody: serializeForDevTools(event.requestBody, /* @__PURE__ */ new Set(), 0, privacy),
+        startedAt: previous?.startedAt ?? event.startedAt,
+        endedAt: event.endedAt,
+        duration: event.duration,
+        attempt: Math.max(event.attempt, previous?.attempt ?? 0),
+        retries: Math.max(event.retries, previous?.retries ?? 0),
+        responseStatus: event.responseStatus,
+        responseBody: serializeForDevTools(event.responseBody, /* @__PURE__ */ new Set(), 0, privacy),
+        error: event.error,
+        source: event.context?.environment === "server" ? "ssr" : "http",
+        test: event.context?.test,
+        route: event.context?.route,
+        navigationId: event.context?.navigationId,
+        dataRequestId: event.context?.dataRequestId,
+        environment: event.context?.environment
+      };
+      for (const pending of pendingUpdates) {
+        if (event.context?.dataRequestId !== void 0 && pending.context.requestIds.has(event.context.dataRequestId)) pending.context.requestIds.add(event.id);
+        if (activeEffectId !== null && pending.effectIds.has(activeEffectId)) pending.context.requestIds.add(event.id);
+      }
+      networkRequests.set(event.id, trace);
+      while (networkRequests.size > maxUpdates) {
+        const oldest = networkRequests.keys().next().value;
+        if (typeof oldest !== "number") break;
+        networkRequests.delete(oldest);
+      }
+      emit("network-request", trace);
+      if (event.error) reportError("network", new Error(event.error.message), {
+        requestId: event.id,
+        route: event.context?.route,
+        navigationId: event.context?.navigationId
+      });
+    }
+  };
+  function importSSRRequests(snapshot) {
+    if (disposed) return;
+    const events = parseSSRRequestSnapshot(snapshot);
+    const ids = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      const importedId = ids.get(event.id) ?? -(event.id + 1);
+      ids.set(event.id, importedId);
+      const trace = {
+        id: importedId,
+        url: event.url,
+        method: event.method,
+        status: event.status,
+        headers: redactHeaders(event.headers, privacy),
+        requestBody: serializeForDevTools(event.requestBody, /* @__PURE__ */ new Set(), 0, privacy),
+        startedAt: event.startedAt,
+        endedAt: event.endedAt,
+        duration: event.duration,
+        attempt: event.attempt,
+        retries: event.retries,
+        responseStatus: event.responseStatus,
+        responseBody: serializeForDevTools(event.responseBody, /* @__PURE__ */ new Set(), 0, privacy),
+        error: event.error,
+        source: "ssr",
+        test: event.context?.test,
+        route: event.context?.route,
+        navigationId: event.context?.navigationId,
+        dataRequestId: event.context?.dataRequestId,
+        environment: "server"
+      };
+      networkRequests.set(importedId, trace);
+    }
+    while (networkRequests.size > maxUpdates) {
+      const oldest = networkRequests.keys().next().value;
+      if (typeof oldest !== "number") break;
+      networkRequests.delete(oldest);
+    }
+    emit("network-request", { source: "ssr", imported: events.length });
+  }
+  __name(importSSRRequests, "importSSRRequests");
+  const previousHooks = getDebugHooks();
+  const previousRuntimeHooks = getRuntimeDebugHooks();
+  const previousHTTPHooks = getHTTPDebugHooks();
+  setDebugHooks(hooks);
+  setRuntimeDebugHooks(runtimeHooks);
+  setHTTPDebugHooks(httpHooks);
+  const target = options.target ?? defaultTarget();
+  const shouldExpose = options.expose ?? Boolean(target);
+  const previousGlobal = target?.__VOBS_DEVTOOLS__;
+  let api;
+  const onGlobalError = /* @__PURE__ */ __name((event) => {
+    const source = typeof event.filename === "string" && event.filename ? `${event.filename}:${typeof event.lineno === "number" ? event.lineno : 0}:${typeof event.colno === "number" ? event.colno : 0}` : void 0;
+    reportError("global", event.error ?? event.message ?? "Unknown global error", { source });
+  }, "onGlobalError");
+  const onUnhandledRejection = /* @__PURE__ */ __name((event) => {
+    reportError("unhandledrejection", event.reason ?? "Unhandled promise rejection");
+  }, "onUnhandledRejection");
+  target?.addEventListener?.("error", onGlobalError);
+  target?.addEventListener?.("unhandledrejection", onUnhandledRejection);
+  function subscribe(event, callback) {
+    if (disposed) return () => void 0;
+    const callbacks = listeners.get(event) ?? /* @__PURE__ */ new Set();
+    callbacks.add(callback);
+    listeners.set(event, callbacks);
+    return () => {
+      callbacks.delete(callback);
+      if (callbacks.size === 0 && listeners.get(event) === callbacks) listeners.delete(event);
+    };
+  }
+  __name(subscribe, "subscribe");
+  function attachRouter(router) {
+    const existing = routerStops.get(router);
+    if (existing) {
+      existing.refs++;
+      let released2 = false;
+      return () => {
+        if (released2) return;
+        released2 = true;
+        existing.refs--;
+        if (existing.refs === 0) existing.stop();
+      };
+    }
+    const source = router.devtools;
+    const initialRoute = source.getCurrentRoute?.();
+    const initialState = source.getNavigationState?.();
+    routerContext = {
+      route: typeof initialRoute?.fullPath === "string" ? initialRoute.fullPath : routerContext?.route,
+      navigationId: typeof initialState?.traceId === "number" ? initialState.traceId : routerContext?.navigationId,
+      navigationStatus: typeof initialState?.status === "string" ? initialState.status : routerContext?.navigationStatus,
+      dataRequests: source.getDataRequests?.() ?? routerContext?.dataRequests ?? []
+    };
+    const stops = [
+      router.devtools.subscribe("navigation:start", (payload) => {
+        const value = payload;
+        routerContext = {
+          route: typeof value.to === "string" ? value.to : routerContext?.route,
+          navigationId: typeof value.traceId === "number" ? value.traceId : routerContext?.navigationId,
+          navigationStatus: typeof value.status === "string" ? value.status : void 0,
+          dataRequests: routerContext?.dataRequests ?? []
+        };
+        emit("router", { type: "navigation:start", payload });
+      }),
+      router.devtools.subscribe("navigation:end", (payload) => {
+        const value = payload;
+        routerContext = {
+          route: typeof value.to === "string" ? value.to : routerContext?.route,
+          navigationId: typeof value.id === "number" ? value.id : routerContext?.navigationId,
+          navigationStatus: typeof value.status === "string" ? value.status : void 0,
+          dataRequests: routerContext?.dataRequests ?? []
+        };
+        emit("router", { type: "navigation:end", payload });
+      }),
+      router.devtools.subscribe("data-request", (payload) => {
+        const request = payload;
+        const requests = [...routerContext?.dataRequests ?? []];
+        const existingIndex = requests.findIndex((item) => item.id === request.id);
+        if (existingIndex >= 0) requests[existingIndex] = request;
+        else requests.push(request);
+        requests.splice(0, Math.max(0, requests.length - maxUpdates));
+        routerContext = { ...routerContext, dataRequests: requests };
+        emit("router", { type: "data-request", payload });
+      }),
+      router.devtools.subscribe("route:update", (payload) => {
+        const value = payload;
+        if (typeof value.fullPath === "string") routerContext = { ...routerContext, route: value.fullPath, dataRequests: routerContext?.dataRequests ?? [] };
+        emit("router", { type: "route:update", payload });
+      }),
+      router.devtools.subscribe("error", (payload) => {
+        const value = payload;
+        reportError("route", Object.assign(new Error(typeof value.message === "string" ? value.message : "Router error"), {
+          stack: value.stack
+        }), {
+          route: typeof value.route === "string" ? value.route : routerContext?.route,
+          requestId: typeof value.requestId === "number" ? value.requestId : void 0,
+          navigationId: typeof value.navigationId === "number" ? value.navigationId : void 0
+        });
+        emit("router", { type: "error", payload });
+      })
+    ];
+    const stop = /* @__PURE__ */ __name(() => {
+      const current = routerStops.get(router);
+      if (!current || current.stop !== stop) return;
+      for (const stop2 of stops) stop2();
+      routerStops.delete(router);
+    }, "stop");
+    routerStops.set(router, { stop, refs: 1 });
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const current = routerStops.get(router);
+      if (!current) return;
+      current.refs--;
+      if (current.refs === 0) current.stop();
+    };
+  }
+  __name(attachRouter, "attachRouter");
+  api = {
+    getComponentTree() {
+      const active = [...owners.values()].filter((owner) => !owner.disposed && !isInternalOwnerId(owner.id));
+      const activeIds = new Set(active.map((owner) => owner.id));
+      return active.filter((owner) => owner.parentId === null || !activeIds.has(owner.parentId)).map((owner) => buildComponentNode(owner, activeIds));
+    },
+    getComponent(ownerId) {
+      const active = [...owners.values()].filter((owner) => !owner.disposed && !isInternalOwnerId(owner.id));
+      const activeIds = new Set(active.map((owner) => owner.id));
+      const find = /* @__PURE__ */ __name((records) => {
+        for (const record of records) {
+          if (!activeIds.has(record.id)) continue;
+          if (record.id === ownerId) return buildComponentNode(record, activeIds);
+          const child = find(active.filter((candidate) => candidate.parentId === record.id));
+          if (child) return child;
+        }
+        return null;
+      }, "find");
+      return find(active.filter((owner) => owner.parentId === null || !activeIds.has(owner.parentId)));
+    },
+    getSignals() {
+      return [...signals.values()].filter((signal) => !signal.disposed && !isInternalSignal(signal)).map((signal) => signalInfo(signal));
+    },
+    getSignal(signalId) {
+      const record = signals.get(signalId);
+      return record && !record.disposed && !isInternalSignal(record) ? signalInfo(record) : null;
+    },
+    canMutate() {
+      return allowMutations && !disposed;
+    },
+    setSignalValue(signalId, value) {
+      if (!allowMutations || disposed) return false;
+      const record = signals.get(signalId);
+      if (!record || record.disposed || record.kind !== "state") return false;
+      try {
+        ;
+        record.signal.value = value;
+        return true;
+      } catch (error) {
+        reportError("render", error);
+        return false;
+      }
+    },
+    getDependencies(signalId) {
+      return [...edges.values()].filter((edge) => edge.from === signalId);
+    },
+    getDependents(subscriberId) {
+      return [...edges.values()].filter((edge) => edge.to === subscriberId);
+    },
+    getEffects() {
+      return [...effects.values()].filter((effect2) => !effect2.disposed && !isInternalEffect(effect2)).map(effectInfo);
+    },
+    getUpdates() {
+      return updates.slice();
+    },
+    getLifecycleEvents() {
+      return lifecycleEvents.slice();
+    },
+    getNetworkRequests() {
+      return [...networkRequests.values()];
+    },
+    importSSRRequests,
+    getRouterContext() {
+      return routerContext ? { ...routerContext, dataRequests: [...routerContext.dataRequests] } : null;
+    },
+    attachRouter,
+    getErrors() {
+      return [...errors.values()];
+    },
+    getPerformanceEntries() {
+      const entries = [];
+      for (const update of updates) {
+        entries.push({
+          kind: "update",
+          id: update.id,
+          label: update.signalName,
+          duration: update.duration,
+          timestamp: update.timestamp,
+          status: update.status
+        });
+      }
+      for (const effect2 of effects.values()) {
+        if (effect2.disposed || isInternalEffect(effect2) || effect2.lastDuration <= 0) continue;
+        entries.push({
+          kind: "effect",
+          id: effect2.id,
+          label: effectInfo(effect2).name,
+          duration: effect2.lastDuration,
+          timestamp: effect2.lastExecutionTime,
+          status: effect2.lastRunStatus ?? effect2.status
+        });
+      }
+      for (const request of networkRequests.values()) {
+        if (request.duration === void 0) continue;
+        entries.push({
+          kind: "request",
+          id: request.id,
+          label: `${request.method} ${request.url}`,
+          duration: request.duration,
+          timestamp: request.startedAt,
+          status: request.status
+        });
+      }
+      return entries.sort((left, right) => right.duration - left.duration);
+    },
+    reportError,
+    getCollectionState() {
+      return { paused: collectionPaused };
+    },
+    setCollectionPaused(paused) {
+      collectionPaused = paused;
+      if (paused) pendingUpdates.length = 0;
+      emit("collection", { paused });
+    },
+    clearUpdates() {
+      pendingUpdates.length = 0;
+      updates.length = 0;
+      updateDurations.length = 0;
+      updateCount = 0;
+      emit("collection-cleared", "updates");
+    },
+    clearNetworkRequests() {
+      networkRequests.clear();
+      emit("collection-cleared", "network");
+    },
+    clearErrors() {
+      errors.clear();
+      emit("collection-cleared", "errors");
+    },
+    clearLifecycleEvents() {
+      lifecycleEvents.length = 0;
+      emit("collection-cleared", "lifecycle");
+    },
+    getPerformanceMetrics() {
+      const total = updateDurations.reduce((sum, duration) => sum + duration, 0);
+      const effectDurations = [...effects.values()].filter((effect2) => !effect2.disposed).map((effect2) => effect2.lastDuration).filter((duration) => duration > 0);
+      const requestDurations = [...networkRequests.values()].map((request) => request.duration ?? 0).filter((duration) => duration > 0);
+      return {
+        updateCount,
+        averageUpdateDuration: updateDurations.length === 0 ? 0 : total / updateDurations.length,
+        slowUpdateCount: updateDurations.filter((duration) => duration > slowUpdateThreshold).length,
+        effectExecutionCount,
+        slowEffectCount: effectDurations.filter((duration) => duration > slowUpdateThreshold).length,
+        slowRequestCount: requestDurations.filter((duration) => duration > slowUpdateThreshold).length,
+        maxUpdateDuration: updateDurations.length === 0 ? 0 : Math.max(...updateDurations),
+        maxEffectDuration: effectDurations.length === 0 ? 0 : Math.max(...effectDurations),
+        maxRequestDuration: requestDurations.length === 0 ? 0 : Math.max(...requestDurations)
+      };
+    },
+    takeMemorySnapshot() {
+      return {
+        signalCount: [...signals.values()].filter((signal) => !signal.disposed && !isInternalSignal(signal)).length,
+        effectCount: [...effects.values()].filter((effect2) => !effect2.disposed && !isInternalEffect(effect2)).length,
+        ownerCount: [...owners.values()].filter((owner) => !owner.disposed && !isInternalOwnerId(owner.id)).length,
+        dependencyEdgeCount: edges.size,
+        leakedOwners: [...owners.values()].filter((owner) => owner.disposed).length
+      };
+    },
+    exportDiagnostics() {
+      return {
+        version: 1,
+        exportedAt: Date.now(),
+        updates: api.getUpdates(),
+        lifecycle: api.getLifecycleEvents(),
+        network: api.getNetworkRequests(),
+        errors: api.getErrors(),
+        performance: api.getPerformanceMetrics(),
+        memory: api.takeMemorySnapshot(),
+        extensions: getExtensionSnapshot()
+      };
+    },
+    importDiagnostics(snapshot) {
+      const imported = parseDiagnosticSnapshot(snapshot);
+      updates.splice(0, updates.length, ...imported.updates.slice(-maxUpdates).map((update) => sanitizeImportedUpdate(update, privacy)));
+      lifecycleEvents.splice(0, lifecycleEvents.length, ...imported.lifecycle.slice(-maxUpdates));
+      networkRequests.clear();
+      for (const request of imported.network.slice(-maxUpdates)) networkRequests.set(request.id, sanitizeImportedRequest(request, privacy));
+      errors.clear();
+      for (const error of imported.errors.slice(-maxUpdates)) {
+        const normalized = sanitizeImportedError(error);
+        errors.set(diagnosticErrorKey(normalized), normalized);
+      }
+      updateDurations.splice(0, updateDurations.length, ...updates.map((update) => update.duration));
+      updateCount = imported.performance.updateCount;
+      effectExecutionCount = imported.performance.effectExecutionCount;
+      emit("collection", { imported: true });
+    },
+    registerInspector(id, inspector) {
+      if (disposed || !id) return () => void 0;
+      inspectors.set(id, inspector);
+      emit("extension", { type: "inspector", id });
+      return () => {
+        if (inspectors.get(id) === inspector) inspectors.delete(id);
+      };
+    },
+    registerTimeline(id, timeline = {}) {
+      if (disposed || !id) return () => void 0;
+      timelines.set(id, timeline);
+      emit("extension", { type: "timeline", id });
+      return () => {
+        if (timelines.get(id) === timeline) timelines.delete(id);
+      };
+    },
+    registerMetric(id, metric) {
+      if (disposed || !id) return () => void 0;
+      metrics.set(id, metric);
+      emit("extension", { type: "metric", id });
+      return () => {
+        if (metrics.get(id) === metric) metrics.delete(id);
+      };
+    },
+    getExtensionSnapshot,
+    inspectExtension(id, value) {
+      const inspector = inspectors.get(id);
+      if (!inspector) return void 0;
+      return safeExtensionCall(
+        () => serializeForDevTools(inspector.inspect(value), /* @__PURE__ */ new Set(), 0, privacy),
+        void 0
+      );
+    },
+    onUpdate(callback) {
+      return subscribe("update", callback);
+    },
+    subscribe,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (getDebugHooks() === hooks) setDebugHooks(previousHooks);
+      if (getRuntimeDebugHooks() === runtimeHooks) setRuntimeDebugHooks(previousRuntimeHooks);
+      if (getHTTPDebugHooks() === httpHooks) setHTTPDebugHooks(previousHTTPHooks);
+      if (activeDevTools === api) activeDevTools = null;
+      if (target && target.__VOBS_DEVTOOLS__ === api) {
+        if (previousGlobal) target.__VOBS_DEVTOOLS__ = previousGlobal;
+        else delete target.__VOBS_DEVTOOLS__;
+      }
+      target?.removeEventListener?.("error", onGlobalError);
+      target?.removeEventListener?.("unhandledrejection", onUnhandledRejection);
+      listeners.clear();
+      for (const { stop } of [...routerStops.values()]) stop();
+      routerStops.clear();
+      routerContext = null;
+      pendingUpdates.length = 0;
+      pendingFlushScheduled = false;
+      activeEffectId = null;
+      inspectors.clear();
+      timelines.clear();
+      metrics.clear();
+    }
+  };
+  if (shouldExpose && target) target.__VOBS_DEVTOOLS__ = api;
+  activeDevTools = api;
+  if (options.router) attachRouter(options.router);
+  return api;
+}
+__name(createDevTools, "createDevTools");
+function enableDevTools(options = {}) {
+  return createDevTools(options);
+}
+__name(enableDevTools, "enableDevTools");
+function disableDevTools() {
+  activeDevTools?.dispose();
+}
+__name(disableDevTools, "disableDevTools");
+function getDevTools() {
+  return activeDevTools;
+}
+__name(getDevTools, "getDevTools");
+function connectDevTools(options = {}) {
+  const target = options.target ?? defaultMessageTarget();
+  const api = options.api ?? activeDevTools;
+  if (!target || !api) return () => void 0;
+  const send = /* @__PURE__ */ __name((message) => {
+    try {
+      target.postMessage(message, "*");
+    } catch {
+    }
+  }, "send");
+  const unsubscribes = DEVTOOLS_EVENTS.map((event) => api.subscribe(event, (...args) => {
+    send({
+      source: "vobs-devtools",
+      type: "event",
+      event,
+      payload: args.length === 1 ? args[0] : args
+    });
+  }));
+  const onMessage = /* @__PURE__ */ __name((event) => {
+    const request = parseRequest(event.data);
+    if (!request) return;
+    try {
+      send({
+        source: "vobs-devtools",
+        type: "response",
+        id: request.id,
+        ok: true,
+        result: invokeRequest(api, request)
+      });
+    } catch (error) {
+      send({
+        source: "vobs-devtools",
+        type: "response",
+        id: request.id,
+        ok: false,
+        error: toErrorMessage(error)
+      });
+    }
+  }, "onMessage");
+  target.addEventListener("message", onMessage);
+  return () => {
+    target.removeEventListener("message", onMessage);
+    for (const unsubscribe of unsubscribes) unsubscribe();
+  };
+}
+__name(connectDevTools, "connectDevTools");
+function devtoolsPlugin(options = {}) {
+  return {
+    name: "@vobs/devtools",
+    version: "0.1.0",
+    install(context) {
+      if (options.enabled === false) return;
+      const devtools = createDevTools(options);
+      const removeErrorObserver = context.onError((error) => {
+        const phase = readErrorProperty(error, "vobsCode") === "VOBS_HYDRATION_MISMATCH" || Boolean(readErrorProperty(error, "vobsHydration")) ? "hydration" : "application";
+        devtools.reportError(phase, error, {
+          handled: false,
+          recovery: "propagated"
+        });
+      });
+      return () => {
+        removeErrorObserver();
+        devtools.dispose();
+      };
+    }
+  };
+}
+__name(devtoolsPlugin, "devtoolsPlugin");
+function defaultTarget() {
+  return typeof window === "undefined" ? void 0 : window;
+}
+__name(defaultTarget, "defaultTarget");
+function defaultMessageTarget() {
+  return typeof window === "undefined" ? void 0 : window;
+}
+__name(defaultMessageTarget, "defaultMessageTarget");
+function parseRequest(value) {
+  if (!value || typeof value !== "object") return null;
+  const request = value;
+  if (request.source !== "vobs-devtools" || request.type !== "request") return null;
+  if (typeof request.id !== "string" || typeof request.method !== "string") return null;
+  return request;
+}
+__name(parseRequest, "parseRequest");
+function invokeRequest(api, request) {
+  const args = request.args ?? [];
+  switch (request.method) {
+    case "getComponentTree":
+      return api.getComponentTree();
+    case "getComponent":
+      return api.getComponent(String(args[0] ?? ""));
+    case "getSignals":
+      return api.getSignals();
+    case "getSignal":
+      return api.getSignal(String(args[0] ?? ""));
+    case "canMutate":
+      return api.canMutate();
+    case "setSignalValue":
+      return api.setSignalValue(String(args[0] ?? ""), args[1]);
+    case "getDependencies":
+      return api.getDependencies(String(args[0] ?? ""));
+    case "getDependents":
+      return api.getDependents(String(args[0] ?? ""));
+    case "getEffects":
+      return api.getEffects();
+    case "getUpdates":
+      return api.getUpdates();
+    case "getLifecycleEvents":
+      return api.getLifecycleEvents();
+    case "getNetworkRequests":
+      return api.getNetworkRequests();
+    case "importSSRRequests":
+      api.importSSRRequests(args[0]);
+      return void 0;
+    case "getRouterContext":
+      return api.getRouterContext();
+    case "getErrors":
+      return api.getErrors();
+    case "getPerformanceEntries":
+      return api.getPerformanceEntries();
+    case "getCollectionState":
+      return api.getCollectionState();
+    case "setCollectionPaused":
+      api.setCollectionPaused(Boolean(args[0]));
+      return void 0;
+    case "clearUpdates":
+      api.clearUpdates();
+      return void 0;
+    case "clearNetworkRequests":
+      api.clearNetworkRequests();
+      return void 0;
+    case "clearErrors":
+      api.clearErrors();
+      return void 0;
+    case "clearLifecycleEvents":
+      api.clearLifecycleEvents();
+      return void 0;
+    case "getPerformanceMetrics":
+      return api.getPerformanceMetrics();
+    case "takeMemorySnapshot":
+      return api.takeMemorySnapshot();
+    case "exportDiagnostics":
+      return api.exportDiagnostics();
+    case "importDiagnostics":
+      api.importDiagnostics(args[0]);
+      return void 0;
+    case "getExtensionSnapshot":
+      return api.getExtensionSnapshot();
+    case "inspectExtension":
+      return api.inspectExtension(String(args[0] ?? ""), args[1]);
+    default:
+      throw new Error(`Vobs DevTools: \u672A\u77E5\u8BF7\u6C42 ${request.method}`);
+  }
+}
+__name(invokeRequest, "invokeRequest");
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(toErrorMessage, "toErrorMessage");
+function toDebugError(error, phase) {
+  const normalized = normalizeVobsError(error);
+  const value = error;
+  const source = value?.vobsSource ?? normalized.location;
+  return {
+    name: typeof value?.name === "string" ? value.name : normalized.name,
+    message: typeof value?.message === "string" ? value.message : normalized.message,
+    stack: typeof value?.stack === "string" ? value.stack : normalized.stack,
+    phase,
+    source: source && typeof source.file === "string" ? `${source.file}:${source.line ?? 0}:${source.column ?? 0}` : void 0,
+    location: source && typeof source.file === "string" && typeof source.line === "number" && typeof source.column === "number" ? { file: source.file, line: source.line, column: source.column } : void 0,
+    code: typeof value?.vobsCode === "string" ? value.vobsCode : typeof value?.code === "string" ? value.code : void 0,
+    hint: typeof value?.vobsHint === "string" ? value.vobsHint : void 0,
+    cause: normalized.cause instanceof Error ? `${normalized.cause.name}: ${normalized.cause.message}` : normalized.cause === void 0 ? void 0 : String(normalized.cause),
+    fix: normalized.fix,
+    hydration: value?.vobsHydration && typeof value.vobsHydration === "object" ? value.vobsHydration : void 0
+  };
+}
+__name(toDebugError, "toDebugError");
+var FRAMEWORK_ERROR_RULES = [
+  { pattern: /响应式更新超过\s*100\s*轮/, origin: "framework", code: "VOBS_REACTIVITY_LOOP", hint: "\u68C0\u67E5 Effect \u662F\u5426\u5728\u6267\u884C\u65F6\u6301\u7EED\u5199\u5165\u5B83\u4F9D\u8D56\u7684 Signal\u3002" },
+  { pattern: /Fragment: (?:不能跨父节点移动|Fragment 不属于指定父节点|找不到结束锚点)/, origin: "framework", code: "VOBS_FRAGMENT_INVARIANT", hint: "\u68C0\u67E5 Fragment \u7684\u7236\u8282\u70B9\u548C\u63D2\u5165/\u5220\u9664\u987A\u5E8F\uFF0C\u901A\u5E38\u8868\u793A\u8FD0\u884C\u65F6\u6811\u7ED3\u6784\u5DF2\u4E0D\u4E00\u81F4\u3002" },
+  { pattern: /当前渲染器不支持 Hydration/, origin: "usage", code: "VOBS_HYDRATION_UNSUPPORTED", hint: "\u8BF7\u4F7F\u7528\u652F\u6301 Hydration \u7684 Renderer\uFF0C\u6216\u6539\u7528 app.mount()\u3002" },
+  { pattern: /(?:HydrationMismatchError|Vobs hydration:|服务端 DOM 与客户端渲染结构不一致|节点位置与客户端渲染结果不一致)/, origin: "framework", code: "VOBS_HYDRATION_MISMATCH", hint: "\u68C0\u67E5\u670D\u52A1\u7AEF\u548C\u5BA2\u6237\u7AEF\u662F\u5426\u751F\u6210\u4E86\u76F8\u540C\u7684\u8282\u70B9\u7ED3\u6784\u4E0E\u521D\u59CB\u72B6\u6001\u3002" },
+  { pattern: /渲染器未初始化/, origin: "usage", code: "VOBS_RENDERER_NOT_INITIALIZED", hint: "\u8BF7\u5728\u5E94\u7528 mount \u6216 hydrate \u540E\u8C03\u7528 Runtime DOM API\u3002" },
+  { pattern: /节点不属于指定父节点/, origin: "framework", code: "VOBS_DOM_PARENT_MISMATCH", hint: "\u68C0\u67E5\u8282\u70B9\u662F\u5426\u88AB\u91CD\u590D\u79FB\u52A8\u3001\u5220\u9664\uFF0C\u6216\u88AB\u9519\u8BEF\u7684 Renderer \u5B9E\u4F8B\u7BA1\u7406\u3002" }
+];
+function classifyError(phase, error, context) {
+  const message = toErrorMessage(error);
+  const explicitCode = context.code ?? readErrorProperty(error, "vobsCode") ?? readErrorProperty(error, "code") ?? extractErrorCode(message);
+  const frameworkRule = FRAMEWORK_ERROR_RULES.find((rule) => rule.pattern.test(message));
+  if (frameworkRule) return { origin: context.origin ?? frameworkRule.origin, code: explicitCode ?? frameworkRule.code, hint: context.hint ?? frameworkRule.hint };
+  if (context.origin) return { origin: context.origin, code: explicitCode, hint: context.hint };
+  if (explicitCode && isUsageErrorCode(explicitCode) || /^Vobs(?:\s|:)|^VOBS_/.test(message) && /必须|不能为空|找不到|缺少|不存在|无效|不能直接|重复|未配置|已销毁/.test(message)) {
+    return { origin: "usage", code: explicitCode, hint: context.hint ?? "\u68C0\u67E5\u8C03\u7528\u53C2\u6570\u3001Owner \u4F5C\u7528\u57DF\u548C\u76F8\u5173\u63D2\u4EF6\u662F\u5426\u5DF2\u5B89\u88C5\u3002" };
+  }
+  if (phase === "global") return { origin: "unknown", code: explicitCode, hint: context.hint };
+  return { origin: "application", code: explicitCode, hint: context.hint };
+}
+__name(classifyError, "classifyError");
+function isUsageErrorCode(code) {
+  return /^(?:INVALID_|.*_(?:CONTEXT_MISSING|CONTEXT_DISPOSED|OPTIONS|MISSING|UNAVAILABLE))/.test(code);
+}
+__name(isUsageErrorCode, "isUsageErrorCode");
+function extractErrorCode(message) {
+  return message.match(/\b[A-Z][A-Z0-9_]{2,}_[A-Z0-9_]+\b/)?.[0];
+}
+__name(extractErrorCode, "extractErrorCode");
+function readErrorProperty(error, key) {
+  if (!error || typeof error !== "object" && typeof error !== "function") return void 0;
+  const value = error[key];
+  return typeof value === "string" ? value : void 0;
+}
+__name(readErrorProperty, "readErrorProperty");
+function mergeRecovery(previous, next) {
+  if (!next) return previous;
+  if (next === "retrying") return next;
+  if (next === "recovered") return next;
+  if (next === "fallback") return next;
+  if (previous === "fallback") return previous;
+  return next;
+}
+__name(mergeRecovery, "mergeRecovery");
+function diagnosticErrorKey(error) {
+  return [error.origin, error.code ?? error.name, error.message, error.source ?? "", error.component ?? ""].join(":");
+}
+__name(diagnosticErrorKey, "diagnosticErrorKey");
+function sanitizeImportedError(error) {
+  const phase = error.phase ?? "global";
+  return {
+    ...error,
+    phase,
+    phases: Array.isArray(error.phases) && error.phases.length > 0 ? error.phases : [phase],
+    origin: error.origin ?? "unknown",
+    handled: error.handled === true,
+    recovery: error.recovery ?? "propagated"
+  };
+}
+__name(sanitizeImportedError, "sanitizeImportedError");
+function parseDiagnosticSnapshot(value) {
+  if (!value || typeof value !== "object") throw new Error("Vobs DevTools: invalid diagnostic snapshot");
+  const snapshot = value;
+  if (snapshot.version !== 1 || !Array.isArray(snapshot.updates) || !Array.isArray(snapshot.lifecycle) || !Array.isArray(snapshot.network) || !Array.isArray(snapshot.errors) || !snapshot.performance || !snapshot.memory) {
+    throw new Error("Vobs DevTools: unsupported diagnostic snapshot");
+  }
+  if (!snapshot.updates.every((item) => isRecord(item) && typeof item.id === "string" && typeof item.duration === "number" && Array.isArray(item.effects) && Array.isArray(item.affectedSignals) && Array.isArray(item.affectedEffects) && Array.isArray(item.domUpdates)) || !snapshot.lifecycle.every((item) => isRecord(item) && typeof item.id === "string" && typeof item.type === "string") || !snapshot.network.every((item) => isRecord(item) && typeof item.id === "number" && typeof item.url === "string" && isRecord(item.headers)) || !snapshot.errors.every((item) => isRecord(item) && typeof item.id === "number" && typeof item.message === "string") || !isRecord(snapshot.performance) || typeof snapshot.performance.updateCount !== "number" || typeof snapshot.performance.effectExecutionCount !== "number" || !isRecord(snapshot.memory)) {
+    throw new Error("Vobs DevTools: malformed diagnostic snapshot");
+  }
+  return snapshot;
+}
+__name(parseDiagnosticSnapshot, "parseDiagnosticSnapshot");
+function parseSSRRequestSnapshot(value) {
+  const candidate = value && typeof value === "object" && !Array.isArray(value) ? value : { version: 1, environment: "server", requests: value };
+  if (candidate.version !== 1 || candidate.environment !== "server" || !Array.isArray(candidate.requests)) {
+    throw new Error("Vobs DevTools: invalid SSR request snapshot");
+  }
+  if (!candidate.requests.every((item) => isRecord(item) && typeof item.id === "number" && typeof item.url === "string" && typeof item.method === "string" && typeof item.startedAt === "number" && isRecord(item.headers))) {
+    throw new Error("Vobs DevTools: malformed SSR request snapshot");
+  }
+  return candidate.requests;
+}
+__name(parseSSRRequestSnapshot, "parseSSRRequestSnapshot");
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function normalizePrivacyOptions(options) {
+  return {
+    redactedHeaders: options?.redactedHeaders ?? [],
+    redactedFields: options?.redactedFields ?? [],
+    redactDomValues: options?.redactDomValues ?? false,
+    replacement: options?.replacement ?? "[Redacted]"
+  };
+}
+__name(normalizePrivacyOptions, "normalizePrivacyOptions");
+function sanitizeImportedUpdate(update, privacy) {
+  return {
+    ...update,
+    previousValue: serializeForDevTools(update.previousValue, /* @__PURE__ */ new Set(), 0, privacy),
+    nextValue: serializeForDevTools(update.nextValue, /* @__PURE__ */ new Set(), 0, privacy),
+    domUpdates: update.domUpdates.map((mutation) => ({
+      ...mutation,
+      previousValue: privacy.redactDomValues ? privacy.replacement : serializeForDevTools(mutation.previousValue, /* @__PURE__ */ new Set(), 0, privacy),
+      nextValue: privacy.redactDomValues ? privacy.replacement : serializeForDevTools(mutation.nextValue, /* @__PURE__ */ new Set(), 0, privacy)
+    }))
+  };
+}
+__name(sanitizeImportedUpdate, "sanitizeImportedUpdate");
+function sanitizeImportedRequest(request, privacy) {
+  return {
+    ...request,
+    headers: redactHeaders(request.headers, privacy),
+    requestBody: serializeForDevTools(request.requestBody, /* @__PURE__ */ new Set(), 0, privacy),
+    responseBody: serializeForDevTools(request.responseBody, /* @__PURE__ */ new Set(), 0, privacy)
+  };
+}
+__name(sanitizeImportedRequest, "sanitizeImportedRequest");
+function redactHeaders(headers, privacy) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (/authorization|cookie|token|password|secret|api[-_]?key/i.test(key) || privacy.redactedHeaders.some((fragment) => key.toLowerCase().includes(fragment.toLowerCase()))) continue;
+    result[key] = value;
+  }
+  return result;
+}
+__name(redactHeaders, "redactHeaders");
+function serializeForDevTools(value, seen = /* @__PURE__ */ new Set(), depth = 0, privacy) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
+  if (typeof value === "bigint") return `${value}n`;
+  if (typeof value === "undefined") return void 0;
+  if (typeof value === "function") return `[Function ${value.name || "anonymous"}]`;
+  if (typeof value === "symbol") return String(value);
+  if (depth >= 4) return "[MaxDepth]";
+  const object = value;
+  if (seen.has(object)) return "[Circular]";
+  seen.add(object);
+  try {
+    if (value instanceof Date) return value.toISOString();
+    if (value instanceof Error) return { name: value.name, message: value.message };
+    if (Array.isArray(value)) return value.slice(0, 100).map((item) => serializeForDevTools(item, seen, depth + 1, privacy));
+    const result = {};
+    for (const key of Object.keys(object).slice(0, 100)) {
+      try {
+        if (privacy?.redactedFields.some((field) => field.toLowerCase() === key.toLowerCase())) {
+          result[key] = privacy.replacement;
+        } else {
+          result[key] = serializeForDevTools(object[key], seen, depth + 1, privacy);
+        }
+      } catch {
+        result[key] = "[Uninspectable]";
+      }
+    }
+    return result;
+  } finally {
+    seen.delete(object);
+  }
+}
+__name(serializeForDevTools, "serializeForDevTools");
+
+export { DEVTOOLS_EVENTS, DEVTOOLS_REACTIVITY_EVENTS, connectDevTools, createDevTools, devtoolsPlugin, disableDevTools, enableDevTools, getDevTools };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map