@anscribe/react 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 msmps
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @anscribe/react
+
+> Cross-framework React DevTools enrichment for Anscribe Captures.
+
+Installs a React DevTools hook that captures React's `currentDispatcherRef` and observes commits. Anscribe's host adapters (`@anscribe/opentui` today; `@anscribe/ink` and friends are the intended future) consume it to enrich Captures with `componentName`, `componentPath`, and source-frame references.
+
+This package is the cross-framework substrate. Most users should reach for the host adapter's re-export instead — for OpenTUI that's [`@anscribe/opentui/react/preload`](https://www.npmjs.com/package/@anscribe/opentui).
+
+## When to use this package directly
+
+Import `@anscribe/react/preload` directly when:
+
+- You're building a non-OpenTUI Anscribe host adapter and want to share the enricher.
+- You're embedding the enricher into a custom React TUI bootstrapper where adapter subpaths don't fit your build pipeline.
+
+Otherwise, prefer your host adapter's preload subpath.
+
+## Install
+
+```bash
+bun add @anscribe/react
+```
+
+`react@>=19.2.0` is a peer dependency.
+
+## Use
+
+```ts
+// MUST be imported before "react" / "@opentui/react" / your React renderer
+import "@anscribe/react/preload";
+```
+
+The preload installs `globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__` (or patches an existing one) before React reads it. It must run **before** the first React render, otherwise the renderer is created without the hook attached and metadata enrichment silently no-ops.
+
+Adapter-internal API (consumed by host adapters, not end users):
+
+```ts
+import { reactMetadataEnricher, isReactRuntimeEnrichmentAvailable } from "@anscribe/react";
+```
+
+## License
+
+MIT © [msmps](https://github.com/msmps)

package/dist/fiber-pipeline-OQRkNJFF.mjs

@@ -0,0 +1,382 @@
+import { SourceReference } from "@anscribe/core";
+import { Effect } from "effect";
+//#region src/source-frames.ts
+const V8_FRAME = /^\s*at\s+(?:(.+?)\s+)?\(?(.+?):(\d+):(\d+)\)?\s*$/;
+const WEBKIT_FRAME = /^(?:(.+?)@)?(.+?):(\d+):(\d+)$/;
+const REJECT_PATH = /(?:node_modules\/|@anscribe\/[a-z-]+\/(?:dist|src|bin)\/|\/packages\/(?:core|react|opentui|mcp|ink)\/(?:src|bin)\/)/;
+const REJECT_FN = /^(?:react-stack-bottom-frame|runWithFiberInDEV|commitMount|commitWork)$/;
+const REACT_PACKAGE_BUNDLE_TAIL = /^(?:cjs|umd|esm|dist|build|lib)\/|^index\.[mc]?js(?:$|\/)/;
+const PREFIX_REGEX = /^(?:webpack-internal:\/{2,3}|webpack:\/{2,3}|turbopack:\/{2,3}|bun:\/{2,3}|node:)/;
+const knownReactPackageNames = new Set([
+	"react",
+	"react-dom",
+	"react-reconciler",
+	"scheduler"
+]);
+function recordReactRendererPackageName(name) {
+	if (typeof name !== "string" || name.length === 0) return;
+	knownReactPackageNames.add(name);
+}
+function parseStackFrame(frame) {
+	const trimmed = frame.trim();
+	if (trimmed.length === 0) return void 0;
+	const v8 = V8_FRAME.exec(trimmed);
+	if (v8 !== null) return makeParsedFrame(v8[1], v8[2], v8[3], v8[4]);
+	const webkit = WEBKIT_FRAME.exec(trimmed);
+	if (webkit !== null) return makeParsedFrame(webkit[1], webkit[2], webkit[3], webkit[4]);
+}
+function cleanSourcePath(path) {
+	let cleaned = path;
+	cleaned = cleaned.replace(PREFIX_REGEX, "");
+	if (cleaned.startsWith("file://")) {
+		cleaned = cleaned.slice(7);
+		try {
+			cleaned = decodeURIComponent(cleaned);
+		} catch {}
+	}
+	if (cleaned.startsWith("./")) cleaned = cleaned.slice(2);
+	else if (cleaned.startsWith("~/")) cleaned = cleaned.slice(2);
+	const queryIndex = cleaned.search(/[?#]/);
+	if (queryIndex !== -1) cleaned = cleaned.slice(0, queryIndex);
+	return cleaned;
+}
+function isApplicationFrame(path, functionName) {
+	if (path.length === 0) return false;
+	if (!path.includes("/") && !path.includes("\\")) return false;
+	if (containsKnownReactPackageSegment(path)) return false;
+	if (REJECT_PATH.test(path)) return false;
+	if (functionName !== void 0 && REJECT_FN.test(functionName)) return false;
+	return true;
+}
+function makeParsedFrame(rawFunctionName, rawFile, rawLine, rawColumn) {
+	if (rawFile === void 0 || rawFile.length === 0) return void 0;
+	const file = cleanSourcePath(rawFile);
+	if (file.length === 0) return void 0;
+	const line = rawLine === void 0 ? void 0 : safeParseInt(rawLine);
+	const column = rawColumn === void 0 ? void 0 : safeParseInt(rawColumn);
+	const functionName = rawFunctionName !== void 0 && rawFunctionName.length > 0 ? rawFunctionName : void 0;
+	return {
+		file,
+		...line !== void 0 && { line },
+		...column !== void 0 && { column },
+		...functionName !== void 0 && { functionName }
+	};
+}
+function safeParseInt(value) {
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function containsKnownReactPackageSegment(path) {
+	const normalised = path.replace(/\\/g, "/");
+	for (const name of knownReactPackageNames) {
+		const marker = `/${name}/`;
+		const idx = normalised.indexOf(marker);
+		if (idx === -1) continue;
+		if (name.includes("-")) return true;
+		const tail = normalised.slice(idx + marker.length);
+		if (REACT_PACKAGE_BUNDLE_TAIL.test(tail)) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/fiber-pipeline.ts
+const REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
+const REACT_MEMO_TYPE = Symbol.for("react.memo");
+const REACT_LAZY_TYPE = Symbol.for("react.lazy");
+const ABORT_MESSAGE = "anscribe.dispatcher-probe.abort";
+const DISPATCHER_PROXY = new Proxy(Object.create(null), { get() {
+	throw new Error(ABORT_MESSAGE);
+} });
+const probeCache = /* @__PURE__ */ new WeakMap();
+const renderableEnrichment = /* @__PURE__ */ new WeakMap();
+let currentDispatcherRef;
+let reactMetadataEnricherRegistered = false;
+let reactRendererInjected = false;
+function markReactMetadataEnricherRegistered() {
+	reactMetadataEnricherRegistered = true;
+}
+function markReactRendererInjected() {
+	reactRendererInjected = true;
+}
+function isReactRuntimeEnrichmentAvailable() {
+	return reactMetadataEnricherRegistered && reactRendererInjected;
+}
+function reactMetadataEnricher(input) {
+	return Effect.sync(() => {
+		const enrichment = isObject(input.renderable) ? renderableEnrichment.get(input.renderable) : void 0;
+		if (enrichment === void 0) return void 0;
+		return enrichment.sourceReferences.length > 0 ? {
+			metadata: enrichment.metadata,
+			sourceReferences: enrichment.sourceReferences
+		} : { metadata: enrichment.metadata };
+	});
+}
+function recordReactCommitRoot(root) {
+	const current = isObject(root) ? root.current : void 0;
+	if (current === void 0 || current === null) return;
+	walkFiber(current);
+}
+function walkFiber(fiber) {
+	recordFiber(fiber);
+	if (fiber.child !== void 0 && fiber.child !== null) walkFiber(fiber.child);
+	if (fiber.sibling !== void 0 && fiber.sibling !== null) walkFiber(fiber.sibling);
+}
+function recordFiber(fiber) {
+	const renderable = fiber.stateNode;
+	if (!isObject(renderable)) return;
+	const componentPath = readComponentPath(fiber);
+	const componentName = componentPath.at(-1);
+	if (componentName === void 0) return;
+	const sourceReferences = extractSourceReferences(fiber);
+	renderableEnrichment.set(renderable, {
+		metadata: {
+			componentName,
+			componentPath: componentPath.join(" > ")
+		},
+		sourceReferences
+	});
+}
+function readComponentPath(fiber) {
+	const path = [];
+	for (let current = fiber.return; current !== void 0 && current !== null; current = current.return) {
+		const name = readComponentName(current);
+		if (name !== void 0 && !isInternalComponentName(name)) path.push(name);
+	}
+	return path.reverse();
+}
+function readComponentName(fiber) {
+	const type = fiber.elementType ?? fiber.type;
+	if (typeof type === "string") return;
+	if (typeof type === "function") return readNamedFunction(type);
+	if (!isObject(type)) return;
+	const displayName = readString(type.displayName);
+	if (displayName !== void 0) return displayName;
+	const nestedType = type.type;
+	if (typeof nestedType === "function") return readNamedFunction(nestedType);
+	const render = type.render;
+	if (typeof render === "function") return readNamedFunction(render);
+	const contextDisplayName = isObject(type._context) ? readString(type._context.displayName) : void 0;
+	return contextDisplayName === void 0 ? void 0 : `${contextDisplayName}.Provider`;
+}
+function readNamedFunction(fn) {
+	return readString(fn.displayName) ?? readString(fn.name);
+}
+function isInternalComponentName(name) {
+	return name === "ErrorBoundary" || name === "AppContext.Provider" || name === "Context.Provider" || name === "Provider";
+}
+function extractSourceReferences(fiber) {
+	const direct = readFromDebugStack(fiber) ?? readFromOwnerDebugStack(fiber) ?? readFromOwnerDebugSource(fiber) ?? readFromJsxSource(fiber) ?? readFromDebugInfo(fiber);
+	if (direct !== void 0) return [direct];
+	const componentFunction = unwrapReactComponentFunction(fiber.type);
+	if (componentFunction === void 0) return [];
+	const cached = probeCache.get(componentFunction);
+	if (cached !== void 0) return cached.ref === null ? [] : [cached.ref];
+	const probed = probeComponentSource(componentFunction) ?? null;
+	probeCache.set(componentFunction, { ref: probed });
+	return probed === null ? [] : [probed];
+}
+function readFromDebugStack(fiber) {
+	const raw = fiber._debugStack;
+	const stack = stackToString(raw);
+	if (stack === void 0) return void 0;
+	const parsed = pickApplicationFrame(stack);
+	if (parsed === void 0) return void 0;
+	return makeSourceReference(parsed, "react-debug-stack");
+}
+function readFromOwnerDebugStack(fiber) {
+	let owner = fiber._debugOwner;
+	while (owner !== void 0 && owner !== null) {
+		const stack = stackToString(owner._debugStack);
+		if (stack !== void 0) {
+			const parsed = pickApplicationFrame(stack);
+			if (parsed !== void 0) return makeSourceReference(parsed, "react-debug-owner-stack", readComponentDisplayName(owner.type));
+		}
+		owner = owner._debugOwner;
+	}
+}
+function readFromOwnerDebugSource(fiber) {
+	let owner = fiber._debugOwner;
+	while (owner !== void 0 && owner !== null) {
+		const source = readSourceFields(owner._debugSource);
+		if (source !== void 0) return makeSourceReference(source, "react-debug-owner", readComponentDisplayName(owner.type));
+		owner = owner._debugOwner;
+	}
+}
+function readFromJsxSource(fiber) {
+	const props = fiber.memoizedProps;
+	if (!isObject(props)) return void 0;
+	const parsed = readSourceFields(props.__source);
+	if (parsed === void 0) return void 0;
+	return makeSourceReference(parsed, "jsx-runtime-source", readSelfConstructorName(props.__self));
+}
+function readFromDebugInfo(fiber) {
+	const info = fiber._debugInfo;
+	if (!Array.isArray(info)) return void 0;
+	for (const entry of info) {
+		if (!isObject(entry)) continue;
+		const stack = entry.stack;
+		if (typeof stack === "string" && stack.length > 0) {
+			const parsed = pickApplicationFrame(stack);
+			if (parsed !== void 0) return makeSourceReference(parsed, "react-debug-info", readComponentDisplayName(entry.name ?? void 0));
+		}
+		const owner = entry.owner;
+		if (isObject(owner)) {
+			const source = readSourceFields(owner._debugSource);
+			if (source !== void 0) return makeSourceReference(source, "react-debug-info", readComponentDisplayName(owner.type ?? entry.name));
+		}
+	}
+}
+function stackToString(value) {
+	if (typeof value === "string" && value.length > 0) return value;
+	if (value instanceof Error && typeof value.stack === "string") return value.stack;
+	if (isObject(value) && typeof value.stack === "string") return value.stack;
+}
+function pickApplicationFrame(stack) {
+	for (const line of stack.split("\n")) {
+		const parsed = parseStackFrame(line);
+		if (parsed === void 0) continue;
+		if (parsed.file === void 0) continue;
+		if (!isApplicationFrame(parsed.file, parsed.functionName)) continue;
+		return parsed;
+	}
+}
+function readSourceFields(raw) {
+	if (!isObject(raw)) return void 0;
+	const fileName = raw.fileName;
+	if (typeof fileName !== "string" || fileName.length === 0) return void 0;
+	const cleaned = cleanSourcePath(fileName);
+	if (cleaned.length === 0) return void 0;
+	const lineNumber = raw.lineNumber;
+	const columnNumber = raw.columnNumber;
+	return {
+		file: cleaned,
+		...typeof lineNumber === "number" && Number.isFinite(lineNumber) && { line: lineNumber },
+		...typeof columnNumber === "number" && Number.isFinite(columnNumber) && { column: columnNumber }
+	};
+}
+function readSelfConstructorName(value) {
+	if (!isObject(value)) return void 0;
+	const ctor = value.constructor;
+	if (typeof ctor !== "function") return void 0;
+	const name = ctor.name;
+	return typeof name === "string" && name.length > 0 ? name : void 0;
+}
+function makeSourceReference(parsed, origin, componentName) {
+	return new SourceReference({
+		...parsed.file !== void 0 && { file: parsed.file },
+		...parsed.line !== void 0 && { line: parsed.line },
+		...parsed.column !== void 0 && { column: parsed.column },
+		...parsed.functionName !== void 0 && { functionName: parsed.functionName },
+		...componentName !== void 0 && { componentName },
+		origin
+	});
+}
+function unwrapReactComponentFunction(value) {
+	let current = value;
+	const seen = /* @__PURE__ */ new Set();
+	while (current !== null && current !== void 0 && !seen.has(current)) {
+		seen.add(current);
+		if (typeof current === "function") return current;
+		if (typeof current !== "object") return;
+		const wrapper = current;
+		if (wrapper.$$typeof === REACT_FORWARD_REF_TYPE) {
+			current = wrapper.render;
+			continue;
+		}
+		if (wrapper.$$typeof === REACT_MEMO_TYPE) {
+			current = wrapper.type;
+			continue;
+		}
+		if (wrapper.$$typeof === REACT_LAZY_TYPE) {
+			const init = wrapper._init;
+			if (typeof init !== "function") return;
+			try {
+				current = init(wrapper._payload);
+				continue;
+			} catch {
+				return;
+			}
+		}
+		return;
+	}
+}
+/**
+* Record the `currentDispatcherRef` that the React reconciler hands to
+* `__REACT_DEVTOOLS_GLOBAL_HOOK__.inject`. That object is the live
+* `ReactSharedInternals` of the React instance the application renders with,
+* so reading the dispatcher slot from it always targets the right copy of
+* React even when more than one is resolvable on disk.
+*
+* @internal
+*/
+function setReactCurrentDispatcherRef(ref) {
+	if (isObject(ref)) currentDispatcherRef = ref;
+}
+function probeComponentSource(componentFunction) {
+	if (isClassComponent(componentFunction)) return void 0;
+	const inner = unwrapReactComponentFunction(componentFunction);
+	if (inner === void 0) return void 0;
+	const slot = locateDispatcherSlot();
+	if (slot === void 0) return void 0;
+	const original = slot.root[slot.key];
+	slot.root[slot.key] = DISPATCHER_PROXY;
+	let stack;
+	try {
+		inner({});
+	} catch (error) {
+		stack = error instanceof Error && typeof error.stack === "string" ? error.stack : void 0;
+	} finally {
+		slot.root[slot.key] = original;
+	}
+	if (stack === void 0) return void 0;
+	for (const line of stack.split("\n")) {
+		const parsed = parseStackFrame(line);
+		if (parsed === void 0 || parsed.file === void 0) continue;
+		if (!isApplicationFrame(parsed.file, parsed.functionName)) continue;
+		return new SourceReference({
+			file: parsed.file,
+			...parsed.line !== void 0 && { line: parsed.line },
+			...parsed.column !== void 0 && { column: parsed.column },
+			...parsed.functionName !== void 0 && { functionName: parsed.functionName },
+			origin: "dispatcher-probe"
+		});
+	}
+}
+function isClassComponent(value) {
+	const prototype = value.prototype;
+	if (prototype === null || typeof prototype !== "object") return false;
+	return prototype.isReactComponent !== void 0;
+}
+function locateDispatcherSlot() {
+	const ref = currentDispatcherRef;
+	if (ref === void 0) return void 0;
+	if ("H" in ref) return {
+		root: ref,
+		key: "H"
+	};
+	const legacyDispatcher = ref.ReactCurrentDispatcher;
+	if (isObject(legacyDispatcher) && "current" in legacyDispatcher) return {
+		root: legacyDispatcher,
+		key: "current"
+	};
+}
+function readComponentDisplayName(type) {
+	if (typeof type === "string" && type.length > 0) return type;
+	if (typeof type === "function") {
+		const fn = type;
+		if (typeof fn.displayName === "string" && fn.displayName.length > 0) return fn.displayName;
+		if (typeof fn.name === "string" && fn.name.length > 0) return fn.name;
+	}
+	if (isObject(type)) {
+		const obj = type;
+		if (typeof obj.displayName === "string" && obj.displayName.length > 0) return obj.displayName;
+	}
+}
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+function readString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+//#endregion
+export { recordReactCommitRoot as a, reactMetadataEnricher as i, markReactMetadataEnricherRegistered as n, setReactCurrentDispatcherRef as o, markReactRendererInjected as r, recordReactRendererPackageName as s, isReactRuntimeEnrichmentAvailable as t };

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+import { CaptureEnrichmentOutput, CapturedTarget, SourceReference } from "@anscribe/core";
+import { Effect } from "effect";
+
+//#region src/fiber-pipeline.d.ts
+declare function isReactRuntimeEnrichmentAvailable(): boolean;
+declare function reactMetadataEnricher(input: {
+  renderable: unknown;
+  target: CapturedTarget;
+}): Effect.Effect<CaptureEnrichmentOutput | undefined>;
+//#endregion
+export { isReactRuntimeEnrichmentAvailable, reactMetadataEnricher };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { i as reactMetadataEnricher, t as isReactRuntimeEnrichmentAvailable } from "./fiber-pipeline-OQRkNJFF.mjs";
+export { isReactRuntimeEnrichmentAvailable, reactMetadataEnricher };

package/dist/preload.d.mts

@@ -0,0 +1,23 @@
+//#region src/preload.d.ts
+type ReactDevToolsRenderer = Record<string, unknown>;
+type ReactDevToolsHook = {
+  supportsFiber?: boolean;
+  hasUnsupportedRendererAttached?: boolean;
+  renderers?: Map<number, ReactDevToolsRenderer>;
+  inject?: (renderer: ReactDevToolsRenderer) => number;
+  onCommitFiberRoot?: (rendererId: number, root: unknown, priorityLevel?: unknown, didError?: unknown) => void;
+  onScheduleFiberRoot?: (rendererId: number, root: unknown, children: unknown) => void;
+  onPostCommitFiberRoot?: (rendererId: number, root: unknown) => void;
+  onCommitFiberUnmount?: (rendererId: number, fiber: unknown) => void;
+  checkDCE?: (fn: unknown) => void;
+  on?: (...args: unknown[]) => void;
+  off?: (...args: unknown[]) => void;
+  sub?: (...args: unknown[]) => () => void;
+  [key: symbol]: true | undefined;
+};
+declare global {
+  var __REACT_DEVTOOLS_GLOBAL_HOOK__: ReactDevToolsHook | undefined;
+}
+declare function installReactPreloadHook(): ReactDevToolsHook;
+//#endregion
+export { installReactPreloadHook };

package/dist/preload.mjs

@@ -0,0 +1,76 @@
+import { a as recordReactCommitRoot, n as markReactMetadataEnricherRegistered, o as setReactCurrentDispatcherRef, r as markReactRendererInjected, s as recordReactRendererPackageName } from "./fiber-pipeline-OQRkNJFF.mjs";
+//#region src/preload.ts
+const PATCHED = Symbol.for("anscribe.react.preload.patched");
+const ENRICHER_REGISTERED = Symbol.for("anscribe.react.preload.enricherRegistered");
+const noop = () => {};
+installReactPreloadHook();
+function installReactPreloadHook() {
+	const hook = getOrCreateHook();
+	if (hook[PATCHED] === true) {
+		registerReactMetadataEnricher(hook);
+		return hook;
+	}
+	hook[PATCHED] = true;
+	registerReactMetadataEnricher(hook);
+	hook.supportsFiber = true;
+	hook.hasUnsupportedRendererAttached = false;
+	hook.renderers ??= /* @__PURE__ */ new Map();
+	for (const renderer of hook.renderers.values()) {
+		markReactRendererInjected();
+		captureDispatcherRef(renderer);
+	}
+	hook.on ??= noop;
+	hook.off ??= noop;
+	hook.sub ??= () => noop;
+	hook.checkDCE ??= noop;
+	hook.onCommitFiberUnmount ??= noop;
+	hook.onPostCommitFiberRoot ??= noop;
+	hook.onScheduleFiberRoot ??= noop;
+	const originalInject = hook.inject;
+	let nextRendererId = Math.max(0, ...hook.renderers.keys());
+	hook.inject = (renderer) => {
+		const rendererId = originalInject?.call(hook, renderer) ?? ++nextRendererId;
+		hook.renderers?.set(rendererId, renderer);
+		markReactRendererInjected();
+		captureDispatcherRef(renderer);
+		return rendererId;
+	};
+	const originalOnCommitFiberRoot = hook.onCommitFiberRoot;
+	hook.onCommitFiberRoot = (rendererId, root, priorityLevel, didError) => {
+		recordReactCommitRoot(root);
+		originalOnCommitFiberRoot?.call(hook, rendererId, root, priorityLevel, didError);
+	};
+	return hook;
+}
+function captureDispatcherRef(renderer) {
+	const ref = renderer.currentDispatcherRef;
+	setReactCurrentDispatcherRef(ref);
+	const name = renderer.rendererPackageName;
+	recordReactRendererPackageName(name);
+}
+function registerReactMetadataEnricher(hook) {
+	if (hook[ENRICHER_REGISTERED] === true) return;
+	hook[ENRICHER_REGISTERED] = true;
+	markReactMetadataEnricherRegistered();
+}
+function getOrCreateHook() {
+	const existingHook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+	if (existingHook !== void 0) return existingHook;
+	const hook = {
+		supportsFiber: true,
+		hasUnsupportedRendererAttached: false,
+		renderers: /* @__PURE__ */ new Map(),
+		on: noop,
+		off: noop,
+		sub: () => noop,
+		onCommitFiberRoot: noop,
+		onScheduleFiberRoot: noop,
+		onCommitFiberUnmount: noop,
+		onPostCommitFiberRoot: noop,
+		checkDCE: noop
+	};
+	globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook;
+	return hook;
+}
+//#endregion
+export { installReactPreloadHook };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@anscribe/react",
+  "version": "0.1.0",
+  "description": "Anscribe React adapter: drop-in <Anscribe /> component and hooks for capture mode in React TUIs.",
+  "keywords": [
+    "agent",
+    "anscribe",
+    "capture",
+    "mcp",
+    "opentui",
+    "react",
+    "tui"
+  ],
+  "homepage": "https://github.com/msmps/anscribe",
+  "bugs": {
+    "url": "https://github.com/msmps/anscribe/issues"
+  },
+  "license": "MIT",
+  "author": "msmps",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/msmps/anscribe.git",
+    "directory": "packages/react"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./preload": {
+      "types": "./dist/preload.d.mts",
+      "import": "./dist/preload.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "effect": "^4.0.0-beta.65",
+    "@anscribe/core": "0.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=19.2.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run"
+  }
+}