@omniaura/solid-pulse 0.1.0

package/dist/index.js

@@ -0,0 +1,987 @@
+import {
+  DEFAULT_PATH,
+  PROTOCOL_VERSION,
+  isServerFrame
+} from "./chunk-WIMCBTHZ.js";
+import {
+  redactText,
+  redactUrl
+} from "./chunk-5FYH2KEZ.js";
+import {
+  FlashOverlay,
+  OWN_ATTR
+} from "./chunk-IXNWEUNF.js";
+import {
+  EventBus,
+  PulseController
+} from "./chunk-C72EYM65.js";
+
+// src/solid/instrument.ts
+import { DEV, getOwner, sharedConfig } from "solid-js";
+var MAX_RECENT_DISPOSED = 64;
+var MAX_ELEMENTS_PER_COMPONENT = 8;
+function installSolid(controller) {
+  const bus = controller.bus;
+  const hooks = DEV?.hooks;
+  const compByOwner = /* @__PURE__ */ new WeakMap();
+  const live = /* @__PURE__ */ new Map();
+  const elements = /* @__PURE__ */ new Map();
+  const recentDisposed = /* @__PURE__ */ new Map();
+  let nextId = 1;
+  let flushId = 0;
+  let flushOpen = false;
+  let runs = 0;
+  let byKind = { memo: 0, computed: 0, effect: 0, render: 0 };
+  let byComponent = /* @__PURE__ */ new Map();
+  let componentsRan = /* @__PURE__ */ new Map();
+  let lastClosed = [];
+  let roots = 0;
+  const now = () => performance.now();
+  function toRef(info) {
+    if (!info) return null;
+    const chain = [];
+    let cur = info;
+    while (cur && chain.length < 8) {
+      chain.push(cur.name);
+      cur = cur.parent === null ? void 0 : live.get(cur.parent);
+    }
+    return { id: info.id, name: info.name, chain };
+  }
+  function componentInfoFor(owner) {
+    let cur = owner;
+    let hops = 0;
+    while (cur && hops++ < 200) {
+      const info = compByOwner.get(cur);
+      if (info) return info;
+      cur = cur.owner;
+    }
+    return null;
+  }
+  function ensureFlush() {
+    if (flushOpen) return;
+    flushOpen = true;
+    flushId++;
+    queueMicrotask(closeFlush);
+  }
+  function closeFlush() {
+    if (!flushOpen) return;
+    flushOpen = false;
+    lastClosed = [...componentsRan.values()];
+    if (runs > 0 || componentsRan.size > 0) {
+      const topComponents = {};
+      const sorted = [...byComponent.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+      for (const [name, n] of sorted) topComponents[name] = n;
+      bus.emit(
+        "solid.flush",
+        {
+          computations: runs,
+          byKind: { ...byKind },
+          byComponent: topComponents,
+          components: lastClosed.map((c) => c.name)
+        },
+        { flush: flushId, component: lastClosed.length === 1 ? lastClosed[0] : null }
+      );
+    }
+    runs = 0;
+    byKind = { memo: 0, computed: 0, effect: 0, render: 0 };
+    byComponent = /* @__PURE__ */ new Map();
+    componentsRan = /* @__PURE__ */ new Map();
+  }
+  function kindOf(owner) {
+    if (owner.pure) return owner.comparator !== void 0 ? "memo" : "computed";
+    return owner.user ? "effect" : "render";
+  }
+  function wrapComputation(owner) {
+    const orig = owner.fn;
+    if (typeof orig !== "function") return;
+    let kind = "render";
+    let first = true;
+    let isComponent = false;
+    owner.fn = function pulseWrapped(...args) {
+      if (first) {
+        first = false;
+        if (owner.component) {
+          isComponent = true;
+          registerComponent(owner);
+        } else {
+          kind = kindOf(owner);
+        }
+        return orig.apply(this, args);
+      }
+      if (isComponent) {
+        if (controller.isOn("solid")) bus.emit("pulse.note", { note: `component body re-executed: ${owner.name ?? "?"}` });
+        return orig.apply(this, args);
+      }
+      if (controller.isOn("solid")) {
+        ensureFlush();
+        runs++;
+        byKind[kind]++;
+        const info = componentInfoFor(owner);
+        if (info) {
+          byComponent.set(info.name, (byComponent.get(info.name) ?? 0) + 1);
+          if (!componentsRan.has(info.id)) componentsRan.set(info.id, toRef(info));
+        }
+        if (controller.isOn("verboseComputations")) {
+          bus.emit("solid.computation", { kind, name: owner.name ?? null }, { flush: flushId, component: toRef(info) });
+        }
+      }
+      return orig.apply(this, args);
+    };
+  }
+  function registerComponent(owner) {
+    const name = owner.name || owner.component?.name || "Anonymous";
+    const parent = componentInfoFor(owner.owner);
+    const t = now();
+    const info = {
+      id: nextId++,
+      name,
+      parent: parent?.id ?? null,
+      hydrated: Boolean(sharedConfig.context),
+      mountedAt: t,
+      mountedWall: Date.now(),
+      flush: flushId,
+      disposedAt: null
+    };
+    compByOwner.set(owner, info);
+    live.set(info.id, info);
+    const key = `${name}|${parent?.name ?? ""}`;
+    if (controller.isOn("solid")) ensureFlush();
+    const disposed = recentDisposed.get(key);
+    const remount = disposed !== void 0 && flushId - disposed.flush <= 1 && t - disposed.t < 250;
+    if (disposed) recentDisposed.delete(key);
+    if (controller.isOn("solid")) {
+      ensureFlush();
+      const ref = toRef(info);
+      componentsRan.set(info.id, ref);
+      bus.emit(
+        remount ? "solid.component.remount" : "solid.component.mount",
+        {
+          name,
+          parent: parent?.name ?? null,
+          hydrated: info.hydrated,
+          id: info.id,
+          ...remount ? { gapMs: Math.round((t - disposed.t) * 100) / 100 } : {}
+        },
+        { flush: flushId, component: ref }
+      );
+    }
+    (owner.cleanups ||= []).push(() => {
+      const d = now();
+      if (controller.isOn("solid")) ensureFlush();
+      info.disposedAt = d;
+      live.delete(info.id);
+      elements.delete(info.id);
+      recentDisposed.set(key, { t: d, flush: flushId });
+      while (recentDisposed.size > MAX_RECENT_DISPOSED) {
+        const oldest = recentDisposed.keys().next().value;
+        if (oldest === void 0) break;
+        recentDisposed.delete(oldest);
+      }
+      if (controller.isOn("solid")) {
+        ensureFlush();
+        bus.emit(
+          "solid.component.dispose",
+          { name, parent: parent?.name ?? null, id: info.id, lifetimeMs: Math.round((d - info.mountedAt) * 100) / 100 },
+          { flush: flushId, component: toRef(info) }
+        );
+      }
+    });
+  }
+  let prevAfterCreateOwner = null;
+  let prevAfterUpdate = null;
+  const available = Boolean(hooks);
+  if (hooks) {
+    prevAfterCreateOwner = hooks.afterCreateOwner ?? null;
+    prevAfterUpdate = hooks.afterUpdate ?? null;
+    hooks.afterCreateOwner = ((owner) => {
+      prevAfterCreateOwner?.(owner);
+      try {
+        if (typeof owner.fn === "function") wrapComputation(owner);
+        else if (!owner.owner) {
+          roots++;
+          if (controller.isOn("solid")) bus.emit("solid.root", { roots });
+        }
+      } catch (err) {
+        console.warn("[solid-pulse] instrumentation error", err);
+      }
+    });
+    hooks.afterUpdate = () => {
+      prevAfterUpdate?.();
+      closeFlush();
+    };
+  }
+  const api = {
+    available,
+    flushId: () => flushId,
+    lastFlushComponents: () => flushOpen ? [...componentsRan.values()] : lastClosed,
+    componentFor: (owner) => toRef(componentInfoFor(owner)),
+    currentComponent: () => toRef(componentInfoFor(getOwner())),
+    components: () => [...live.values()],
+    attachElement(componentId, el) {
+      const list = elements.get(componentId) ?? [];
+      if (list.some((r) => r.deref() === el)) return;
+      list.push(new WeakRef(el));
+      while (list.length > MAX_ELEMENTS_PER_COMPONENT) list.shift();
+      elements.set(componentId, list);
+    },
+    elementsFor(componentId) {
+      const out = [];
+      for (const ref of elements.get(componentId) ?? []) {
+        const el = ref.deref();
+        if (el && el.isConnected) out.push(el);
+      }
+      return out;
+    },
+    rectFor(component) {
+      let els = api.elementsFor(component.id);
+      if (els.length === 0 && typeof document !== "undefined") {
+        const escaped = component.name.replace(/["\\]/g, "\\$&");
+        els = [...document.querySelectorAll(`[data-solid-component="${escaped}"]`)].slice(0, 4);
+      }
+      let x1 = Infinity, y1 = Infinity, x2 = -Infinity, y2 = -Infinity;
+      for (const el of els) {
+        const r = el.getBoundingClientRect();
+        if (r.width === 0 && r.height === 0) continue;
+        x1 = Math.min(x1, r.left);
+        y1 = Math.min(y1, r.top);
+        x2 = Math.max(x2, r.right);
+        y2 = Math.max(y2, r.bottom);
+      }
+      if (!Number.isFinite(x1)) return null;
+      return { x: x1, y: y1, w: x2 - x1, h: y2 - y1 };
+    },
+    dispose() {
+      if (hooks) {
+        hooks.afterCreateOwner = prevAfterCreateOwner;
+        hooks.afterUpdate = prevAfterUpdate;
+      }
+    }
+  };
+  controller.register(
+    { name: "inspect.components", summary: "Live component instances (name, parent, hydrated, age).", args: { name: "substring filter" }, ui: "Pulse tab \u203A Components" },
+    (a) => {
+      const needle = a.name === void 0 ? "" : String(a.name).toLowerCase();
+      const t = now();
+      return api.components().filter((c) => !needle || c.name.toLowerCase().includes(needle)).map((c) => ({ id: c.id, name: c.name, parent: c.parent === null ? null : live.get(c.parent)?.name ?? null, hydrated: c.hydrated, ageMs: Math.round(t - c.mountedAt), elements: api.elementsFor(c.id).length }));
+    }
+  );
+  controller.register(
+    { name: "inspect.solid", summary: "Solid dev-hook availability, root count, live component count, current flush id." },
+    () => ({ available, roots, liveComponents: live.size, flush: flushId })
+  );
+  if (!available) {
+    bus.emit("pulse.note", { note: "solid-js DEV hooks unavailable (production build?) \u2014 Solid instrumentation disabled" });
+  }
+  return api;
+}
+
+// src/solid/dom.ts
+var MAX_TARGETS_PER_BATCH = 40;
+var MAX_TARGETS_IN_EVENT = 25;
+var MAX_TRACKED_SCROLLERS = 50;
+var MAX_DETACHED = 200;
+var DETACHED_TTL_MS = 3e3;
+function describeElement(el, withRect = true) {
+  const out = { tag: el.tagName.toLowerCase() };
+  if (el.id) out.id = el.id;
+  const testId = el.getAttribute("data-testid");
+  if (testId) out.testId = testId;
+  const cls = typeof el.className === "string" ? el.className.trim() : "";
+  if (cls) out.classes = cls.length > 80 ? cls.slice(0, 77) + "..." : cls;
+  const comp = el.closest("[data-solid-component]");
+  out.component = comp ? comp.getAttribute("data-solid-component") : null;
+  const src = el.closest("[data-solid-source]");
+  out.source = src ? src.getAttribute("data-solid-source") : null;
+  if (withRect) {
+    const r = el.getBoundingClientRect();
+    out.rect = { x: r.left, y: r.top, w: r.width, h: r.height };
+  }
+  return out;
+}
+function toSelector(el) {
+  if (el.id) return `#${cssEscape(el.id)}`;
+  const testId = el.getAttribute("data-testid");
+  if (testId) return `[data-testid="${testId.replace(/"/g, '\\"')}"]`;
+  const parts = [];
+  let cur = el;
+  while (cur && parts.length < 5 && cur !== document.documentElement) {
+    const parent = cur.parentElement;
+    let part = cur.tagName.toLowerCase();
+    if (parent) {
+      const siblings = [...parent.children].filter((c) => c.tagName === cur.tagName);
+      if (siblings.length > 1) part += `:nth-of-type(${siblings.indexOf(cur) + 1})`;
+    }
+    parts.unshift(part);
+    if (cur.id) {
+      parts[0] = `#${cssEscape(cur.id)}`;
+      break;
+    }
+    cur = parent;
+  }
+  return parts.join(" > ");
+}
+function cssEscape(s) {
+  return typeof CSS !== "undefined" && CSS.escape ? CSS.escape(s) : s.replace(/[^a-zA-Z0-9_-]/g, "\\$&");
+}
+function nextFrame(fn) {
+  let done = false;
+  const run = () => {
+    if (done) return;
+    done = true;
+    fn();
+  };
+  if (typeof requestAnimationFrame === "function") requestAnimationFrame(run);
+  setTimeout(run, 50);
+}
+function installDom(controller, solid, overlay) {
+  const bus = controller.bus;
+  const scrollTops = /* @__PURE__ */ new Map();
+  let lastFocused = null;
+  const detached = /* @__PURE__ */ new Map();
+  const now = () => performance.now();
+  const isOwn = (n) => {
+    const el = n instanceof Element ? n : n.parentElement;
+    return el ? el.closest(`[${OWN_ATTR}]`) !== null : false;
+  };
+  const onScroll = (e) => {
+    const t = e.target;
+    if (!(t instanceof Element)) return;
+    scrollTops.delete(t);
+    scrollTops.set(t, t.scrollTop);
+    if (scrollTops.size > MAX_TRACKED_SCROLLERS) {
+      const oldest = scrollTops.keys().next().value;
+      if (oldest) scrollTops.delete(oldest);
+    }
+  };
+  const onFocusIn = (e) => {
+    if (e.target instanceof Element && !isOwn(e.target)) lastFocused = e.target;
+  };
+  document.addEventListener("scroll", onScroll, { capture: true, passive: true });
+  document.addEventListener("focusin", onFocusIn, true);
+  const focusPoll = setInterval(() => {
+    const active = document.activeElement;
+    if (active && active !== document.body && active !== document.documentElement && !isOwn(active)) lastFocused = active;
+  }, 200);
+  function attributionFor(target, flushComps) {
+    if (flushComps.length === 1) return flushComps[0];
+    const named = target.closest("[data-solid-component]")?.getAttribute("data-solid-component");
+    if (named) {
+      const match = flushComps.find((c) => c.name === named);
+      if (match) return match;
+      return { id: -1, name: named };
+    }
+    return flushComps.length > 1 ? null : null;
+  }
+  function pruneDetached(t) {
+    for (const [node, rec] of detached) {
+      if (t - rec.t > DETACHED_TTL_MS) detached.delete(node);
+      else break;
+    }
+    while (detached.size > MAX_DETACHED) {
+      const oldest = detached.keys().next().value;
+      if (oldest === void 0) break;
+      detached.delete(oldest);
+    }
+  }
+  const observer = new MutationObserver((records) => {
+    if (globalThis.__PULSE_DEBUG) console.error("DBG-MO", records.map((r) => `${r.type}:${r.target.tagName ?? "?"}:+${r.addedNodes.length}/-${r.removedNodes.length}`).join(" "), "dom on:", controller.isOn("dom"));
+    if (!controller.isOn("dom")) return;
+    const t = now();
+    const flush = solid?.flushId() ?? 0;
+    const flushComps = solid?.lastFlushComponents() ?? [];
+    const targets = /* @__PURE__ */ new Map();
+    const detachedNow = [];
+    const reattached = [];
+    for (const r of records) {
+      const target = r.target instanceof Element ? r.target : r.target.parentElement;
+      if (!target || isOwn(target)) continue;
+      let info = targets.get(target);
+      if (!info) {
+        if (targets.size >= MAX_TARGETS_PER_BATCH) continue;
+        info = { types: /* @__PURE__ */ new Set(), attrs: /* @__PURE__ */ new Set(), added: 0, removed: 0 };
+        targets.set(target, info);
+      }
+      info.types.add(r.type);
+      if (r.type === "attributes" && r.attributeName) info.attrs.add(r.attributeName);
+      info.added += r.addedNodes.length;
+      info.removed += r.removedNodes.length;
+      for (const n of r.removedNodes) {
+        if (!(n instanceof Element) || isOwn(n)) continue;
+        const scrollers = [];
+        for (const [el, top] of scrollTops) {
+          if (top > 0 && (n === el || n.contains(el))) scrollers.push({ el, desc: describeElement(el, false), scrollTop: top });
+        }
+        const hadFocus = lastFocused !== null && (n === lastFocused || n.contains(lastFocused));
+        const rec = {
+          t,
+          desc: describeElement(n, false),
+          scrollers,
+          hadFocus,
+          focused: hadFocus && lastFocused ? describeElement(lastFocused, false) : null,
+          component: attributionFor(n, flushComps)
+        };
+        detached.set(n, rec);
+        if (scrollers.length || hadFocus) detachedNow.push(rec);
+      }
+      for (const n of r.addedNodes) {
+        if (!(n instanceof Element)) continue;
+        const rec = detached.get(n);
+        if (rec) {
+          detached.delete(n);
+          reattached.push({ node: n, rec });
+        }
+      }
+    }
+    pruneDetached(t);
+    if (targets.size > 0) {
+      const wantRects = Boolean(overlay && controller.isOn("flash"));
+      const rects = [];
+      const summary = [];
+      let attributed = null;
+      let i = 0;
+      for (const [el, info] of targets) {
+        if (wantRects || i < MAX_TARGETS_IN_EVENT) {
+          const desc = describeElement(el, wantRects);
+          if (wantRects && desc.rect && el.isConnected) rects.push(desc.rect);
+          if (i < MAX_TARGETS_IN_EVENT) {
+            summary.push({
+              ...desc,
+              types: [...info.types],
+              ...info.attrs.size ? { attrs: [...info.attrs] } : {},
+              ...info.added ? { added: info.added } : {},
+              ...info.removed ? { removed: info.removed } : {}
+            });
+          }
+        }
+        const comp = attributionFor(el, flushComps);
+        if (comp && !attributed) attributed = comp;
+        if (solid && comp && comp.id > 0 && el.isConnected) solid.attachElement(comp.id, el);
+        i++;
+      }
+      bus.emit(
+        "dom.mutation",
+        {
+          records: records.length,
+          targets: targets.size,
+          summary,
+          attributedTo: flushComps.length === 1 ? "single-component-flush" : flushComps.length > 1 ? "multi-component-flush" : "outside-solid-flush"
+        },
+        { flush, component: attributed }
+      );
+      if (wantRects && rects.length) overlay.flash(rects, "dom", { label: attributed?.name });
+    }
+    for (const rec of detachedNow) {
+      bus.emit(
+        "dom.detach",
+        {
+          element: rec.desc,
+          scrollers: rec.scrollers.map((s) => ({ element: s.desc, scrollTop: s.scrollTop })),
+          hadFocus: rec.hadFocus,
+          focused: rec.focused
+        },
+        { flush, component: rec.component }
+      );
+    }
+    if (reattached.length) {
+      nextFrame(() => {
+        const t2 = now();
+        for (const { node, rec } of reattached) {
+          const scrollReset = rec.scrollers.map((s) => ({
+            element: s.desc,
+            before: s.scrollTop,
+            after: s.el.scrollTop,
+            reset: s.scrollTop > 0 && s.el.scrollTop === 0
+          }));
+          const focusLost = rec.hadFocus && !node.contains(document.activeElement);
+          const chain = rec.component?.chain ?? [];
+          const data = {
+            element: rec.desc,
+            gapMs: Math.round((t2 - rec.t) * 100) / 100,
+            scrollReset,
+            focusLost,
+            suspenseInChain: chain.includes("Suspense"),
+            selector: toSelector(node)
+          };
+          bus.emit("dom.reattach", data, { flush, component: rec.component });
+          if (overlay && controller.isOn("flash") && node.isConnected) {
+            const r = node.getBoundingClientRect();
+            overlay.flash([{ x: r.left, y: r.top, w: r.width, h: r.height }], "reattach", {
+              ms: 900,
+              label: `reattach ${scrollReset.some((s) => s.reset) ? "\xB7 scroll reset" : ""}${focusLost ? " \xB7 focus lost" : ""}`.trim()
+            });
+          }
+        }
+      });
+    }
+    if (lastFocused && !lastFocused.isConnected) {
+      const active = document.activeElement;
+      if (!active || active === document.body) {
+        bus.emit("focus.lost", { element: describeElement(lastFocused, false), cause: "element removed from document" }, { flush });
+      }
+      lastFocused = null;
+    }
+  });
+  observer.observe(document.documentElement, { childList: true, subtree: true, attributes: true, characterData: true });
+  function grabContext(el) {
+    const grab = window.__SOLID_GRAB__;
+    const desc = describeElement(el);
+    const ctx = grab?.inspect && el instanceof HTMLElement ? grab.inspect(el) : null;
+    return {
+      element: desc,
+      selector: toSelector(el),
+      pulseComponent: solid ? (() => {
+        for (const c of solid.components()) if (solid.elementsFor(c.id).includes(el)) return { id: c.id, name: c.name };
+        return null;
+      })() : null,
+      grab: ctx ? { formatted: ctx.formatted, elementSource: ctx.elementSource, components: ctx.components } : null,
+      html: el.outerHTML.length > 500 ? el.outerHTML.slice(0, 500) + "..." : el.outerHTML
+    };
+  }
+  controller.register(
+    {
+      name: "inspect.element",
+      summary: "Element \u2192 source context: data-solid-source/component, solid-grab formatted context when installed, pulse component attribution.",
+      args: { selector: "CSS selector (first match)", x: "viewport x (with y, instead of selector)", y: "viewport y" },
+      ui: "Grab tab \u203A Pick element (Alt+click via solid-grab)"
+    },
+    (a) => {
+      let el = null;
+      if (a.selector !== void 0) el = document.querySelector(String(a.selector));
+      else if (a.x !== void 0 && a.y !== void 0) {
+        const hit = document.elementsFromPoint(Number(a.x), Number(a.y)).find((e) => !isOwn(e));
+        el = hit ?? null;
+      }
+      if (!el) throw new Error("no element matched");
+      return grabContext(el);
+    }
+  );
+  controller.register(
+    { name: "dom.highlight", summary: "Flash an outline around matching elements so a human can see what an agent is looking at.", args: { selector: "CSS selector", ms: "duration (default 1200)", all: "true = every match (max 20)" }, ui: "Grab tab \u203A Highlight" },
+    (a) => {
+      if (!overlay) throw new Error("overlay not mounted");
+      const all = a.all === true || a.all === "true";
+      const nodes = all ? [...document.querySelectorAll(String(a.selector))].slice(0, 20) : [document.querySelector(String(a.selector))].filter(Boolean);
+      const rects = nodes.map((n) => {
+        const r = n.getBoundingClientRect();
+        return { x: r.left, y: r.top, w: r.width, h: r.height };
+      });
+      overlay.flash(rects, "highlight", { ms: a.ms === void 0 ? 1200 : Number(a.ms), label: String(a.selector) });
+      return { matched: nodes.length, rects };
+    }
+  );
+  controller.register(
+    { name: "inspect.focus", summary: "Active element and the last element that had focus.", ui: "Pulse tab \u203A footer" },
+    () => ({
+      active: document.activeElement && document.activeElement !== document.body ? describeElement(document.activeElement) : null,
+      lastFocused: lastFocused ? describeElement(lastFocused) : null
+    })
+  );
+  controller.register(
+    { name: "inspect.scrollers", summary: "Elements that have scrolled recently with their last scrollTop.", ui: "Pulse tab \u203A footer" },
+    () => [...scrollTops].map(([el, top]) => ({ element: describeElement(el, false), selector: toSelector(el), scrollTop: top, connected: el.isConnected }))
+  );
+  return {
+    dispose() {
+      observer.disconnect();
+      clearInterval(focusPoll);
+      document.removeEventListener("scroll", onScroll, true);
+      document.removeEventListener("focusin", onFocusIn, true);
+      controller.unregister("inspect.element");
+      controller.unregister("dom.highlight");
+      controller.unregister("inspect.focus");
+      controller.unregister("inspect.scrollers");
+    }
+  };
+}
+
+// src/solid/network.ts
+var MAX_BODY_CHARS = 2e3;
+var MAX_INDIVIDUAL_STREAM_MESSAGES = 200;
+function bodySize(body) {
+  if (body == null) return 0;
+  if (typeof body === "string") return body.length;
+  if (body instanceof ArrayBuffer) return body.byteLength;
+  if (ArrayBuffer.isView(body)) return body.byteLength;
+  if (typeof Blob !== "undefined" && body instanceof Blob) return body.size;
+  if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return body.toString().length;
+  return null;
+}
+function messageType(data) {
+  if (typeof data !== "string" || data.length > 65536 || data[0] !== "{") return null;
+  const m = /"type"\s*:\s*"([^"]{1,80})"/.exec(data);
+  return m ? m[1] : null;
+}
+function preview(data, on) {
+  if (!on) return void 0;
+  if (typeof data === "string") return redactText(data.length > MAX_BODY_CHARS ? data.slice(0, MAX_BODY_CHARS) + "\u2026" : data);
+  return void 0;
+}
+function installNetwork(controller, solid, options = {}) {
+  const bus = controller.bus;
+  const ignored = (url) => options.ignoreUrl?.(url) === true;
+  let nextId = 1;
+  const g = globalThis;
+  const origFetch = g.fetch;
+  const NativeWebSocket = g.WebSocket;
+  const NativeEventSource = g.EventSource;
+  function wrapSse(res, id, url) {
+    if (!res.body) return res;
+    let count = 0;
+    let carry = "";
+    const decoder = new TextDecoder();
+    const startedAt = performance.now();
+    const reader = res.body.getReader();
+    bus.emit("net.sse.open", { id, url, transport: "fetch" });
+    const scan = (chunk) => {
+      carry += decoder.decode(chunk, { stream: true });
+      let idx;
+      while ((idx = carry.search(/\r?\n\r?\n/)) >= 0) {
+        const frame = carry.slice(0, idx);
+        carry = carry.slice(idx).replace(/^\r?\n\r?\n/, "");
+        if (!frame.trim() || frame.startsWith(":")) continue;
+        count++;
+        const evt = /^event:\s?(.*)$/m.exec(frame)?.[1] ?? "message";
+        if (count <= MAX_INDIVIDUAL_STREAM_MESSAGES || count % 50 === 0) {
+          bus.emit("net.sse.message", { id, url, event: evt, n: count, bytes: frame.length, transport: "fetch", preview: preview(frame, controller.isOn("captureBodies")) });
+        }
+      }
+    };
+    const done = () => bus.emit("net.sse.close", { id, url, messages: count, ms: Math.round(performance.now() - startedAt), transport: "fetch" });
+    const body = new ReadableStream({
+      async pull(ctl) {
+        const { value, done: finished } = await reader.read();
+        if (finished) {
+          done();
+          ctl.close();
+          return;
+        }
+        scan(value);
+        ctl.enqueue(value);
+      },
+      cancel(reason) {
+        done();
+        return reader.cancel(reason);
+      }
+    });
+    return new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+  }
+  const pulseFetch = function pulseFetch2(input, init) {
+    if (!controller.isOn("network")) return origFetch.call(this, input, init);
+    const req = typeof Request !== "undefined" && input instanceof Request ? input : null;
+    const rawUrl = req ? req.url : input instanceof URL ? input.href : String(input);
+    if (ignored(rawUrl)) return origFetch.call(this, input, init);
+    const id = nextId++;
+    const url = redactUrl(rawUrl);
+    const method = (init?.method ?? req?.method ?? "GET").toUpperCase();
+    const start = performance.now();
+    const component = solid?.currentComponent() ?? null;
+    let aborted = false;
+    const signal = init?.signal ?? req?.signal;
+    if (signal) {
+      if (signal.aborted) aborted = true;
+      else signal.addEventListener("abort", () => aborted = true, { once: true });
+    }
+    bus.emit("net.fetch.start", { id, method, url, bodyBytes: bodySize(init?.body), preview: preview(init?.body, controller.isOn("captureBodies")) }, { component });
+    return origFetch.call(this, input, init).then(
+      (res) => {
+        const ms = Math.round((performance.now() - start) * 100) / 100;
+        const ct = res.headers.get("content-type") ?? "";
+        const sse = ct.includes("text/event-stream");
+        bus.emit(
+          "net.fetch.end",
+          { id, method, url, status: res.status, ok: res.ok, ms, contentType: ct, contentLength: res.headers.get("content-length"), sse, streaming: sse || !res.headers.has("content-length") && res.body !== null },
+          { component }
+        );
+        return sse ? wrapSse(res, id, url) : res;
+      },
+      (err) => {
+        const ms = Math.round((performance.now() - start) * 100) / 100;
+        const e = err;
+        bus.emit("net.fetch.error", { id, method, url, ms, name: e?.name ?? "Error", message: redactText(String(e?.message ?? err)), aborted: aborted || e?.name === "AbortError" }, { component });
+        throw err;
+      }
+    );
+  };
+  pulseFetch.__solidPulse = true;
+  g.fetch = pulseFetch;
+  class PulseWebSocket extends NativeWebSocket {
+    constructor(url, protocols) {
+      super(url, protocols);
+      if (ignored(typeof url === "string" ? url : url.href)) return;
+      const id = nextId++;
+      const safeUrl = redactUrl(typeof url === "string" ? url : url.href);
+      const openedAt = performance.now();
+      let inbound = 0;
+      let outbound = 0;
+      const component = solid?.currentComponent() ?? null;
+      bus.emit("net.ws.open", { id, url: safeUrl, protocols: protocols ? [].concat(protocols) : [], state: "connecting" }, { component });
+      this.addEventListener("open", () => {
+        bus.emit("net.ws.open", { id, url: safeUrl, protocol: this.protocol, state: "open", ms: Math.round(performance.now() - openedAt) }, { component });
+      });
+      this.addEventListener("message", (ev) => {
+        inbound++;
+        if (!controller.isOn("network")) return;
+        if (inbound <= MAX_INDIVIDUAL_STREAM_MESSAGES || inbound % 50 === 0) {
+          const data = ev.data;
+          bus.emit("net.ws.message", { id, url: safeUrl, dir: "in", n: inbound, bytes: bodySize(data), type: messageType(data), preview: preview(data, controller.isOn("captureBodies")) });
+        }
+      });
+      this.addEventListener("close", (ev) => {
+        const e = ev;
+        bus.emit("net.ws.close", { id, url: safeUrl, code: e.code, reason: redactText(e.reason), wasClean: e.wasClean, inbound, outbound, ms: Math.round(performance.now() - openedAt) });
+      });
+      this.addEventListener("error", () => {
+        bus.emit("net.ws.error", { id, url: safeUrl, readyState: this.readyState });
+      });
+      const origSend = this.send.bind(this);
+      this.send = (data) => {
+        outbound++;
+        if (controller.isOn("network") && (outbound <= MAX_INDIVIDUAL_STREAM_MESSAGES || outbound % 50 === 0)) {
+          bus.emit("net.ws.message", { id, url: safeUrl, dir: "out", n: outbound, bytes: bodySize(data), type: messageType(data), preview: preview(data, controller.isOn("captureBodies")) });
+        }
+        return origSend(data);
+      };
+    }
+  }
+  PulseWebSocket.__solidPulse = true;
+  g.WebSocket = PulseWebSocket;
+  if (NativeEventSource) {
+    class PulseEventSource extends NativeEventSource {
+      constructor(url, init) {
+        super(url, init);
+        if (ignored(typeof url === "string" ? url : url.href)) return;
+        const id = nextId++;
+        const safeUrl = redactUrl(typeof url === "string" ? url : url.href);
+        const openedAt = performance.now();
+        let count = 0;
+        const seen = /* @__PURE__ */ new Set();
+        const component = solid?.currentComponent() ?? null;
+        const countType = (type) => {
+          if (seen.has(type)) return;
+          seen.add(type);
+          super.addEventListener(type, (ev) => {
+            count++;
+            if (!controller.isOn("network")) return;
+            if (count <= MAX_INDIVIDUAL_STREAM_MESSAGES || count % 50 === 0) {
+              const data = ev.data;
+              bus.emit("net.sse.message", { id, url: safeUrl, event: type, n: count, bytes: bodySize(data), transport: "EventSource", preview: preview(data, controller.isOn("captureBodies")) });
+            }
+          });
+        };
+        countType("message");
+        this.addEventListener("open", () => bus.emit("net.sse.open", { id, url: safeUrl, transport: "EventSource", ms: Math.round(performance.now() - openedAt) }, { component }));
+        this.addEventListener("error", () => bus.emit("net.sse.error", { id, url: safeUrl, readyState: this.readyState, transport: "EventSource" }));
+        const origAdd = this.addEventListener.bind(this);
+        this.addEventListener = ((type, listener, options2) => {
+          if (type !== "open" && type !== "error") countType(type);
+          return origAdd(type, listener, options2);
+        });
+        const origClose = this.close.bind(this);
+        this.close = () => {
+          bus.emit("net.sse.close", { id, url: safeUrl, messages: count, ms: Math.round(performance.now() - openedAt), transport: "EventSource" });
+          origClose();
+        };
+      }
+    }
+    PulseEventSource.__solidPulse = true;
+    g.EventSource = PulseEventSource;
+  }
+  return {
+    dispose() {
+      g.fetch = origFetch;
+      g.WebSocket = NativeWebSocket;
+      if (NativeEventSource) g.EventSource = NativeEventSource;
+    }
+  };
+}
+
+// src/bridge/client.ts
+function defaultUrl() {
+  const proto = location.protocol === "https:" ? "wss:" : "ws:";
+  return `${proto}//${location.host}${DEFAULT_PATH}/ws`;
+}
+function clientIdFor(explicit) {
+  if (explicit) return explicit;
+  try {
+    const existing = sessionStorage.getItem("solid-pulse:clientId");
+    if (existing) return existing;
+    const id = `tab-${Math.random().toString(36).slice(2, 8)}`;
+    sessionStorage.setItem("solid-pulse:clientId", id);
+    return id;
+  } catch {
+    return `tab-${Math.random().toString(36).slice(2, 8)}`;
+  }
+}
+var BridgeClient = class {
+  constructor(controller, options = {}) {
+    this.controller = controller;
+    this.options = options;
+    this.url = options.url ?? defaultUrl();
+    this.clientId = clientIdFor(options.clientId);
+    this.NativeWebSocket = WebSocket;
+  }
+  controller;
+  options;
+  ws = null;
+  timer = null;
+  queue = [];
+  flushTimer = null;
+  unsubscribe = null;
+  closed = false;
+  NativeWebSocket;
+  url;
+  clientId;
+  connected = false;
+  connect() {
+    if (this.ws || this.closed) return;
+    try {
+      const ws = new this.NativeWebSocket(this.url);
+      this.ws = ws;
+      ws.onopen = () => {
+        this.connected = true;
+        const hello = {
+          type: "hello",
+          protocol: PROTOCOL_VERSION,
+          clientId: this.clientId,
+          url: location.href,
+          title: document.title,
+          userAgent: navigator.userAgent,
+          commands: this.controller.describe(),
+          startedWall: this.controller.startedWall
+        };
+        ws.send(JSON.stringify(hello));
+        this.queue = this.controller.bus.list({ limit: 2e3 });
+        this.scheduleFlush();
+        this.unsubscribe?.();
+        this.unsubscribe = this.controller.bus.subscribe((e) => {
+          this.queue.push(e);
+          this.scheduleFlush();
+        });
+        this.controller.bus.emit("pulse.note", { note: `bridge connected ${this.url}` });
+      };
+      ws.onmessage = (ev) => void this.onMessage(ev.data);
+      ws.onclose = () => {
+        this.connected = false;
+        this.ws = null;
+        this.unsubscribe?.();
+        this.unsubscribe = null;
+        if (!this.closed) this.timer = setTimeout(() => this.connect(), this.options.reconnectMs ?? 2e3);
+      };
+      ws.onerror = () => ws.close();
+    } catch {
+      this.timer = setTimeout(() => this.connect(), this.options.reconnectMs ?? 2e3);
+    }
+  }
+  disconnect() {
+    this.closed = true;
+    if (this.timer) clearTimeout(this.timer);
+    if (this.flushTimer) clearTimeout(this.flushTimer);
+    this.unsubscribe?.();
+    this.ws?.close();
+    this.ws = null;
+    this.connected = false;
+  }
+  scheduleFlush() {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.flush();
+    }, 50);
+  }
+  flush() {
+    if (!this.ws || this.ws.readyState !== this.NativeWebSocket.OPEN || this.queue.length === 0) return;
+    while (this.queue.length) {
+      const chunk = this.queue.splice(0, 200);
+      this.send({ type: "events", events: chunk });
+    }
+  }
+  send(frame) {
+    if (!this.ws || this.ws.readyState !== this.NativeWebSocket.OPEN) return;
+    this.ws.send(JSON.stringify(frame));
+  }
+  async onMessage(raw) {
+    let frame;
+    try {
+      frame = JSON.parse(String(raw));
+    } catch {
+      return;
+    }
+    if (!isServerFrame(frame)) return;
+    if (frame.type === "command") {
+      const result = await this.controller.run(frame.name, frame.args ?? {});
+      this.send({ type: "result", id: frame.id, result });
+    }
+  }
+};
+
+// src/index.ts
+var instance = null;
+function getPulse() {
+  return instance;
+}
+function initPulse(options = {}) {
+  if (instance) return instance;
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    throw new Error("solid-pulse runs in the browser only");
+  }
+  const bus = new EventBus(options.bufferSize ?? 2e3);
+  const controller = new PulseController(bus, options.features);
+  const overlay = options.overlay === false ? null : new FlashOverlay();
+  let solid = null;
+  let dom = null;
+  let net = null;
+  let bridge = null;
+  const boot = () => {
+    overlay?.mount();
+    solid = installSolid(controller);
+    dom = installDom(controller, solid, overlay);
+    if (options.bridge) {
+      const opts = options.bridge === true ? {} : typeof options.bridge === "string" ? { url: options.bridge } : options.bridge;
+      bridge = new BridgeClient(controller, opts);
+    }
+    net = installNetwork(controller, solid, { ignoreUrl: (url) => url.includes("/__pulse/") });
+    bridge?.connect();
+    if (options.banner !== false) {
+      console.log(
+        "%c\u25C9 solid-pulse%c dev instrumentation on \xB7 window.__SOLID_PULSE__.run(cmd) \xB7 CLI: solid-pulse commands",
+        "color:#f59e0b;font-weight:bold",
+        "color:inherit"
+      );
+    }
+  };
+  const pulse = {
+    controller,
+    bus,
+    overlay,
+    get solid() {
+      return solid;
+    },
+    get bridge() {
+      return bridge;
+    },
+    run: (name, args) => controller.run(name, args),
+    destroy() {
+      bridge?.disconnect();
+      net?.dispose();
+      dom?.dispose();
+      solid?.dispose();
+      overlay?.unmount();
+      instance = null;
+      delete window.__SOLID_PULSE__;
+    }
+  };
+  instance = pulse;
+  window.__SOLID_PULSE__ = pulse;
+  boot();
+  return pulse;
+}
+export {
+  EventBus,
+  FlashOverlay,
+  PulseController,
+  describeElement,
+  getPulse,
+  initPulse,
+  toSelector
+};
+//# sourceMappingURL=index.js.map