@agent-scope/playwright 1.0.1

package/dist/browser-bundle.iife.js

@@ -0,0 +1,994 @@
+"use strict";
+(() => {
+  // ../core/src/serialization.ts
+  var DEFAULTS = {
+    maxDepth: 5,
+    maxStringLength: 200,
+    maxArrayLength: 100,
+    maxProperties: 50
+  };
+  function serialize(value, options) {
+    const opts = { ...DEFAULTS, ...options };
+    const seen = /* @__PURE__ */ new WeakSet();
+    return serializeInner(value, 0, seen, opts);
+  }
+  function serializeInner(value, depth, seen, opts) {
+    if (value === null) {
+      return { type: "null", value: null, preview: "null" };
+    }
+    if (value === void 0) {
+      return { type: "undefined", preview: "undefined" };
+    }
+    if (typeof value === "boolean") {
+      return { type: "boolean", value, preview: String(value) };
+    }
+    if (typeof value === "number") {
+      return { type: "number", value, preview: String(value) };
+    }
+    if (typeof value === "string") {
+      if (value.length > opts.maxStringLength) {
+        const truncated = value.slice(0, opts.maxStringLength) + "...";
+        return { type: "string", value: truncated, preview: `"${truncated}"` };
+      }
+      return { type: "string", value, preview: `"${value}"` };
+    }
+    if (typeof value === "bigint") {
+      return { type: "bigint", value: `${value.toString()}n`, preview: `${value.toString()}n` };
+    }
+    if (typeof value === "symbol") {
+      const preview = value.toString();
+      return { type: "symbol", preview };
+    }
+    if (typeof value === "function") {
+      const raw = Function.prototype.toString.call(value);
+      const preview = raw.length > 50 ? raw.slice(0, 50) + " ..." : raw;
+      return { type: "function", preview };
+    }
+    if (typeof value !== "object") {
+      return { type: "string", value: String(value), preview: String(value) };
+    }
+    if (seen.has(value)) {
+      return { type: "circular" };
+    }
+    if (depth >= opts.maxDepth) {
+      return { type: "truncated", preview: truncationPreview(value) };
+    }
+    seen.add(value);
+    try {
+      if (value instanceof Date) {
+        return { type: "date", value: value.toISOString(), preview: value.toISOString() };
+      }
+      if (value instanceof Map) {
+        const entries = [];
+        let count = 0;
+        for (const [k, v] of value) {
+          if (count >= opts.maxProperties) break;
+          const serializedKey = serializeInner(k, depth + 1, seen, opts);
+          const serializedVal = serializeInner(v, depth + 1, seen, opts);
+          entries.push({
+            type: "object",
+            value: { key: serializedKey, value: serializedVal },
+            preview: `[${serializedKey.preview ?? "?"} => ${serializedVal.preview ?? "?"}]`
+          });
+          count++;
+        }
+        const truncated = value.size > opts.maxProperties;
+        return {
+          type: "map",
+          value: entries,
+          preview: `Map(${value.size})${truncated ? " [truncated]" : ""}`
+        };
+      }
+      if (value instanceof Set) {
+        const items = [];
+        let count = 0;
+        for (const v of value) {
+          if (count >= opts.maxArrayLength) break;
+          items.push(serializeInner(v, depth + 1, seen, opts));
+          count++;
+        }
+        const truncated = value.size > opts.maxArrayLength;
+        return {
+          type: "set",
+          value: items,
+          preview: `Set(${value.size})${truncated ? " [truncated]" : ""}`
+        };
+      }
+      if (Array.isArray(value)) {
+        const items = [];
+        const limit = Math.min(value.length, opts.maxArrayLength);
+        for (let i = 0; i < limit; i++) {
+          items.push(serializeInner(value[i], depth + 1, seen, opts));
+        }
+        const truncated = value.length > opts.maxArrayLength;
+        return {
+          type: "array",
+          value: items,
+          preview: `Array(${value.length})${truncated ? " [truncated]" : ""}`
+        };
+      }
+      return serializeObject(value, depth, seen, opts);
+    } finally {
+      seen.delete(value);
+    }
+  }
+  function serializeObject(value, depth, seen, opts) {
+    const ctor = getConstructorName(value);
+    if (value instanceof WeakMap || value instanceof WeakSet || typeof WeakRef !== "undefined" && value instanceof WeakRef) {
+      return { type: "object", preview: ctor };
+    }
+    if (value instanceof Error) {
+      const props2 = {
+        name: serializeInner(value.name, depth + 1, seen, opts),
+        message: serializeInner(value.message, depth + 1, seen, opts)
+      };
+      if (value.stack !== void 0) {
+        props2.stack = serializeInner(value.stack, depth + 1, seen, opts);
+      }
+      return { type: "object", value: props2, preview: `${value.name}: ${value.message}` };
+    }
+    let keys;
+    try {
+      keys = Object.keys(value);
+    } catch {
+      return { type: "object", preview: ctor ?? "Object" };
+    }
+    const props = {};
+    const limit = Math.min(keys.length, opts.maxProperties);
+    for (let i = 0; i < limit; i++) {
+      const key = keys[i];
+      let propValue;
+      try {
+        propValue = value[key];
+      } catch {
+        propValue = "[Getter threw]";
+      }
+      props[key] = serializeInner(propValue, depth + 1, seen, opts);
+    }
+    const truncated = keys.length > opts.maxProperties;
+    const ctorPart = ctor && ctor !== "Object" ? `${ctor} ` : "";
+    const preview = `${ctorPart}{${keys.slice(0, 3).join(", ")}${keys.length > 3 ? ", \u2026" : ""}}${truncated ? " [truncated]" : ""}`;
+    return { type: "object", value: props, preview };
+  }
+  function getConstructorName(value) {
+    try {
+      const ctor = Object.getPrototypeOf(value)?.constructor;
+      return ctor?.name ?? "Object";
+    } catch {
+      return "Object";
+    }
+  }
+  function truncationPreview(value) {
+    if (Array.isArray(value)) return `Array(${value.length})`;
+    if (value instanceof Map) return `Map(${value.size})`;
+    if (value instanceof Set) return `Set(${value.size})`;
+    const ctor = typeof value === "object" && value !== null ? getConstructorName(value) : "";
+    return ctor || "Object";
+  }
+
+  // ../runtime/src/console-interceptor.ts
+  var INTERCEPTED_LEVELS = [
+    "log",
+    "warn",
+    "error",
+    "info",
+    "debug",
+    "group",
+    "groupCollapsed",
+    "table",
+    "trace"
+  ];
+  var _entries = [];
+  var _originals = {};
+  var _installed = false;
+  function getCurrentComponentName() {
+    try {
+      const win = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : null;
+      if (!win) return null;
+      const hook = win.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+      if (!hook || typeof hook !== "object") return null;
+      const fiber = hook._currentFiber ?? hook.currentFiber ?? null;
+      if (!fiber) return null;
+      return extractFiberName(fiber);
+    } catch {
+      return null;
+    }
+  }
+  function extractFiberName(fiber) {
+    if (!fiber) return null;
+    const { type } = fiber;
+    if (!type) return null;
+    if (typeof type === "function") {
+      return type.displayName || type.name || null;
+    }
+    if (typeof type === "object" && type !== null) {
+      if (typeof type.displayName === "string" && type.displayName) {
+        return type.displayName;
+      }
+      if (typeof type.render === "function") {
+        return type.render.displayName || type.render.name || null;
+      }
+      if (type.type) {
+        return extractFiberName({ type: type.type });
+      }
+    }
+    return null;
+  }
+  function buildPreview(args) {
+    const MAX = 200;
+    const parts = args.map((arg) => {
+      if (arg === null) return "null";
+      if (arg === void 0) return "undefined";
+      if (typeof arg === "string") return arg;
+      if (typeof arg === "number" || typeof arg === "boolean" || typeof arg === "bigint") {
+        return String(arg);
+      }
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    });
+    const joined = parts.join(" ");
+    return joined.length > MAX ? `${joined.slice(0, MAX - 1)}\u2026` : joined;
+  }
+  function makeWrapper(level, original) {
+    return function scopeConsoleWrapper(...args) {
+      original.apply(console, args);
+      try {
+        const componentName = getCurrentComponentName();
+        const timestamp = Date.now();
+        const serializedArgs = args.map((a) => serialize(a));
+        const preview = buildPreview(args);
+        const entry = {
+          level,
+          args: serializedArgs,
+          componentName,
+          timestamp,
+          preview
+        };
+        _entries.push(entry);
+      } catch {
+      }
+    };
+  }
+  function installConsoleInterceptor() {
+    if (_installed) return;
+    _installed = true;
+    for (const level of INTERCEPTED_LEVELS) {
+      const original = console[level];
+      _originals[level] = original;
+      console[level] = makeWrapper(level, original);
+    }
+  }
+  function uninstallConsoleInterceptor() {
+    if (!_installed) return;
+    _installed = false;
+    for (const level of INTERCEPTED_LEVELS) {
+      const original = _originals[level];
+      if (original !== void 0) {
+        console[level] = original;
+      }
+      delete _originals[level];
+    }
+  }
+  function getConsoleEntries() {
+    return _entries.slice();
+  }
+  function clearConsoleEntries() {
+    _entries.splice(0);
+  }
+
+  // ../runtime/src/devtools-hook.ts
+  var _hook = null;
+  var _nextRendererID = 1;
+  var _rendererListeners = [];
+  function createScopeHook() {
+    const renderers = /* @__PURE__ */ new Map();
+    const hook = {
+      isDisabled: false,
+      supportsFiber: true,
+      _renderers: renderers,
+      _isScopeHook: true,
+      inject(renderer) {
+        const id = _nextRendererID++;
+        const entry = {
+          id,
+          renderer,
+          // biome-ignore lint/suspicious/noExplicitAny: React renderer internals
+          fiberRoots: /* @__PURE__ */ new Set()
+        };
+        renderers.set(id, entry);
+        for (const listener of _rendererListeners.splice(0)) {
+          listener(entry);
+        }
+        return id;
+      },
+      onCommitFiberRoot(rendererID, root, _priorityLevel) {
+        const entry = renderers.get(rendererID);
+        if (entry) {
+          entry.fiberRoots.add(root);
+        }
+      },
+      onCommitFiberUnmount(_rendererID, _fiber) {
+      },
+      onPostCommitFiberRoot(_rendererID, _root) {
+      }
+    };
+    return hook;
+  }
+  function installHook() {
+    if (_hook !== null) {
+      return _hook;
+    }
+    const win = typeof window !== "undefined" ? window : null;
+    if (win === null) {
+      _hook = createScopeHook();
+      return _hook;
+    }
+    const existing = win.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    if (existing && typeof existing === "object") {
+      const existingHook = existing;
+      if (existingHook._isScopeHook === true) {
+        _hook = existing;
+        return _hook;
+      }
+      const scopeHook2 = createScopeHook();
+      const originalInject = existingHook.inject;
+      existingHook.inject = (renderer) => {
+        const originalId = typeof originalInject === "function" ? originalInject.call(existing, renderer) : -1;
+        scopeHook2.inject(renderer);
+        return originalId;
+      };
+      existingHook._renderers = scopeHook2._renderers;
+      existingHook._isScopeHook = true;
+      _hook = scopeHook2;
+      return _hook;
+    }
+    _hook = createScopeHook();
+    win.__REACT_DEVTOOLS_GLOBAL_HOOK__ = _hook;
+    return _hook;
+  }
+  function waitForReact(timeout = 1e4) {
+    const hook = _hook ?? installHook();
+    const existing = Array.from(hook._renderers.values());
+    if (existing.length > 0) {
+      return Promise.resolve(existing[0]);
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const idx = _rendererListeners.indexOf(listener);
+        if (idx !== -1) _rendererListeners.splice(idx, 1);
+        reject(new Error(`waitForReact: timed out after ${timeout}ms`));
+      }, timeout);
+      const listener = (renderer) => {
+        clearTimeout(timer);
+        resolve(renderer);
+      };
+      _rendererListeners.push(listener);
+    });
+  }
+
+  // ../runtime/src/error-detector.ts
+  var ClassComponent = 1;
+  function fiberName(fiber) {
+    const { type } = fiber;
+    if (!type) return "Anonymous";
+    if (typeof type === "string") return type;
+    if (typeof type.displayName === "string" && type.displayName) return type.displayName;
+    if (typeof type.name === "string" && type.name) return type.name;
+    return "Anonymous";
+  }
+  function isErrorBoundary(fiber) {
+    if (fiber.tag !== ClassComponent) return false;
+    const type = fiber.type;
+    if (!type || typeof type !== "function") return false;
+    if (typeof type.getDerivedStateFromError === "function") return true;
+    if (type.prototype && typeof type.prototype.componentDidCatch === "function") return true;
+    return false;
+  }
+  function extractErrorFromState(memoizedState) {
+    if (memoizedState === null || memoizedState === void 0) return null;
+    if (memoizedState instanceof Error) return memoizedState;
+    if (typeof memoizedState !== "object") return null;
+    if (memoizedState.hasError === true && memoizedState.error instanceof Error) {
+      return memoizedState.error;
+    }
+    if (memoizedState.error instanceof Error) return memoizedState.error;
+    for (const key of Object.keys(memoizedState)) {
+      if (memoizedState[key] instanceof Error) return memoizedState[key];
+    }
+    return null;
+  }
+  function findNearestBoundaryName(fiber) {
+    let current = fiber.return ?? null;
+    while (current !== null) {
+      if (isErrorBoundary(current)) {
+        return fiberName(current);
+      }
+      current = current.return ?? null;
+    }
+    return null;
+  }
+  function detectErrors(rootFiber) {
+    const results = [];
+    const visited = /* @__PURE__ */ new Set();
+    function walk(fiber) {
+      if (fiber === null || fiber === void 0) return;
+      if (visited.has(fiber)) return;
+      visited.add(fiber);
+      if (isErrorBoundary(fiber)) {
+        const error = extractErrorFromState(fiber.memoizedState);
+        if (error !== null) {
+          const throwingChild = fiber.child;
+          const componentName = throwingChild ? fiberName(throwingChild) : fiberName(fiber);
+          const boundaryName = fiberName(fiber);
+          const enclosingBoundary = findNearestBoundaryName(fiber);
+          results.push({
+            message: error.message ?? String(error),
+            name: error.name ?? "Error",
+            stack: error.stack ?? null,
+            source: null,
+            // Stack parsing is left to consumers
+            componentName,
+            timestamp: Date.now(),
+            capturedBy: "boundary",
+            // Store boundary name as a non-standard extension that typed consumers
+            // can access.  The interface only requires the defined fields.
+            ...{ boundaryName: enclosingBoundary ?? boundaryName }
+          });
+        }
+      }
+      walk(fiber.child ?? null);
+      walk(fiber.sibling ?? null);
+    }
+    walk(rootFiber);
+    return results;
+  }
+
+  // ../runtime/src/context-extractor.ts
+  var CONTEXT_CONSUMER_TAG = 9;
+  function resolveContextName(context) {
+    if (!context || typeof context !== "object") return null;
+    if (typeof context.displayName === "string" && context.displayName) {
+      return context.displayName;
+    }
+    const currentValue = context._currentValue;
+    if (currentValue !== null && currentValue !== void 0 && typeof currentValue === "object") {
+      const ctorName = currentValue.constructor?.name;
+      if (typeof ctorName === "string" && ctorName && ctorName !== "Object" && ctorName !== "Array") {
+        return ctorName;
+      }
+    }
+    return null;
+  }
+  function readContextDependencies(fiber) {
+    const first = (
+      // biome-ignore lint/suspicious/noExplicitAny: React fiber internals
+      fiber.dependencies?.firstContext ?? // React 16 legacy field
+      // biome-ignore lint/suspicious/noExplicitAny: React fiber internals
+      fiber.contextDependencies?.first ?? null
+    );
+    if (first === null || first === void 0) return [];
+    const deps = [];
+    let node = first;
+    while (node !== null && node !== void 0) {
+      deps.push(node);
+      node = node.next ?? null;
+    }
+    return deps;
+  }
+  function extractContextConsumptions(fiber) {
+    if (fiber.tag === CONTEXT_CONSUMER_TAG) {
+      const context = fiber.type;
+      if (context && typeof context === "object") {
+        const contextName = resolveContextName(context);
+        const raw = context._currentValue;
+        return [
+          {
+            contextName,
+            value: serialize(raw),
+            didTriggerRender: false
+          }
+        ];
+      }
+      return [];
+    }
+    const deps = readContextDependencies(fiber);
+    if (deps.length === 0) return [];
+    const consumptions = [];
+    for (const dep of deps) {
+      const context = dep.context ?? dep.observedBits ?? null;
+      if (!context || typeof context !== "object") continue;
+      const raw = context._currentValue;
+      const contextName = resolveContextName(context);
+      consumptions.push({
+        contextName,
+        value: serialize(raw),
+        didTriggerRender: false
+      });
+    }
+    return consumptions;
+  }
+
+  // ../runtime/src/hooks-extractor.ts
+  var HookLayout = 4;
+  function isEffectNode(node) {
+    const ms = node.memoizedState;
+    if (ms === null || typeof ms !== "object") return false;
+    const obj = ms;
+    return typeof obj.create === "function" && "deps" in obj && typeof obj.tag === "number";
+  }
+  function isRefNode(node) {
+    if (node.queue != null) return false;
+    const ms = node.memoizedState;
+    if (ms === null || typeof ms !== "object" || Array.isArray(ms)) return false;
+    const keys = Object.keys(ms);
+    return keys.length === 1 && keys[0] === "current";
+  }
+  function isMemoTuple(node) {
+    if (node.queue != null) return false;
+    const ms = node.memoizedState;
+    if (!Array.isArray(ms) || ms.length !== 2) return false;
+    return ms[1] === null || Array.isArray(ms[1]);
+  }
+  function isStateOrReducerNode(node) {
+    return node.queue != null && typeof node.queue === "object" && typeof node.queue.dispatch === "function";
+  }
+  function isReducerNode(node) {
+    if (!isStateOrReducerNode(node)) return false;
+    const q = node.queue;
+    if (typeof q.reducer === "function") return true;
+    const lrr = q.lastRenderedReducer;
+    if (typeof lrr !== "function") return false;
+    const name = lrr.name ?? "";
+    return name !== "basicStateReducer" && name !== "";
+  }
+  function classifyEffectType(effect) {
+    if (effect.tag & HookLayout) return "useLayoutEffect";
+    return "useEffect";
+  }
+  function serializeDeps(deps) {
+    if (deps === null || deps === void 0) return null;
+    if (!Array.isArray(deps)) return null;
+    return deps.map((d) => serialize(d));
+  }
+  function extractHooks(fiber) {
+    if (fiber == null) return [];
+    let node = fiber.memoizedState ?? null;
+    if (node === null) return [];
+    const hooks = [];
+    while (node !== null) {
+      hooks.push(classifyNode(node));
+      node = node.next ?? null;
+    }
+    return hooks;
+  }
+  function classifyNode(node) {
+    if (isEffectNode(node)) {
+      const effect = node.memoizedState;
+      const hookType = classifyEffectType(effect);
+      return {
+        type: hookType,
+        name: null,
+        value: serialize(void 0),
+        deps: serializeDeps(effect.deps),
+        hasCleanup: typeof effect.destroy === "function"
+      };
+    }
+    if (isRefNode(node)) {
+      const ref = node.memoizedState;
+      return {
+        type: "useRef",
+        name: null,
+        value: serialize(ref.current),
+        deps: null,
+        hasCleanup: null
+      };
+    }
+    if (isMemoTuple(node)) {
+      const [val, deps] = node.memoizedState;
+      const hookType = typeof val === "function" ? "useCallback" : "useMemo";
+      return {
+        type: hookType,
+        name: null,
+        value: serialize(val),
+        deps: serializeDeps(deps),
+        hasCleanup: null
+      };
+    }
+    if (isStateOrReducerNode(node)) {
+      const hookType = isReducerNode(node) ? "useReducer" : "useState";
+      return {
+        type: hookType,
+        name: null,
+        value: serialize(node.memoizedState),
+        deps: null,
+        hasCleanup: null
+      };
+    }
+    return {
+      type: "custom",
+      name: null,
+      value: serialize(node.memoizedState),
+      deps: null,
+      hasCleanup: null
+    };
+  }
+
+  // ../runtime/src/profiler.ts
+  var _profilingData = /* @__PURE__ */ new Map();
+  var _fiberRefMap = /* @__PURE__ */ new WeakMap();
+  var _syntheticIdCounter = -1;
+  var _installed2 = false;
+  function fiberId(fiber) {
+    if (typeof fiber._debugID === "number") {
+      return fiber._debugID;
+    }
+    const existing = _fiberRefMap.get(fiber);
+    if (existing !== void 0) return existing;
+    const id = _syntheticIdCounter--;
+    _fiberRefMap.set(fiber, id);
+    return id;
+  }
+  function walkCommittedFibers(fiber) {
+    if (fiber === null || fiber === void 0) return;
+    const actualDuration = typeof fiber.actualDuration === "number" ? fiber.actualDuration : -1;
+    const selfBaseDuration = typeof fiber.selfBaseDuration === "number" ? fiber.selfBaseDuration : 0;
+    if (actualDuration >= 0) {
+      const id = fiberId(fiber);
+      const existing = _profilingData.get(id);
+      if (existing !== void 0) {
+        existing.renderCount += 1;
+        existing.renderDuration += selfBaseDuration;
+      } else {
+        _profilingData.set(id, {
+          renderCount: 1,
+          renderDuration: selfBaseDuration
+        });
+      }
+    }
+    walkCommittedFibers(fiber.child ?? null);
+    walkCommittedFibers(fiber.sibling ?? null);
+  }
+  function installProfiler(hook) {
+    if (_installed2) return;
+    _installed2 = true;
+    const originalOnCommit2 = hook.onCommitFiberRoot.bind(hook);
+    hook.onCommitFiberRoot = (rendererID, root, priorityLevel) => {
+      originalOnCommit2(rendererID, root, priorityLevel);
+      const wipRoot = root?.current?.alternate ?? root?.current ?? null;
+      if (wipRoot !== null) {
+        walkCommittedFibers(wipRoot);
+      }
+    };
+  }
+  function getProfilingData(fiberIdParam) {
+    const record = _profilingData.get(fiberIdParam);
+    if (record === void 0) return null;
+    return { renderCount: record.renderCount, renderDuration: record.renderDuration };
+  }
+
+  // ../runtime/src/fiber-walker.ts
+  var FunctionComponent = 0;
+  var ClassComponent2 = 1;
+  var IndeterminateComponent = 2;
+  var HostRoot = 3;
+  var HostComponent = 5;
+  var HostText = 6;
+  var Fragment = 7;
+  var ForwardRef = 11;
+  var SuspenseComponent = 13;
+  var MemoComponent = 14;
+  var SimpleMemoComponent = 15;
+  var _idCounter = 1;
+  function nextId() {
+    return _idCounter++;
+  }
+  var INFERRED_PROPERTY_NAMES = /* @__PURE__ */ new Set(["render", "type", "forward_ref", "memo"]);
+  function isUserSuppliedName(name, tag) {
+    if (typeof name !== "string" || !name) return false;
+    if ((tag === ForwardRef || tag === MemoComponent || tag === SimpleMemoComponent) && INFERRED_PROPERTY_NAMES.has(name)) {
+      return false;
+    }
+    return true;
+  }
+  function extractName(fiber) {
+    const { type, tag } = fiber;
+    if (type === null || type === void 0) {
+      if (tag === HostRoot) return "HostRoot";
+      if (tag === Fragment) return "Fragment";
+      if (tag === HostText) return "#text";
+      return "Anonymous";
+    }
+    if (typeof type === "string") {
+      return type;
+    }
+    if (typeof type.displayName === "string" && type.displayName) {
+      return type.displayName;
+    }
+    if (tag === ForwardRef || type.$$typeof && String(type.$$typeof).includes("forward_ref")) {
+      const render = type.render;
+      if (render) {
+        if (typeof render.displayName === "string" && render.displayName) return render.displayName;
+        if (isUserSuppliedName(render.name, tag)) return render.name;
+      }
+      return "ForwardRef";
+    }
+    if (tag === MemoComponent || tag === SimpleMemoComponent || type.$$typeof && String(type.$$typeof).includes("memo")) {
+      const inner = type.type;
+      if (inner) {
+        if (typeof inner.displayName === "string" && inner.displayName) return inner.displayName;
+        if (isUserSuppliedName(inner.name, tag)) return inner.name;
+      }
+      return "Memo";
+    }
+    if (isUserSuppliedName(type.name, tag)) {
+      return type.name;
+    }
+    return "Anonymous";
+  }
+  function classifyType(fiber) {
+    const { tag, type } = fiber;
+    switch (tag) {
+      case FunctionComponent:
+      case IndeterminateComponent:
+        return "function";
+      case ClassComponent2:
+        return "class";
+      case ForwardRef:
+        return "forward_ref";
+      case MemoComponent:
+      case SimpleMemoComponent:
+        return "memo";
+      case HostComponent:
+      case HostText:
+        return "host";
+      default:
+        if (type && typeof type === "object") {
+          const typeofStr = String(type.$$typeof ?? "");
+          if (typeofStr.includes("forward_ref")) return "forward_ref";
+          if (typeofStr.includes("memo")) return "memo";
+        }
+        return "function";
+    }
+  }
+  function extractSource(fiber) {
+    if (fiber._debugSource) {
+      const { fileName, lineNumber, columnNumber } = fiber._debugSource;
+      return {
+        fileName: String(fileName),
+        lineNumber: Number(lineNumber),
+        columnNumber: Number(columnNumber)
+      };
+    }
+    const scopeSource = fiber.memoizedProps?.__scopeSource;
+    if (scopeSource && typeof scopeSource === "object") {
+      const { fileName, lineNumber, columnNumber } = scopeSource;
+      if (typeof fileName === "string" && typeof lineNumber === "number" && typeof columnNumber === "number") {
+        return { fileName, lineNumber, columnNumber };
+      }
+    }
+    return null;
+  }
+  function shouldSkip(fiber, includeHost) {
+    const { tag } = fiber;
+    if (tag === HostRoot || tag === HostText || tag === Fragment || tag === SuspenseComponent) {
+      return true;
+    }
+    if (tag === HostComponent && !includeHost) {
+      return true;
+    }
+    return false;
+  }
+  function walkFiberInner(fiber, includeHost, visited) {
+    if (fiber === null || fiber === void 0) return null;
+    if (visited.has(fiber)) return null;
+    if (shouldSkip(fiber, includeHost)) {
+      return null;
+    }
+    visited.add(fiber);
+    const id = typeof fiber._debugID === "number" ? fiber._debugID : nextId();
+    const profilingData = getProfilingData(id);
+    const children = collectChildren(fiber, includeHost, visited);
+    const node = {
+      id,
+      name: extractName(fiber),
+      type: classifyType(fiber),
+      source: extractSource(fiber),
+      props: serialize(fiber.memoizedProps ?? {}),
+      state: extractHooks(fiber),
+      context: extractContextConsumptions(fiber),
+      renderCount: profilingData?.renderCount ?? 1,
+      renderDuration: profilingData?.renderDuration ?? 0,
+      children
+    };
+    return node;
+  }
+  function collectChildren(fiber, includeHost, visited) {
+    const nodes = [];
+    let current = fiber.child ?? null;
+    while (current !== null) {
+      if (visited.has(current)) {
+        current = current.sibling ?? null;
+        continue;
+      }
+      if (shouldSkip(current, includeHost)) {
+        const promoted = collectChildren(current, includeHost, visited);
+        nodes.push(...promoted);
+      } else {
+        const node = walkFiberInner(current, includeHost, visited);
+        if (node !== null) {
+          nodes.push(node);
+        }
+      }
+      current = current.sibling ?? null;
+    }
+    return nodes;
+  }
+  function walkFiberRoot(fiberRoot, options = {}) {
+    if (!fiberRoot) return null;
+    const hostRootFiber = fiberRoot.current ?? null;
+    if (!hostRootFiber) return null;
+    const includeHost = options.includeHostElements ?? false;
+    const visited = /* @__PURE__ */ new Set();
+    const children = collectChildren(hostRootFiber, includeHost, visited);
+    if (children.length === 0) return null;
+    if (children.length === 1) return children[0] ?? null;
+    return {
+      id: nextId(),
+      name: "Root",
+      type: "function",
+      source: null,
+      props: serialize({}),
+      state: [],
+      context: [],
+      renderCount: 1,
+      renderDuration: 0,
+      children
+    };
+  }
+
+  // ../runtime/src/suspense-detector.ts
+  var SuspenseComponent2 = 13;
+  var HostText2 = 6;
+  function nearestAncestorName(fiber) {
+    let current = fiber.return ?? null;
+    while (current !== null) {
+      const { type } = current;
+      if (type && typeof type !== "string") {
+        const name = type.displayName ?? type.name;
+        if (typeof name === "string" && name) return name;
+      }
+      current = current.return ?? null;
+    }
+    return "Unknown";
+  }
+  function extractFallbackName(fiber) {
+    const primary = fiber.child ?? null;
+    const fallback = primary?.sibling ?? null;
+    if (!fallback) return null;
+    const { type, tag } = fallback;
+    if (tag === HostText2) return null;
+    if (typeof type === "string") return type;
+    if (type && typeof type.displayName === "string" && type.displayName) return type.displayName;
+    if (type && typeof type.name === "string" && type.name) return type.name;
+    return null;
+  }
+  function classifyStatus(memoizedState) {
+    if (memoizedState === null || memoizedState === void 0) {
+      return false;
+    }
+    if (typeof memoizedState === "object" && memoizedState.dehydrated !== void 0 && memoizedState.dehydrated !== null) {
+      return true;
+    }
+    if (typeof memoizedState === "object" && typeof memoizedState.then === "function") {
+      return true;
+    }
+    return true;
+  }
+  function detectSuspenseBoundaries(rootFiber) {
+    const results = [];
+    const visited = /* @__PURE__ */ new Set();
+    function walk(fiber) {
+      if (fiber === null || fiber === void 0) return;
+      if (visited.has(fiber)) return;
+      visited.add(fiber);
+      if (fiber.tag === SuspenseComponent2) {
+        const isSuspended = classifyStatus(fiber.memoizedState);
+        const componentName = nearestAncestorName(fiber);
+        const fallbackName = extractFallbackName(fiber);
+        const id = typeof fiber._debugID === "number" ? fiber._debugID : fiber.index;
+        results.push({
+          id,
+          componentName,
+          isSuspended,
+          suspendedDuration: null,
+          // timing not available at capture time
+          fallbackName,
+          source: fiber._debugSource ? {
+            fileName: String(fiber._debugSource.fileName),
+            lineNumber: Number(fiber._debugSource.lineNumber),
+            columnNumber: Number(fiber._debugSource.columnNumber)
+          } : null
+        });
+      }
+      walk(fiber.child ?? null);
+      walk(fiber.sibling ?? null);
+    }
+    walk(rootFiber);
+    return results;
+  }
+
+  // ../runtime/src/capture.ts
+  async function capture(options = {}) {
+    const startTime = Date.now();
+    const hook = installHook();
+    installProfiler(hook);
+    installConsoleInterceptor();
+    clearConsoleEntries();
+    const url = options.url ?? (typeof window !== "undefined" ? window.location.href : "unknown");
+    try {
+      const renderer = await waitForReact(options.reactTimeout ?? 1e4);
+      const fiberRoot = Array.from(renderer.fiberRoots)[0] ?? null;
+      if (!fiberRoot) {
+        throw new Error(
+          "capture(): React renderer registered but no fiber roots found. Make sure React has rendered at least one component."
+        );
+      }
+      const walkOptions = {
+        includeHostElements: options.includeHostElements ?? false
+      };
+      const tree = walkFiberRoot(fiberRoot, walkOptions);
+      if (!tree) {
+        throw new Error(
+          "capture(): Fiber tree is empty. Make sure React has rendered at least one component."
+        );
+      }
+      const hostRootFiber = fiberRoot.current ?? null;
+      const rootChild = hostRootFiber?.child ?? null;
+      const errors = detectErrors(rootChild);
+      const suspenseBoundaries = detectSuspenseBoundaries(rootChild);
+      const capturedIn = Date.now() - startTime;
+      const consoleEntries = getConsoleEntries();
+      return {
+        url,
+        timestamp: startTime,
+        capturedIn,
+        tree,
+        consoleEntries,
+        errors,
+        suspenseBoundaries
+      };
+    } finally {
+      uninstallConsoleInterceptor();
+    }
+  }
+
+  // src/browser-entry.ts
+  var scopeHook = installHook();
+  var hookObj = scopeHook;
+  if (!hookObj.renderers) {
+    const renderersProxy = /* @__PURE__ */ new Map();
+    const origInject = scopeHook.inject.bind(scopeHook);
+    scopeHook.inject = (renderer) => {
+      const id = origInject(renderer);
+      renderersProxy.set(id, renderer);
+      return id;
+    };
+    hookObj.renderers = renderersProxy;
+  }
+  var resolveFirstCommit;
+  var firstCommit = new Promise((res) => {
+    resolveFirstCommit = res;
+  });
+  var originalOnCommit = scopeHook.onCommitFiberRoot.bind(scopeHook);
+  scopeHook.onCommitFiberRoot = (rendererID, root, priorityLevel) => {
+    originalOnCommit(rendererID, root, priorityLevel);
+    resolveFirstCommit();
+  };
+  window.__SCOPE_CAPTURE__ = async () => {
+    await firstCommit;
+    return capture();
+  };
+})();