@domscribe/react 0.1.0

package/utils/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../packages/domscribe-react/src/utils/constants.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BnB,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,aAU/B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,UAoB/B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe;IAC1B;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;CAEK,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;CAKrB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB,mCAAmC,CAAC"}

package/utils/constants.js

@@ -0,0 +1,123 @@
+/**
+ * React constants and magic numbers
+ * @module @domscribe/react/utils/constants
+ */
+/**
+ * React Fiber tags
+ *
+ * These are internal constants used by React to identify different types of Fiber nodes.
+ * Based on React's ReactWorkTags.js (values may vary slightly across React versions)
+ *
+ * @see https://github.com/facebook/react/blob/main/packages/react-reconciler/src/ReactWorkTags.js
+ */
+export const REACT_FIBER_TAGS = {
+    FunctionComponent: 0,
+    ClassComponent: 1,
+    IndeterminateComponent: 2, // Before we know whether it's function or class
+    HostRoot: 3,
+    HostPortal: 4,
+    HostComponent: 5, // DOM element (div, span, etc.)
+    HostText: 6, // Text node
+    Fragment: 7,
+    Mode: 8,
+    ContextConsumer: 9,
+    ContextProvider: 10,
+    ForwardRef: 11,
+    Profiler: 12,
+    SuspenseComponent: 13,
+    MemoComponent: 14,
+    SimpleMemoComponent: 15,
+    LazyComponent: 16,
+    IncompleteClassComponent: 17,
+    DehydratedFragment: 18,
+    SuspenseListComponent: 19,
+    ScopeComponent: 21,
+    OffscreenComponent: 22,
+    LegacyHiddenComponent: 23,
+    CacheComponent: 24,
+    TracingMarkerComponent: 25,
+};
+/**
+ * React internal props to exclude from capture
+ *
+ * These props are internal to React and should not be included in captured props
+ */
+export const REACT_INTERNAL_PROPS = new Set([
+    'children',
+    'key',
+    'ref',
+    '__self',
+    '__source',
+    '__owner',
+    '_owner',
+    '_store',
+    '$$typeof',
+]);
+/**
+ * Common HOC (Higher Order Component) patterns
+ *
+ * Used to detect and unwrap HOC wrappers to find the underlying component
+ */
+export const COMMON_HOC_PATTERNS = [
+    'withRouter',
+    'withStyles',
+    'withTheme',
+    'connect', // Redux
+    'observer', // MobX
+    'inject', // MobX
+    'withAuth',
+    'withData',
+    'withApollo', // Apollo
+    'graphql', // Apollo
+    'withTracker', // Meteor
+    'pure', // Recompose
+    'withProps', // Recompose
+    'withState', // Recompose
+    'withHandlers', // Recompose
+    'lifecycle', // Recompose
+    'branch', // Recompose
+    'renderComponent', // Recompose
+    'renderNothing', // Recompose
+];
+/**
+ * Default options for various operations
+ */
+export const DEFAULT_OPTIONS = {
+    /**
+     * Default maximum tree depth
+     */
+    MAX_TREE_DEPTH: 50,
+    /**
+     * Default maximum hooks to parse
+     */
+    MAX_HOOKS: 100,
+    /**
+     * Default maximum wrapper depth
+     */
+    MAX_WRAPPER_DEPTH: 3,
+    /**
+     * Default capture strategy
+     */
+    CAPTURE_STRATEGY: 'best-effort',
+    /**
+     * Default fallback component name
+     */
+    FALLBACK_COMPONENT_NAME: 'Anonymous',
+    /**
+     * Default hook name prefix
+     */
+    HOOK_NAME_PREFIX: 'hook_',
+};
+/**
+ * React element keys (different across React versions)
+ */
+export const REACT_ELEMENT_KEYS = {
+    FIBER_16: '__reactInternalInstance',
+    FIBER_17_18: '__reactFiber',
+    PROPS_16: '__reactEventHandlers',
+    PROPS_17_18: '__reactProps',
+};
+/**
+ * DevTools global hook key
+ */
+export const DEVTOOLS_HOOK_KEY = '__REACT_DEVTOOLS_GLOBAL_HOOK__';

package/utils/type-guards.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Type guard functions for React structures
+ * @module @domscribe/react/utils/type-guards
+ */
+import type { ExtendedReactFiber } from '../fiber/types.js';
+import type { ReactDevToolsHook, ReactDevToolsRenderer, ReactDevToolsRendererInterface } from '../adapter/types.js';
+/**
+ * Check if a value is a React Fiber node
+ */
+export declare function isReactFiber(value: unknown): value is ExtendedReactFiber;
+/**
+ * Check if a Fiber node is a component fiber (user or HOC)
+ */
+export declare function isComponentFiber(fiber: ExtendedReactFiber): boolean;
+/**
+ * Check if an element has React Fiber keys
+ */
+export declare function hasReactFiberKey(element: HTMLElement): boolean;
+/**
+ * Check if a value is a React DevTools global hook
+ */
+export declare function isReactDevToolsHook(value: unknown): value is ReactDevToolsHook;
+/**
+ * Check if a value is a React DevTools renderer entry
+ */
+export declare function isReactDevToolsRenderer(value: unknown): value is ReactDevToolsRenderer;
+/**
+ * Check if a value is a React DevTools renderer interface entry
+ */
+export declare function isReactDevToolsRendererInterface(value: unknown): value is ReactDevToolsRendererInterface;
+//# sourceMappingURL=type-guards.d.ts.map

package/utils/type-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["../../../../packages/domscribe-react/src/utils/type-guards.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACrB,8BAA8B,EAC/B,MAAM,qBAAqB,CAAC;AAE7B;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,kBAAkB,CAQxE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAQnE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAO9D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,iBAAiB,CAwC5B;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,qBAAqB,CAkBhC;AAED;;GAEG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,8BAA8B,CAUzC"}

package/utils/type-guards.js

@@ -0,0 +1,89 @@
+/**
+ * Type guard functions for React structures
+ * @module @domscribe/react/utils/type-guards
+ */
+import { REACT_FIBER_TAGS, REACT_ELEMENT_KEYS } from './constants.js';
+/**
+ * Check if a value is a React Fiber node
+ */
+export function isReactFiber(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'tag' in value &&
+        typeof value.tag === 'number' &&
+        'memoizedProps' in value);
+}
+/**
+ * Check if a Fiber node is a component fiber (user or HOC)
+ */
+export function isComponentFiber(fiber) {
+    return (fiber.tag === REACT_FIBER_TAGS.FunctionComponent ||
+        fiber.tag === REACT_FIBER_TAGS.ClassComponent ||
+        fiber.tag === REACT_FIBER_TAGS.ForwardRef ||
+        fiber.tag === REACT_FIBER_TAGS.MemoComponent ||
+        fiber.tag === REACT_FIBER_TAGS.SimpleMemoComponent);
+}
+/**
+ * Check if an element has React Fiber keys
+ */
+export function hasReactFiberKey(element) {
+    const keys = Object.keys(element);
+    return keys.some((key) => key.startsWith(REACT_ELEMENT_KEYS.FIBER_16) ||
+        key.startsWith(REACT_ELEMENT_KEYS.FIBER_17_18));
+}
+/**
+ * Check if a value is a React DevTools global hook
+ */
+export function isReactDevToolsHook(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if (!('renderers' in value) ||
+        typeof value.renderers !== 'object' ||
+        value.renderers === null) {
+        return false;
+    }
+    if (Object.values(value.renderers).some((renderer) => !isReactDevToolsRenderer(renderer))) {
+        return false;
+    }
+    if ('rendererInterfaces' in value) {
+        if (typeof value.rendererInterfaces !== 'object' ||
+            value.rendererInterfaces === null) {
+            return false;
+        }
+        if (Object.values(value.rendererInterfaces).some((rendererInterface) => !isReactDevToolsRendererInterface(rendererInterface))) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Check if a value is a React DevTools renderer entry
+ */
+export function isReactDevToolsRenderer(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if (!('findFiberByHostInstance' in value)) {
+        return false;
+    }
+    if (typeof value.findFiberByHostInstance !== 'function') {
+        return false;
+    }
+    if ('version' in value && typeof value.version !== 'string') {
+        return false;
+    }
+    return true;
+}
+/**
+ * Check if a value is a React DevTools renderer interface entry
+ */
+export function isReactDevToolsRendererInterface(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if ('version' in value && typeof value.version !== 'string') {
+        return false;
+    }
+    return true;
+}

package/utils/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared utility types for @domscribe/react
+ * @module @domscribe/react/utils/types
+ */
+export type { Nullable } from '@domscribe/core';
+//# sourceMappingURL=types.d.ts.map

package/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../packages/domscribe-react/src/utils/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}

package/utils/types.js

@@ -0,0 +1,5 @@
+/**
+ * Shared utility types for @domscribe/react
+ * @module @domscribe/react/utils/types
+ */
+export {};

package/vite/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Vite plugin entry point
+ * @module @domscribe/react/vite
+ */
+export { domscribe } from './vite-plugin.js';
+export type { DomscribeReactPluginOptions, DomscribeRuntimeOptions, DomscribeReactCaptureOptions, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/vite/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/domscribe-react/src/vite/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,YAAY,EACV,2BAA2B,EAC3B,uBAAuB,EACvB,4BAA4B,GAC7B,MAAM,YAAY,CAAC"}

package/vite/index.js

@@ -0,0 +1,5 @@
+/**
+ * Vite plugin entry point
+ * @module @domscribe/react/vite
+ */
+export { domscribe } from './vite-plugin.js';

package/vite/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Options for the React-aware Domscribe Vite plugin.
+ *
+ * Mirrors the base transform plugin options — all options are passed through.
+ * Adds `runtime` and `capture` namespaces for configuring runtime behavior
+ * and React adapter capture settings.
+ *
+ * @module @domscribe/react/vite/types
+ */
+/**
+ * RuntimeManager configuration (minus adapter, which is framework-specific).
+ */
+export interface DomscribeRuntimeOptions {
+    /** Capture phase. @default 1 */
+    phase?: 1 | 2;
+    /** Redact PII from captured data. @default true */
+    redactPII?: boolean;
+    /** CSS selectors to block from capture. @default [] */
+    blockSelectors?: string[];
+}
+/**
+ * React adapter capture configuration.
+ *
+ * @remarks
+ * `hookNameResolvers` uses plain objects (JSON-serializable) in plugin options.
+ * Converted to `Map<string, Map<number, string>>` at runtime.
+ */
+export interface DomscribeReactCaptureOptions {
+    /** Capture strategy. @default 'best-effort' */
+    strategy?: 'devtools' | 'fiber' | 'best-effort';
+    /** Maximum component tree depth. @default 50 */
+    maxTreeDepth?: number;
+    /** Include wrapper/HOC components. @default true */
+    includeWrappers?: boolean;
+    /** Hook name resolvers as plain objects. Keys are component names, values map hook index to name. */
+    hookNameResolvers?: Record<string, Record<number, string>>;
+}
+export interface DomscribeReactPluginOptions {
+    include?: RegExp;
+    exclude?: RegExp;
+    debug?: boolean;
+    relay?: {
+        autoStart?: boolean;
+        port?: number;
+        host?: string;
+    };
+    overlay?: boolean | {
+        initialMode?: 'collapsed' | 'expanded';
+        debug?: boolean;
+    };
+    /** RuntimeManager configuration (phase, PII redaction, block selectors). */
+    runtime?: DomscribeRuntimeOptions;
+    /** React adapter capture configuration (strategy, tree depth, wrappers, hook resolvers). */
+    capture?: DomscribeReactCaptureOptions;
+}
+//# sourceMappingURL=types.d.ts.map

package/vite/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../packages/domscribe-react/src/vite/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,gCAAgC;IAChC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IACd,mDAAmD;IACnD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,4BAA4B;IAC3C,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,UAAU,GAAG,OAAO,GAAG,aAAa,CAAC;IAChD,gDAAgD;IAChD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qGAAqG;IACrG,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,2BAA2B;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE;QACN,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IACF,OAAO,CAAC,EACJ,OAAO,GACP;QACE,WAAW,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC;QACvC,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC;IACN,4EAA4E;IAC5E,OAAO,CAAC,EAAE,uBAAuB,CAAC;IAClC,4FAA4F;IAC5F,OAAO,CAAC,EAAE,4BAA4B,CAAC;CACxC"}

package/vite/types.js

@@ -0,0 +1,10 @@
+/**
+ * Options for the React-aware Domscribe Vite plugin.
+ *
+ * Mirrors the base transform plugin options — all options are passed through.
+ * Adds `runtime` and `capture` namespaces for configuring runtime behavior
+ * and React adapter capture settings.
+ *
+ * @module @domscribe/react/vite/types
+ */
+export {};

package/vite/vite-plugin.d.ts

@@ -0,0 +1,29 @@
+/**
+ * React-aware Domscribe Vite plugin
+ * @module @domscribe/react/vite/vite-plugin
+ */
+import type { Plugin } from 'vite';
+import type { DomscribeReactPluginOptions } from './types.js';
+/**
+ * Domscribe Vite plugin for React projects.
+ *
+ * Creates the base transform plugin internally and adds RuntimeManager + ReactAdapter
+ * initialization via a virtual module. No entrypoint changes needed.
+ *
+ * @remarks
+ * For framework-agnostic usage (no runtime capture), import `domscribe`
+ * from `@domscribe/transform/plugins/vite` directly.
+ *
+ * Usage:
+ * ```ts
+ * // vite.config.ts
+ * import react from '@vitejs/plugin-react'
+ * import { domscribe } from '@domscribe/react/vite'
+ *
+ * export default defineConfig({
+ *   plugins: [react(), domscribe({ overlay: true })]
+ * })
+ * ```
+ */
+export declare function domscribe(options?: DomscribeReactPluginOptions): Plugin;
+//# sourceMappingURL=vite-plugin.d.ts.map

package/vite/vite-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin.d.ts","sourceRoot":"","sources":["../../../../packages/domscribe-react/src/vite/vite-plugin.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,MAAM,EAA+C,MAAM,MAAM,CAAC;AAEhF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAgB9D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,SAAS,CAAC,OAAO,CAAC,EAAE,2BAA2B,GAAG,MAAM,CAoFvE"}

package/vite/vite-plugin.js

@@ -0,0 +1,104 @@
+import { domscribe as baseDomscribe } from '@domscribe/transform/plugins/vite';
+/**
+ * URL path for the virtual init module.
+ *
+ * When the browser fetches this path, Vite's dev server routes it through
+ * the plugin pipeline (resolveId → load → transform). The transform step
+ * rewrites bare specifiers (`@domscribe/runtime`, `@domscribe/react`) to
+ * pre-bundled paths — the same ones the overlay resolves to internally —
+ * so RuntimeManager shares a single singleton across all consumers.
+ *
+ * Direct `/node_modules/` paths bypass pre-bundling and create separate
+ * module instances with separate singletons, which breaks runtime capture.
+ */
+const INIT_MODULE_PATH = '/@domscribe/react-init.js';
+/**
+ * Domscribe Vite plugin for React projects.
+ *
+ * Creates the base transform plugin internally and adds RuntimeManager + ReactAdapter
+ * initialization via a virtual module. No entrypoint changes needed.
+ *
+ * @remarks
+ * For framework-agnostic usage (no runtime capture), import `domscribe`
+ * from `@domscribe/transform/plugins/vite` directly.
+ *
+ * Usage:
+ * ```ts
+ * // vite.config.ts
+ * import react from '@vitejs/plugin-react'
+ * import { domscribe } from '@domscribe/react/vite'
+ *
+ * export default defineConfig({
+ *   plugins: [react(), domscribe({ overlay: true })]
+ * })
+ * ```
+ */
+export function domscribe(options) {
+    const basePlugin = baseDomscribe(options);
+    const baseTransformIndexHtml = basePlugin.transformIndexHtml;
+    const baseResolveId = typeof basePlugin.resolveId === 'function' ? basePlugin.resolveId : null;
+    const baseLoad = typeof basePlugin.load === 'function' ? basePlugin.load : null;
+    basePlugin.name = 'vite-plugin-domscribe-react';
+    basePlugin.resolveId = function (id, ...args) {
+        if (id === INIT_MODULE_PATH) {
+            return INIT_MODULE_PATH;
+        }
+        return baseResolveId?.call(this, id, ...args) ?? null;
+    };
+    basePlugin.load = function (id, ...args) {
+        if (id === INIT_MODULE_PATH) {
+            const rt = options?.runtime ?? {};
+            const cap = options?.capture ?? {};
+            const debug = options?.debug ?? false;
+            // Build hookNameResolvers reconstruction if provided
+            const resolversLine = cap.hookNameResolvers
+                ? `const _r = ${JSON.stringify(cap.hookNameResolvers)};\n` +
+                    `const _resolvers = new Map(Object.entries(_r).map(([k,v])=>[k,new Map(Object.entries(v).map(([i,n])=>[Number(i),n]))]));`
+                : `const _resolvers = new Map();`;
+            // Bare specifiers here get rewritten by Vite's transform pipeline
+            // to pre-bundled paths, matching what the overlay resolves internally
+            return [
+                `import { RuntimeManager } from '@domscribe/runtime';`,
+                `import { createReactAdapter } from '@domscribe/react';`,
+                ``,
+                resolversLine,
+                ``,
+                `RuntimeManager.getInstance().initialize({`,
+                `  phase: ${rt.phase ?? 1},`,
+                `  debug: ${debug},`,
+                `  redactPII: ${rt.redactPII ?? true},`,
+                `  blockSelectors: ${JSON.stringify(rt.blockSelectors ?? [])},`,
+                `  adapter: createReactAdapter({`,
+                `    strategy: '${cap.strategy ?? 'best-effort'}',`,
+                `    maxTreeDepth: ${cap.maxTreeDepth ?? 50},`,
+                `    includeWrappers: ${cap.includeWrappers ?? true},`,
+                `    debug: ${debug},`,
+                `    hookNameResolvers: _resolvers,`,
+                `  }),`,
+                `}).catch(e => console.warn('[domscribe] Failed to init React runtime:', e.message));`,
+            ].join('\n');
+        }
+        return baseLoad?.call(this, id, ...args) ?? null;
+    };
+    basePlugin.transformIndexHtml = () => {
+        // Call the base plugin's transformIndexHtml (relay port + overlay injection)
+        const baseResult = typeof baseTransformIndexHtml === 'function'
+            ? baseTransformIndexHtml()
+            : undefined;
+        // Build on existing tags from the base plugin
+        const baseTags = baseResult && typeof baseResult === 'object' && 'tags' in baseResult
+            ? (baseResult.tags ?? [])
+            : [];
+        // Import the virtual init module — browser fetches this URL, Vite
+        // serves it through its full plugin + transform pipeline
+        const runtimeTag = {
+            tag: 'script',
+            attrs: { type: 'module' },
+            children: `import('${INIT_MODULE_PATH}');`,
+            injectTo: 'body',
+        };
+        const tags = [...baseTags, runtimeTag];
+        return { html: '', tags };
+    };
+    return basePlugin;
+}

package/webpack/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Webpack plugin entry point
+ * @module @domscribe/react/webpack
+ */
+export { DomscribeWebpackPlugin } from './webpack-plugin.js';
+export type { DomscribeReactWebpackPluginOptions } from './webpack-plugin.js';
+//# sourceMappingURL=index.d.ts.map

package/webpack/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/domscribe-react/src/webpack/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,YAAY,EAAE,kCAAkC,EAAE,MAAM,qBAAqB,CAAC"}

package/webpack/index.js

@@ -0,0 +1,5 @@
+/**
+ * Webpack plugin entry point
+ * @module @domscribe/react/webpack
+ */
+export { DomscribeWebpackPlugin } from './webpack-plugin.js';

package/webpack/webpack-plugin.d.ts

@@ -0,0 +1,50 @@
+/**
+ * React-aware Domscribe webpack plugin
+ * @module @domscribe/react/webpack/webpack-plugin
+ */
+import type { Compiler, WebpackPluginInstance } from 'webpack';
+import { type WebpackPluginOptions } from '@domscribe/transform/plugins/webpack';
+import type { DomscribeRuntimeOptions, DomscribeReactCaptureOptions } from '../vite/types.js';
+/**
+ * Unified options for the React webpack plugin.
+ *
+ * Extends the base transform options with `runtime` and `capture` namespaces
+ * for configuring RuntimeManager and ReactAdapter behavior.
+ */
+export interface DomscribeReactWebpackPluginOptions extends WebpackPluginOptions {
+    /** RuntimeManager configuration (phase, PII redaction, block selectors). */
+    runtime?: DomscribeRuntimeOptions;
+    /** React adapter capture configuration (strategy, tree depth, wrappers, hook resolvers). */
+    capture?: DomscribeReactCaptureOptions;
+}
+/**
+ * Domscribe webpack plugin for React projects.
+ *
+ * Creates the base transform plugin internally and adds `@domscribe/react/auto-init`
+ * as a webpack entry so that RuntimeManager + ReactAdapter are initialized
+ * automatically — no entrypoint changes needed.
+ *
+ * @remarks
+ * For framework-agnostic usage (no runtime capture), import `DomscribeWebpackPlugin`
+ * from `@domscribe/transform/plugins/webpack` directly.
+ *
+ * Usage:
+ * ```ts
+ * // webpack.config.ts
+ * import { DomscribeWebpackPlugin } from '@domscribe/react/webpack'
+ *
+ * export default {
+ *   plugins: [new DomscribeWebpackPlugin({ overlay: true })]
+ * }
+ * ```
+ */
+export declare class DomscribeWebpackPlugin implements WebpackPluginInstance {
+    private readonly basePlugin;
+    private readonly runtimeOptions;
+    private readonly captureOptions;
+    private readonly debug;
+    constructor(options?: DomscribeReactWebpackPluginOptions);
+    apply(compiler: Compiler): void;
+    private addAdapterEntry;
+}
+//# sourceMappingURL=webpack-plugin.d.ts.map

package/webpack/webpack-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack-plugin.d.ts","sourceRoot":"","sources":["../../../../packages/domscribe-react/src/webpack/webpack-plugin.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,KAAK,EACV,uBAAuB,EACvB,4BAA4B,EAC7B,MAAM,kBAAkB,CAAC;AAE1B;;;;;GAKG;AACH,MAAM,WAAW,kCAAmC,SAAQ,oBAAoB;IAC9E,4EAA4E;IAC5E,OAAO,CAAC,EAAE,uBAAuB,CAAC;IAClC,4FAA4F;IAC5F,OAAO,CAAC,EAAE,4BAA4B,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,sBAAuB,YAAW,qBAAqB;IAClE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA0B;IACzD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA+B;IAC9D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAU;gBAEpB,OAAO,CAAC,EAAE,kCAAkC;IAOxD,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAqB/B,OAAO,CAAC,eAAe;CAUxB"}

package/webpack/webpack-plugin.js

@@ -0,0 +1,63 @@
+import { DomscribeWebpackPlugin as BaseDomscribeWebpackPlugin, } from '@domscribe/transform/plugins/webpack';
+/**
+ * Domscribe webpack plugin for React projects.
+ *
+ * Creates the base transform plugin internally and adds `@domscribe/react/auto-init`
+ * as a webpack entry so that RuntimeManager + ReactAdapter are initialized
+ * automatically — no entrypoint changes needed.
+ *
+ * @remarks
+ * For framework-agnostic usage (no runtime capture), import `DomscribeWebpackPlugin`
+ * from `@domscribe/transform/plugins/webpack` directly.
+ *
+ * Usage:
+ * ```ts
+ * // webpack.config.ts
+ * import { DomscribeWebpackPlugin } from '@domscribe/react/webpack'
+ *
+ * export default {
+ *   plugins: [new DomscribeWebpackPlugin({ overlay: true })]
+ * }
+ * ```
+ */
+export class DomscribeWebpackPlugin {
+    basePlugin;
+    runtimeOptions;
+    captureOptions;
+    debug;
+    constructor(options) {
+        this.basePlugin = new BaseDomscribeWebpackPlugin(options);
+        this.runtimeOptions = options?.runtime ?? {};
+        this.captureOptions = options?.capture ?? {};
+        this.debug = options?.debug ?? false;
+    }
+    apply(compiler) {
+        const { DefinePlugin } = compiler.webpack;
+        new DefinePlugin({
+            __DOMSCRIBE_RUNTIME_OPTIONS__: JSON.stringify({
+                phase: this.runtimeOptions.phase,
+                debug: this.debug,
+                redactPII: this.runtimeOptions.redactPII,
+                blockSelectors: this.runtimeOptions.blockSelectors,
+            }),
+            __DOMSCRIBE_ADAPTER_OPTIONS__: JSON.stringify({
+                strategy: this.captureOptions.strategy,
+                maxTreeDepth: this.captureOptions.maxTreeDepth,
+                includeWrappers: this.captureOptions.includeWrappers,
+                hookNameResolvers: this.captureOptions.hookNameResolvers,
+                debug: this.debug,
+            }),
+        }).apply(compiler);
+        this.addAdapterEntry(compiler);
+        this.basePlugin.apply(compiler);
+    }
+    addAdapterEntry(compiler) {
+        const entry = compiler.options.entry;
+        if (typeof entry === 'object' && !Array.isArray(entry)) {
+            const firstKey = Object.keys(entry)[0];
+            if (firstKey && entry[firstKey]?.import) {
+                entry[firstKey].import.push('@domscribe/react/auto-init');
+            }
+        }
+    }
+}