@iteraai/react-component-inspector 0.1.0

package/README.md

@@ -0,0 +1,168 @@
+# `@iteraai/react-component-inspector`
+
+Browser bridge and iteration runtime for customer React apps embedded in the hosted Itera editor.
+
+This is the current public React implementation of the component inspector SDK. It preserves the existing bridge/runtime behavior from `Web/libs/react-inspector-bridge` and carries it forward under the package name `@iteraai/react-component-inspector`.
+
+## Installation
+
+```bash
+npm install @iteraai/react-component-inspector @iteraai/inspector-protocol react react-dom
+```
+
+Peer dependency support:
+
+- `react`: `^18.3.0 || ^19.0.0`
+- `react-dom`: `^18.3.0 || ^19.0.0`
+
+This package targets browser DOM runtimes. It is meant to run inside the customer app iframe or preview surface that the hosted editor embeds.
+
+## Public Entry Points
+
+| Import path                                             | Purpose                                                                                                              |
+| ------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `@iteraai/react-component-inspector`                    | Root exports for bootstrap helpers, bridge helpers, adapter/runtime config, telemetry helpers, and token validation. |
+| `@iteraai/react-component-inspector/embeddedBootstrap`  | Embedded bootstrap helpers.                                                                                          |
+| `@iteraai/react-component-inspector/bridgeRuntime`      | Low-level bridge initialization and teardown.                                                                        |
+| `@iteraai/react-component-inspector/iterationInspector` | Element-selection runtime and message types for iteration mode.                                                      |
+
+## Embedded Bridge Quick Start
+
+Use the bootstrap helper when you want the standard embedded bridge behavior:
+
+```ts
+import { bootstrapEmbeddedInspectorBridge } from "@iteraai/react-component-inspector";
+import { bootIterationInspectorRuntime } from "@iteraai/react-component-inspector/iterationInspector";
+
+const bridge = bootstrapEmbeddedInspectorBridge({
+  enabled: true,
+  hostOrigins: ["https://app.iteraapp.com", "https://preview.iteraapp.com"],
+});
+
+bootIterationInspectorRuntime();
+
+window.addEventListener("beforeunload", () => {
+  bridge.destroy();
+});
+```
+
+What `bootstrapEmbeddedInspectorBridge` does by default:
+
+- Initializes the bridge in `development` mode
+- Enables the `tree`, `props`, and `highlight` capabilities
+- Uses `runtimeConfig: { adapter: 'fiber' }`
+- Installs the React DevTools inline backend hook unless you opt out
+- Starts optional embedded runtime telemetry when configured
+
+For local development defaults, `initDevEmbeddedInspectorBridge()` is a thinner shortcut that defaults to:
+
+- `enabled: true`
+- `killSwitchActive: false`
+- `hostOrigins: ['https://app.iteraapp.com']`
+- `runtimeConfig: { adapter: 'fiber' }`
+
+## When To Use The Low-Level Bridge API
+
+Use `initInspectorBridge` when you need lower-level control over runtime configuration, security, or adapter wiring.
+
+```ts
+import { initInspectorBridge } from "@iteraai/react-component-inspector/bridgeRuntime";
+
+const bridge = initInspectorBridge({
+  enabled: true,
+  hostOrigins: ["https://app.iteraapp.com"],
+  mode: "development",
+  runtimeConfig: {
+    adapter: "fiber",
+  },
+  security: {
+    enabled: true,
+  },
+});
+
+window.addEventListener("beforeunload", () => {
+  bridge.destroy();
+});
+```
+
+Use the low-level API if you need any of the following:
+
+- Secure `HELLO` handshakes with session-token validation
+- A custom `treeAdapter`
+- A custom `adapterFactory`
+- Direct control over bridge handlers or telemetry hooks
+
+If you call `initInspectorBridge` without `treeAdapter`, `adapterFactory`, or `runtimeConfig`, the bridge can still handshake, but tree/props/snapshot requests do not have an adapter behind them.
+
+## Origin And Session-Token Requirements
+
+Embedded bridge requirements:
+
+- `hostOrigins` must contain at least one trusted hosted-editor origin or the bridge stays disabled.
+- Messages from untrusted origins are ignored before protocol parsing.
+- `bootstrapEmbeddedInspectorBridge` accepts `hostOrigins` as either an array or a comma-separated string and trims empty entries.
+- `mode: 'production'`, `enabled: false`, or `killSwitchActive: true` disables the bridge.
+
+Secure session-token behavior:
+
+- Bridge security is only available through `initInspectorBridge`, not the higher-level bootstrap helper.
+- When `security.enabled` is `true`, the host `HELLO` payload must include `auth.sessionToken`.
+- The default validator rejects missing tokens, blank tokens, and expired `auth.metadata.expiresAt` values.
+- Provide `security.tokenValidator` if you need stronger token validation than the built-in non-empty/not-expired checks.
+
+## Supported React Runtime Targets
+
+The exported runtime adapter targets are:
+
+- `auto`
+- `vite`
+- `next`
+- `cra`
+- `fiber`
+
+Current guidance:
+
+- The customer-facing bootstrap helpers use `fiber` today.
+- Prefer `fiber` for parity with the preserved `Web` behavior unless you are intentionally wiring a custom adapter path.
+- `vite`, `next`, and `cra` remain exported adapter targets for direct runtime configuration and future expansion.
+
+## Current Runtime Behavior
+
+The current implementation is intentionally documented as-is rather than generalized.
+
+- Trusted `HELLO` messages receive `READY`; `PING` receives `PONG`.
+- `REQUEST_TREE` returns a capped tree snapshot. Tree responses can include truncation metadata when the node count exceeds the current limit.
+- `REQUEST_NODE_PROPS` serializes props into JSON-safe values and uses `__iteraType` placeholders for unsupported values.
+- Sensitive prop keys matching names such as `token`, `password`, `secret`, or `authorization` are redacted.
+- `REQUEST_SNAPSHOT` currently returns a placeholder SVG capture plus the DOM HTML snapshot when it fits the response size budget.
+- If the HTML portion would make the snapshot too large, the bridge omits the HTML and sets `htmlTruncated: true`.
+- After the host handshake, the bridge posts `PATH_UPDATED` messages on `itera-preview-path` for the initial location and subsequent history/hash navigation.
+
+## Iteration Inspector Runtime
+
+The iteration runtime uses the separate `itera:iteration-inspector` channel.
+
+```ts
+import { bootIterationInspectorRuntime } from "@iteraai/react-component-inspector/iterationInspector";
+
+bootIterationInspectorRuntime();
+```
+
+Current runtime behavior:
+
+- `bootIterationInspectorRuntime()` returns `null` when the page is not embedded in an iframe unless `allowSelfMessaging: true` is passed.
+- The runtime emits `runtime_ready`, `mode_changed`, `element_selected`, `selection_invalidated`, and optional `debug_log` messages.
+- It listens for `enter_select_mode`, `exit_select_mode`, and `clear_hover` parent messages.
+- The first accepted parent origin is pinned for the lifetime of the started runtime; messages from a different origin are ignored until the runtime stops.
+- `enter_select_mode` supports `single` and `persistent` selection modes.
+- Selected elements can be invalidated on reloads, route changes, or DOM node detachment.
+
+## Runtime Telemetry
+
+If you opt in through `runtimeTelemetry`, the embedded runtime can post telemetry messages on `ara:embedded-runtime-telemetry` for:
+
+- `console.error`
+- `window.onerror`
+- `unhandledrejection`
+
+Those messages are forwarded separately from the main inspector protocol and are intended for host/editor-side debugging and observability.

package/dist/adapters/base/baseAdapter.d.ts

@@ -0,0 +1,24 @@
+import { TreeNode, TreeSnapshotMeta } from '../../../../inspector-protocol/src/index.ts';
+import { ReactInspectorAdapterContract } from './types';
+export type ReactTreeSnapshot = {
+    nodes: TreeNode[];
+    rootIds: string[];
+    meta?: TreeSnapshotMeta;
+};
+export type CappedReactTreeSnapshot = ReactTreeSnapshot & {
+    meta?: TreeSnapshotMeta;
+};
+export declare const MAX_TREE_SNAPSHOT_NODE_COUNT = 200;
+export declare const capTreeSnapshot: (snapshot: ReactTreeSnapshot, maxNodeCount?: number) => CappedReactTreeSnapshot;
+export type BaseAdapterNodeLookup = {
+    node: TreeNode;
+    nodeById: ReadonlyMap<string, TreeNode>;
+    snapshot: ReactTreeSnapshot;
+};
+export type CreateBaseReactInspectorAdapterOptions = {
+    getTreeSnapshot: () => ReactTreeSnapshot;
+    getNodeProps?: (lookup: BaseAdapterNodeLookup) => unknown | undefined;
+    getDomElement?: (lookup: BaseAdapterNodeLookup) => Element | null;
+    getReactComponentPathForElement?: (element: Element) => ReadonlyArray<string> | undefined;
+};
+export declare const createBaseReactInspectorAdapter: (options: CreateBaseReactInspectorAdapterOptions) => ReactInspectorAdapterContract;

package/dist/adapters/base/createReactInspectorAdapter.d.ts

@@ -0,0 +1,6 @@
+import { ReactInspectorAdapterContract, ReactInspectorRuntimeConfig } from './types';
+import { EmbeddedBridgeTelemetryHooks } from '../../security/bridgeTelemetry';
+export type CreateReactInspectorAdapterOptions = Readonly<{
+    telemetry?: EmbeddedBridgeTelemetryHooks;
+}>;
+export declare const createReactInspectorAdapter: (runtimeConfig?: ReactInspectorRuntimeConfig, options?: CreateReactInspectorAdapterOptions) => ReactInspectorAdapterContract;

package/dist/adapters/base/index.d.ts

@@ -0,0 +1,4 @@
+export { capTreeSnapshot, createBaseReactInspectorAdapter, MAX_TREE_SNAPSHOT_NODE_COUNT, type BaseAdapterNodeLookup, type CappedReactTreeSnapshot, type CreateBaseReactInspectorAdapterOptions, type ReactTreeSnapshot, } from './baseAdapter';
+export { createReactInspectorAdapter } from './createReactInspectorAdapter';
+export { defaultReactInspectorAdapterCapabilities, defaultReactInspectorRuntimeConfig, resolveReactInspectorRuntimeConfig, } from './runtimeConfig';
+export { reactInspectorRuntimeAdapterTargets, type ReactInspectorAdapterCapabilities, type ReactInspectorAdapterContract, type ReactInspectorRuntimeAdapterTarget, type ReactInspectorRuntimeConfig, type ResolvedReactInspectorRuntimeConfig, } from './types';

package/dist/adapters/base/runtimeConfig.d.ts

@@ -0,0 +1,4 @@
+import { ReactInspectorAdapterCapabilities, ReactInspectorRuntimeConfig, ResolvedReactInspectorRuntimeConfig } from './types';
+export declare const defaultReactInspectorAdapterCapabilities: ReactInspectorAdapterCapabilities;
+export declare const defaultReactInspectorRuntimeConfig: ResolvedReactInspectorRuntimeConfig;
+export declare const resolveReactInspectorRuntimeConfig: (runtimeConfig?: ReactInspectorRuntimeConfig) => ResolvedReactInspectorRuntimeConfig;

package/dist/adapters/base/sourceMetadata.d.ts

@@ -0,0 +1,3 @@
+import { TreeNodeSource } from '../../../../inspector-protocol/src/index.ts';
+export declare const normalizeTreeNodeSource: (value: unknown) => TreeNodeSource | undefined;
+export declare const getNormalizedTreeNodeSourceFromElement: (element: Element) => TreeNodeSource | undefined;

package/dist/adapters/base/types.d.ts

@@ -0,0 +1,23 @@
+import { ReactTreeSnapshot } from './baseAdapter';
+export declare const reactInspectorRuntimeAdapterTargets: readonly ["auto", "vite", "next", "cra", "fiber"];
+export type ReactInspectorRuntimeAdapterTarget = (typeof reactInspectorRuntimeAdapterTargets)[number];
+export type ReactInspectorAdapterCapabilities = Readonly<{
+    tree: boolean;
+    props: boolean;
+    highlight: boolean;
+}>;
+export type ReactInspectorComponentPath = ReadonlyArray<string>;
+export type ReactInspectorAdapterContract = {
+    getTreeSnapshot: () => ReactTreeSnapshot;
+    getNodeProps: (nodeId: string) => unknown | undefined;
+    getDomElement: (nodeId: string) => Element | null;
+    getReactComponentPathForElement?: (element: Element) => ReactInspectorComponentPath | undefined;
+};
+export type ReactInspectorRuntimeConfig = {
+    adapter?: ReactInspectorRuntimeAdapterTarget;
+    capabilities?: Partial<ReactInspectorAdapterCapabilities>;
+};
+export type ResolvedReactInspectorRuntimeConfig = {
+    adapter: ReactInspectorRuntimeAdapterTarget;
+    capabilities: ReactInspectorAdapterCapabilities;
+};

package/dist/adapters/cra/craAdapter.d.ts

@@ -0,0 +1,6 @@
+import { ReactInspectorAdapterContract } from '../base/types';
+type CreateCraReactInspectorAdapterOptions = {
+    doc?: Document;
+};
+export declare const createCraReactInspectorAdapter: (options?: CreateCraReactInspectorAdapterOptions) => ReactInspectorAdapterContract;
+export {};

package/dist/adapters/cra/index.d.ts

@@ -0,0 +1,3 @@
+import { ReactInspectorRuntimeAdapterTarget } from '../base/types';
+export { createCraReactInspectorAdapter } from './craAdapter';
+export declare const reactInspectorCraAdapterTarget: ReactInspectorRuntimeAdapterTarget;

package/dist/adapters/fiber/fiberAdapter.d.ts

@@ -0,0 +1,9 @@
+import { ReactInspectorAdapterContract } from '../base/types';
+import { RootDiscoveryResult } from './types';
+export type FiberAdapterSnapshotDiagnostics = Readonly<{
+    discoveryResult: RootDiscoveryResult;
+}>;
+export type CreateFiberReactInspectorAdapterOptions = Readonly<{
+    onSnapshotDiagnostics?: (diagnostics: FiberAdapterSnapshotDiagnostics) => void;
+}>;
+export declare const createFiberReactInspectorAdapter: (options?: CreateFiberReactInspectorAdapterOptions) => ReactInspectorAdapterContract;

package/dist/adapters/fiber/highlightTarget.d.ts

@@ -0,0 +1,2 @@
+import { FiberNodeLookupPayload } from './nodeLookup';
+export declare const resolveFiberHighlightTarget: (lookupPayload: FiberNodeLookupPayload) => Element | null;

package/dist/adapters/fiber/index.d.ts

@@ -0,0 +1,3 @@
+import { ReactInspectorRuntimeAdapterTarget } from '../base/types';
+export { createFiberReactInspectorAdapter } from './fiberAdapter';
+export declare const reactInspectorFiberAdapterTarget: ReactInspectorRuntimeAdapterTarget;

package/dist/adapters/fiber/nodeIdentity.d.ts

@@ -0,0 +1,14 @@
+import { FiberTraversalRecord } from './traversal';
+export type FiberNodeIdentityResult = Readonly<{
+    nodeIdByRecordKey: ReadonlyMap<string, string>;
+}>;
+export type FiberNodeIdentityAllocator = Readonly<{
+    allocateNodeIds: (records: FiberTraversalRecord[]) => FiberNodeIdentityResult;
+}>;
+export declare const toFiberNodeIdentitySignature: (record: FiberTraversalRecord) => {
+    readonly rendererId: number;
+    readonly rendererRootIndex: number;
+    readonly parentKey: string;
+    readonly tag: number;
+};
+export declare const createFiberNodeIdentityAllocator: () => FiberNodeIdentityAllocator;

package/dist/adapters/fiber/nodeLookup.d.ts

@@ -0,0 +1,23 @@
+import { ReactTreeSnapshot } from '../base/baseAdapter';
+import { FiberTraversalResult } from './traversal';
+export type FiberNodeLookupPayload = Readonly<{
+    nodeId: string;
+    recordKey: string;
+    fiber: unknown;
+    tag: number;
+    rendererId: number;
+    rendererRootIndex: number;
+    path: string;
+    parentNodeId: string | null;
+    childNodeIds: string[];
+}>;
+export type FiberNodeLookup = Readonly<{
+    refreshFromSnapshot: (options: {
+        traversalResult: FiberTraversalResult;
+        nodeIdByRecordKey: ReadonlyMap<string, string>;
+        snapshot: ReactTreeSnapshot;
+    }) => void;
+    resolveByNodeId: (nodeId: string) => FiberNodeLookupPayload | undefined;
+    resolveClosestComponentPathForElement: (element: Element) => ReadonlyArray<string> | undefined;
+}>;
+export declare const createFiberNodeLookup: () => FiberNodeLookup;

package/dist/adapters/fiber/props.d.ts

@@ -0,0 +1,2 @@
+import { FiberNodeLookupPayload } from './nodeLookup';
+export declare const readFiberNodeProps: (lookupPayload: FiberNodeLookupPayload) => unknown | undefined;

package/dist/adapters/fiber/rootDiscovery.d.ts

@@ -0,0 +1,2 @@
+import { RootDiscoveryResult, RootDiscoveryWindow } from './types';
+export declare const discoverFiberRoots: (windowRef?: RootDiscoveryWindow) => RootDiscoveryResult;

package/dist/adapters/fiber/source.d.ts

@@ -0,0 +1,2 @@
+import { TreeNodeSource } from '../../../../inspector-protocol/src/index.ts';
+export declare const readFiberNodeSource: (fiberValue: unknown) => TreeNodeSource | undefined;

package/dist/adapters/fiber/spike/devtoolsProbe.d.ts

@@ -0,0 +1,2 @@
+import { DevtoolsProbeResult, DevtoolsProbeWindow } from './types';
+export declare const probeDevtoolsFiberRoots: (windowRef?: DevtoolsProbeWindow) => DevtoolsProbeResult;

package/dist/adapters/fiber/spike/displayName.d.ts

@@ -0,0 +1 @@
+export declare const resolveFiberDisplayName: (fiber: unknown) => string;

package/dist/adapters/fiber/spike/fallbackDecision.d.ts

@@ -0,0 +1,26 @@
+import { DevtoolsProbeResult } from './types';
+export declare const FIBER_FALLBACK_ACTION = "fallback-to-tag-adapter";
+export type FiberUnsupportedState = 'hook-missing' | 'renderer-empty' | 'root-missing' | 'traversal-failed';
+export type FiberFallbackAction = typeof FIBER_FALLBACK_ACTION;
+export type FiberDecisionDiagnostics = Readonly<{
+    source: 'fiber-spike';
+    probeStatus: DevtoolsProbeResult['status'] | 'unavailable';
+    probeReason: string;
+    rendererId?: number;
+    details?: unknown;
+    unsupportedState?: FiberUnsupportedState;
+}>;
+export type FiberFallbackDecision = Readonly<{
+    outcome: 'continue-fiber';
+    diagnostics: FiberDecisionDiagnostics;
+} | {
+    outcome: 'fallback';
+    unsupportedState: FiberUnsupportedState;
+    action: FiberFallbackAction;
+    diagnostics: FiberDecisionDiagnostics;
+}>;
+export type FiberFallbackInput = Readonly<{
+    probeResult?: unknown;
+    traversalError?: unknown;
+}>;
+export declare const decideFiberFallback: (input?: FiberFallbackInput) => FiberFallbackDecision;

package/dist/adapters/fiber/spike/fiberTraversal.d.ts

@@ -0,0 +1,12 @@
+import { TreeNode } from '../../../../../inspector-protocol/src/index.ts';
+import { DevtoolsProbeResult, FiberRootRef } from './types';
+export type FiberSpikeTreeNode = TreeNode & Readonly<{
+    rendererId: number;
+    fiber: unknown;
+}>;
+export type FiberTraversalSnapshot = Readonly<{
+    nodes: FiberSpikeTreeNode[];
+    rootIds: string[];
+}>;
+export declare const traverseFiberRoots: (roots: FiberRootRef[]) => FiberTraversalSnapshot;
+export declare const traverseFiberRootsFromProbe: (probeResult: DevtoolsProbeResult) => FiberTraversalSnapshot;

package/dist/adapters/fiber/spike/types.d.ts

@@ -0,0 +1,35 @@
+export type DevtoolsProbeWindow = {
+    __REACT_DEVTOOLS_GLOBAL_HOOK__?: unknown;
+};
+export type RendererRef = Readonly<{
+    rendererId: number;
+    renderer: unknown;
+}>;
+export type FiberRootRef = Readonly<{
+    rendererId: number;
+    root: unknown;
+}>;
+export type DevtoolsProbeUnsupportedReason = 'hook-missing' | 'hook-malformed' | 'renderers-malformed' | 'fiber-roots-reader-missing' | 'fiber-roots-malformed';
+export type DevtoolsProbeEmptyReason = 'renderer-empty' | 'root-empty';
+export type DevtoolsProbeErrorReason = 'fiber-roots-read-failed' | 'probe-failed';
+export type DevtoolsProbeOkResult = Readonly<{
+    status: 'ok';
+    renderers: RendererRef[];
+    roots: FiberRootRef[];
+}>;
+export type DevtoolsProbeUnsupportedResult = Readonly<{
+    status: 'unsupported';
+    reason: DevtoolsProbeUnsupportedReason;
+}>;
+export type DevtoolsProbeEmptyResult = Readonly<{
+    status: 'empty';
+    reason: DevtoolsProbeEmptyReason;
+    renderers: RendererRef[];
+}>;
+export type DevtoolsProbeErrorResult = Readonly<{
+    status: 'error';
+    reason: DevtoolsProbeErrorReason;
+    rendererId?: number;
+    details?: unknown;
+}>;
+export type DevtoolsProbeResult = DevtoolsProbeOkResult | DevtoolsProbeUnsupportedResult | DevtoolsProbeEmptyResult | DevtoolsProbeErrorResult;

package/dist/adapters/fiber/traversal.d.ts

@@ -0,0 +1,31 @@
+import { FiberRootRef, RootDiscoveryResult } from './types';
+export type FiberTraversalBudget = Readonly<{
+    maxRecords: number;
+    maxTraversalSteps: number;
+}>;
+export type FiberTraversalExhaustedBy = 'record-limit' | 'step-limit';
+export type FiberTraversalMeta = Readonly<{
+    truncated: boolean;
+    exhaustedBy: FiberTraversalExhaustedBy | null;
+    includedRecordCount: number;
+    traversalStepCount: number;
+    budget: FiberTraversalBudget;
+}>;
+export type FiberTraversalRecord = Readonly<{
+    key: string;
+    rendererId: number;
+    rendererRootIndex: number;
+    path: string;
+    tag: number;
+    fiber: unknown;
+    parentKey: string | null;
+    childKeys: string[];
+}>;
+export type FiberTraversalResult = Readonly<{
+    records: FiberTraversalRecord[];
+    rootRecordKeys: string[];
+    meta?: FiberTraversalMeta;
+}>;
+export declare const DEFAULT_FIBER_TRAVERSAL_BUDGET: FiberTraversalBudget;
+export declare const traverseFiberRoots: (roots: FiberRootRef[], budget?: Partial<FiberTraversalBudget>) => FiberTraversalResult;
+export declare const traverseDiscoveredFiberRoots: (discoveryResult: RootDiscoveryResult, budget?: Partial<FiberTraversalBudget>) => FiberTraversalResult;

package/dist/adapters/fiber/treeMapping.d.ts

@@ -0,0 +1,8 @@
+import { ReactTreeSnapshot } from '../base/baseAdapter';
+import { FiberTraversalResult } from './traversal';
+type FiberTreeMappingOptions = Readonly<{
+    traversalResult: FiberTraversalResult;
+    nodeIdByRecordKey: ReadonlyMap<string, string>;
+}>;
+export declare const mapFiberTraversalToTreeSnapshot: (options: FiberTreeMappingOptions) => ReactTreeSnapshot;
+export {};

package/dist/adapters/fiber/types.d.ts

@@ -0,0 +1,35 @@
+export type RootDiscoveryWindow = {
+    __REACT_DEVTOOLS_GLOBAL_HOOK__?: unknown;
+};
+export type RendererRef = Readonly<{
+    rendererId: number;
+    renderer: unknown;
+}>;
+export type FiberRootRef = Readonly<{
+    rendererId: number;
+    root: unknown;
+}>;
+export type RootDiscoveryUnsupportedReason = 'hook-missing' | 'hook-malformed' | 'renderers-malformed' | 'fiber-roots-reader-missing' | 'fiber-roots-malformed';
+export type RootDiscoveryEmptyReason = 'renderer-empty' | 'root-empty';
+export type RootDiscoveryErrorReason = 'fiber-roots-read-failed' | 'probe-failed';
+export type RootDiscoveryOkResult = Readonly<{
+    status: 'ok';
+    renderers: RendererRef[];
+    roots: FiberRootRef[];
+}>;
+export type RootDiscoveryUnsupportedResult = Readonly<{
+    status: 'unsupported';
+    reason: RootDiscoveryUnsupportedReason;
+}>;
+export type RootDiscoveryEmptyResult = Readonly<{
+    status: 'empty';
+    reason: RootDiscoveryEmptyReason;
+    renderers: RendererRef[];
+}>;
+export type RootDiscoveryErrorResult = Readonly<{
+    status: 'error';
+    reason: RootDiscoveryErrorReason;
+    rendererId?: number;
+    details?: unknown;
+}>;
+export type RootDiscoveryResult = RootDiscoveryOkResult | RootDiscoveryUnsupportedResult | RootDiscoveryEmptyResult | RootDiscoveryErrorResult;

package/dist/adapters/next/index.d.ts

@@ -0,0 +1,3 @@
+import { ReactInspectorRuntimeAdapterTarget } from '../base/types';
+export { createNextReactInspectorAdapter } from './nextAdapter';
+export declare const reactInspectorNextAdapterTarget: ReactInspectorRuntimeAdapterTarget;

package/dist/adapters/next/nextAdapter.d.ts

@@ -0,0 +1,6 @@
+import { ReactInspectorAdapterContract } from '../base/types';
+type CreateNextReactInspectorAdapterOptions = {
+    doc?: Document;
+};
+export declare const createNextReactInspectorAdapter: (options?: CreateNextReactInspectorAdapterOptions) => ReactInspectorAdapterContract;
+export {};

package/dist/adapters/vite/index.d.ts

@@ -0,0 +1,3 @@
+import { ReactInspectorRuntimeAdapterTarget } from '../base/types';
+export { createViteReactInspectorAdapter } from './viteAdapter';
+export declare const reactInspectorViteAdapterTarget: ReactInspectorRuntimeAdapterTarget;

package/dist/adapters/vite/viteAdapter.d.ts

@@ -0,0 +1,6 @@
+import { ReactInspectorAdapterContract } from '../base/types';
+type CreateViteReactInspectorAdapterOptions = {
+    doc?: Document;
+};
+export declare const createViteReactInspectorAdapter: (options?: CreateViteReactInspectorAdapterOptions) => ReactInspectorAdapterContract;
+export {};

package/dist/bridgeRuntime.d.ts

@@ -0,0 +1,37 @@
+import { HostToEmbeddedMessage } from '../../inspector-protocol/src/index.ts';
+import { ReactInspectorRuntimeConfig } from './adapters/base/types';
+import { ReactTreeAdapter } from './reactTreeAdapter';
+import { EmbeddedBridgeTelemetryHooks } from './security/bridgeTelemetry';
+import { InspectorBridgeSecurityOptions } from './security/tokenValidation';
+type InspectorBridgeMode = 'development' | 'iteration' | 'production';
+export type InspectorBridgeRequestHandlers = {
+    onHighlightNode?: (message: HostToEmbeddedMessage) => void;
+    onClearHighlight?: (message: HostToEmbeddedMessage) => void;
+};
+export type InitInspectorBridgeOptions = {
+    hostOrigins: readonly string[];
+    enabled: boolean;
+    killSwitchActive?: boolean;
+    mode?: InspectorBridgeMode;
+    runtimeConfig?: ReactInspectorRuntimeConfig;
+    capabilities?: string[];
+    treeAdapter?: ReactTreeAdapter;
+    adapterFactory?: (runtimeConfig?: ReactInspectorRuntimeConfig) => ReactTreeAdapter | undefined;
+    handlers?: InspectorBridgeRequestHandlers;
+    security?: InspectorBridgeSecurityOptions;
+    telemetry?: EmbeddedBridgeTelemetryHooks;
+};
+type InspectorBridge = {
+    destroy: () => void;
+};
+type EmbeddedReactInspectorSelectionApi = {
+    getReactComponentPathForElement: (element: Element) => ReadonlyArray<string> | undefined;
+};
+declare global {
+    interface Window {
+        __ARA_EMBEDDED_REACT_INSPECTOR_SELECTION__?: EmbeddedReactInspectorSelectionApi | undefined;
+    }
+}
+export declare const initInspectorBridge: (options: InitInspectorBridgeOptions) => InspectorBridge;
+export declare const destroyInspectorBridge: () => void;
+export {};

package/dist/bridgeRuntime.js

@@ -0,0 +1,7 @@
+import "@iteraai/inspector-protocol";
+import { g as o, i as t } from "./chunks/bridgeRuntime-Da4khSK2.js";
+export {
+  o as destroyInspectorBridge,
+  t as initInspectorBridge
+};
+//# sourceMappingURL=bridgeRuntime.js.map

package/dist/bridgeRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridgeRuntime.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}