@lensmcp/react-instrumentation 1.0.0

package/lib/publish.js

@@ -0,0 +1,174 @@
+const QUEUE = [];
+const MAX_QUEUE = 200;
+const FLOW_STACK = [];
+/**
+ * Causality window: the synchronous flow stack misses everything Valtio and
+ * React deliver asynchronously — subscriber notifications, Profiler commits,
+ * and the whole post-response wave (state update + re-render after a fetch).
+ * An interaction OPENS a short attribution window; fetch completion EXTENDS
+ * it; any publish that has no explicit flow and no sync stack inherits the
+ * window's flow. Single-user dev semantics: the most recent interaction owns
+ * ambient activity for a few seconds — exactly how a person reads the app.
+ */
+const FLOW_WINDOW_MS = 4000;
+let windowFlow;
+export function extendFlowWindow(spec) {
+    const s = spec ?? currentFlow() ?? windowFlow?.spec;
+    if (s)
+        windowFlow = { spec: s, until: Date.now() + FLOW_WINDOW_MS };
+}
+function windowedFlow() {
+    return windowFlow && Date.now() < windowFlow.until ? windowFlow.spec : undefined;
+}
+/** The flow that owns work happening NOW: sync stack first, else the window. */
+export function activeFlow() {
+    return currentFlow() ?? windowedFlow();
+}
+/**
+ * Start a flow with no synchronous handler to wrap — page loads, timers,
+ * websocket pushes. Opens the causality window (so the async work that
+ * follows inherits the flow) and publishes the origin event that makes the
+ * flow exist in the reducer.
+ */
+export function beginBackgroundFlow(origin) {
+    const spec = {
+        flowId: newFlowId(),
+        originType: origin.originType,
+        ...(origin.originNodeId ? { originNodeId: origin.originNodeId } : {}),
+    };
+    windowFlow = { spec, until: Date.now() + FLOW_WINDOW_MS };
+    publish({
+        source: 'react',
+        category: 'runtime',
+        severity: 'info',
+        title: origin.originType,
+        fingerprint: `flow-origin:${origin.originNodeId ?? origin.originType}`,
+        raw: { kind: 'flow-origin', originNodeId: origin.originNodeId },
+    });
+    return spec;
+}
+export function setPublisher(fn) {
+    globalThis.__LENSMCP_PUBLISH__ = fn;
+    if (fn) {
+        while (QUEUE.length) {
+            const ev = QUEUE.shift();
+            if (ev) {
+                try {
+                    fn(ev);
+                }
+                catch {
+                    /* swallow */
+                }
+            }
+        }
+    }
+}
+/**
+ * Push a flow onto the module-level stack for the duration of `fn`. Any
+ * `publish()` calls inside `fn` (including transitively triggered
+ * Valtio subscribers and React Profiler callbacks that fire synchronously)
+ * will inherit the flow context.
+ *
+ * NB: only synchronous propagation. For async chains (`fetch().then`,
+ * `setTimeout`, promises) the caller must re-enter the flow with
+ * `runInFlow` at the continuation site. The Phase 6.5 carryover adds
+ * automatic continuation tracking via an async-context shim.
+ */
+export function runInFlow(spec, fn) {
+    FLOW_STACK.push(spec);
+    windowFlow = { spec, until: Date.now() + FLOW_WINDOW_MS }; // interaction opens the causality window
+    try {
+        return fn();
+    }
+    finally {
+        FLOW_STACK.pop();
+    }
+}
+export function currentFlow() {
+    return FLOW_STACK[FLOW_STACK.length - 1];
+}
+/** Marks a handler as already flow-wrapped so layered wrapping is a no-op. */
+const FLOWED = Symbol.for('lensmcp.flowed');
+/**
+ * Wrap a React event handler so every call runs inside a fresh flow.
+ * The flowId is generated per invocation; `originType` defaults to
+ * `'user-click'`. Pass `originNodeId` from the component identity
+ * (typically the `data-agent-component` value).
+ *
+ * The babel transform wraps `on*` JSX values blindly, so this must be
+ * total: non-function values (e.g. `onClick={maybeUndefined}`) pass
+ * through unchanged, and an already-flowed handler is returned as-is —
+ * layered components forwarding the same prop would otherwise nest a
+ * flow per layer and crash on the inner non-function (`handler is not
+ * a function`).
+ */
+export function withFlow(handler, spec = {}) {
+    if (typeof handler !== 'function')
+        return handler;
+    const existing = handler;
+    if (existing[FLOWED])
+        return handler;
+    const flowed = function flowed(...args) {
+        const flowId = newFlowId();
+        return runInFlow({
+            flowId,
+            originType: spec.originType ?? 'user-click',
+            originNodeId: spec.originNodeId,
+        }, () => {
+            // The origin event — published inside the flow so it carries the
+            // flowId. It guarantees the flow materialises in the reducer (which
+            // keys on the first event with a flowId) even when every downstream
+            // effect lands asynchronously, outside the synchronous flow window.
+            publish({
+                source: 'react',
+                category: 'runtime',
+                severity: 'info',
+                title: spec.originType ?? 'user-click',
+                fingerprint: `flow-origin:${spec.originNodeId ?? 'unknown'}`,
+                raw: { kind: 'flow-origin', originNodeId: spec.originNodeId },
+            });
+            return handler(...args);
+        });
+    };
+    flowed[FLOWED] = true;
+    return flowed;
+}
+let flowSeq = 0;
+function newFlowId() {
+    flowSeq = (flowSeq + 1) % 0xffff;
+    return `flow:${Date.now().toString(36)}:${flowSeq.toString(36)}`;
+}
+export function publish(env) {
+    // Sync stack first; otherwise the causality window — unless the caller
+    // already carries its own flow (e.g. fetch-done with closure context).
+    const flow = currentFlow() ?? (env.context?.flowId ? undefined : windowedFlow());
+    const stamped = flow == null
+        ? env
+        : {
+            ...env,
+            context: {
+                ...(flow.flowId ? { flowId: flow.flowId } : {}),
+                ...(flow.originType ? { originType: flow.originType } : {}),
+                ...(flow.originNodeId ? { originNodeId: flow.originNodeId } : {}),
+                ...(flow.causedByNodeId ? { causedByNodeId: flow.causedByNodeId } : {}),
+                ...env.context,
+            },
+        };
+    const fn = globalThis.__LENSMCP_PUBLISH__;
+    if (fn) {
+        try {
+            fn(stamped);
+            return;
+        }
+        catch {
+            /* fall through to queue */
+        }
+    }
+    if (QUEUE.length >= MAX_QUEUE)
+        QUEUE.shift();
+    QUEUE.push(stamped);
+}
+/** Test hook — only useful in unit tests / smokes. */
+export function drainQueue() {
+    return QUEUE.splice(0, QUEUE.length);
+}

package/lib/trace-slot.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+export interface TraceSlotProps {
+    id: string;
+    children: ReactNode;
+}
+/**
+ * Slot tracker. Emits `slot-content-changed` when the type of the
+ * primary child changes. The Babel transform (T5.1) wraps JSX
+ * conditionals with `<TraceSlot id="file:line:conditional">{...}</TraceSlot>`.
+ */
+export declare function TraceSlot(props: TraceSlotProps): ReactNode;
+//# sourceMappingURL=trace-slot.d.ts.map

package/lib/trace-slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-slot.d.ts","sourceRoot":"","sources":["../../src/lib/trace-slot.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,SAAS,EAAqB,MAAM,OAAO,CAAC;AAK9E,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,CAsC1D"}

package/lib/trace-slot.js

@@ -0,0 +1,67 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Children, Fragment, useEffect, useRef } from 'react';
+import { publish } from './publish.js';
+import { makeInstanceId } from './identity.js';
+import { useLensmcpContext } from './context.js';
+/**
+ * Slot tracker. Emits `slot-content-changed` when the type of the
+ * primary child changes. The Babel transform (T5.1) wraps JSX
+ * conditionals with `<TraceSlot id="file:line:conditional">{...}</TraceSlot>`.
+ */
+export function TraceSlot(props) {
+    const ctx = useLensmcpContext();
+    const lastTypeRef = useRef(undefined);
+    const slotInstanceRef = useRef(undefined);
+    if (!slotInstanceRef.current) {
+        slotInstanceRef.current = makeInstanceId(`react:slot:${props.id}`).instanceId;
+    }
+    const slotInstanceId = slotInstanceRef.current;
+    const currentType = describeChild(props.children);
+    useEffect(() => {
+        if (lastTypeRef.current !== currentType) {
+            const fromComponent = lastTypeRef.current;
+            lastTypeRef.current = currentType;
+            publish({
+                source: 'react',
+                category: 'render',
+                severity: 'info',
+                title: `slot ${props.id}: ${fromComponent ?? '(none)'} → ${currentType}`,
+                fingerprint: `slot-change:${props.id}`,
+                raw: {
+                    kind: 'slot-content-changed',
+                    slot: {
+                        slotLogicalId: `react:slot:${props.id}`,
+                        slotInstanceId,
+                        fromComponent,
+                        toComponent: currentType,
+                        componentInstanceId: ctx.componentInstanceId,
+                    },
+                },
+            });
+        }
+    }, [currentType, props.id, slotInstanceId, ctx.componentInstanceId]);
+    // Stable wrapper so React doesn't think the children's parent changed
+    // when the slot remounts — we want layout to feel transparent.
+    return _jsx(Fragment, { children: props.children });
+}
+function describeChild(children) {
+    const arr = Children.toArray(children);
+    const first = arr[0];
+    if (!first)
+        return '(empty)';
+    if (typeof first === 'string' || typeof first === 'number')
+        return '(text)';
+    if (typeof first === 'boolean')
+        return '(boolean)';
+    if (Array.isArray(first))
+        return '(array)';
+    if (typeof first === 'object' && first && 'type' in first) {
+        const t = first.type;
+        if (typeof t === 'string')
+            return t;
+        if (typeof t === 'function')
+            return t.displayName ?? t.name ?? 'AnonymousComponent';
+        return 'unknown';
+    }
+    return 'unknown';
+}

package/lib/traced-hooks.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Drop-in replacement for `useEffect` that emits an `effect-run` event
+ * on every run + a separate event on cleanup. The transform (T5.1)
+ * rewrites bare `useEffect(fn, deps)` calls to
+ * `tracedUseEffect("<file>:<line>:<index>", fn, deps)`.
+ */
+export declare function tracedUseEffect(hookLogicalId: string, effect: () => void | (() => void), deps: readonly unknown[] | undefined): void;
+/** Same idea for `useMemo` — emits a `hook-run` event with `recomputed`. */
+export declare function tracedUseMemo<T>(hookLogicalId: string, compute: () => T, deps: readonly unknown[] | undefined): T;
+/** Drop-in `useCallback` with the same accounting as `tracedUseMemo`. */
+export declare function tracedUseCallback<T extends (...args: never[]) => unknown>(hookLogicalId: string, cb: T, deps: readonly unknown[] | undefined): T;
+//# sourceMappingURL=traced-hooks.d.ts.map

package/lib/traced-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traced-hooks.d.ts","sourceRoot":"","sources":["../../src/lib/traced-hooks.ts"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,EACjC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,GACnC,IAAI,CA6DN;AAED,4EAA4E;AAC5E,wBAAgB,aAAa,CAAC,CAAC,EAC7B,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,CAAC,EAChB,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,GACnC,CAAC,CA8BH;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EACvE,aAAa,EAAE,MAAM,EACrB,EAAE,EAAE,CAAC,EACL,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,GACnC,CAAC,CA8BH"}

package/lib/traced-hooks.js

@@ -0,0 +1,143 @@
+import { useCallback as reactUseCallback, useEffect as reactUseEffect, useMemo as reactUseMemo, useRef, } from 'react';
+import { useLensmcpContext } from './context.js';
+import { depsHash } from './identity.js';
+import { publish } from './publish.js';
+/**
+ * Drop-in replacement for `useEffect` that emits an `effect-run` event
+ * on every run + a separate event on cleanup. The transform (T5.1)
+ * rewrites bare `useEffect(fn, deps)` calls to
+ * `tracedUseEffect("<file>:<line>:<index>", fn, deps)`.
+ */
+export function tracedUseEffect(hookLogicalId, effect, deps) {
+    const ctx = useLensmcpContext();
+    const hookInstanceId = useStableHookInstance(hookLogicalId);
+    const prevHashRef = useRef(undefined);
+    reactUseEffect(() => {
+        const startedAt = typeof performance !== 'undefined' && performance.now
+            ? performance.now()
+            : Date.now();
+        const hash = depsHash(deps);
+        const prevHash = prevHashRef.current;
+        prevHashRef.current = hash;
+        let cleanup;
+        try {
+            cleanup = effect();
+        }
+        finally {
+            const endedAt = typeof performance !== 'undefined' && performance.now
+                ? performance.now()
+                : Date.now();
+            publish({
+                source: 'react',
+                category: 'render',
+                severity: 'info',
+                title: `effect-run ${hookLogicalId}`,
+                fingerprint: `effect-run:${hookLogicalId}`,
+                raw: {
+                    kind: 'effect-run',
+                    effect: {
+                        hookInstanceId,
+                        hookLogicalId,
+                        componentInstanceId: ctx.componentInstanceId,
+                        depsHash: hash,
+                        prevDepsHash: prevHash,
+                        durationMs: Math.max(0, endedAt - startedAt),
+                    },
+                },
+            });
+        }
+        return () => {
+            if (typeof cleanup === 'function')
+                cleanup();
+            publish({
+                source: 'react',
+                category: 'render',
+                severity: 'info',
+                title: `effect-cleanup ${hookLogicalId}`,
+                fingerprint: `effect-cleanup:${hookLogicalId}`,
+                raw: {
+                    kind: 'effect-run',
+                    effect: {
+                        hookInstanceId,
+                        hookLogicalId,
+                        componentInstanceId: ctx.componentInstanceId,
+                        depsHash: prevHashRef.current ?? hash,
+                        durationMs: 0,
+                        cleanupRan: true,
+                    },
+                },
+            });
+        };
+    }, deps);
+}
+/** Same idea for `useMemo` — emits a `hook-run` event with `recomputed`. */
+export function tracedUseMemo(hookLogicalId, compute, deps) {
+    const ctx = useLensmcpContext();
+    const hookInstanceId = useStableHookInstance(hookLogicalId);
+    const prevHashRef = useRef(undefined);
+    const hash = depsHash(deps);
+    const recomputed = hash !== prevHashRef.current;
+    const value = reactUseMemo(compute, deps ?? []);
+    if (recomputed) {
+        publish({
+            source: 'react',
+            category: 'render',
+            severity: 'debug',
+            title: `useMemo recomputed ${hookLogicalId}`,
+            fingerprint: `hook-run:${hookLogicalId}`,
+            raw: {
+                kind: 'hook-run',
+                hook: {
+                    hookInstanceId,
+                    hookLogicalId,
+                    componentInstanceId: ctx.componentInstanceId,
+                    hookType: 'useMemo',
+                    depsHash: hash,
+                    prevDepsHash: prevHashRef.current,
+                    recomputed: true,
+                },
+            },
+        });
+    }
+    prevHashRef.current = hash;
+    return value;
+}
+/** Drop-in `useCallback` with the same accounting as `tracedUseMemo`. */
+export function tracedUseCallback(hookLogicalId, cb, deps) {
+    const ctx = useLensmcpContext();
+    const hookInstanceId = useStableHookInstance(hookLogicalId);
+    const prevHashRef = useRef(undefined);
+    const hash = depsHash(deps);
+    const recomputed = hash !== prevHashRef.current;
+    const memoised = reactUseCallback(cb, deps ?? []);
+    if (recomputed) {
+        publish({
+            source: 'react',
+            category: 'render',
+            severity: 'debug',
+            title: `useCallback recomputed ${hookLogicalId}`,
+            fingerprint: `hook-run:${hookLogicalId}`,
+            raw: {
+                kind: 'hook-run',
+                hook: {
+                    hookInstanceId,
+                    hookLogicalId,
+                    componentInstanceId: ctx.componentInstanceId,
+                    hookType: 'useCallback',
+                    depsHash: hash,
+                    prevDepsHash: prevHashRef.current,
+                    recomputed: true,
+                },
+            },
+        });
+    }
+    prevHashRef.current = hash;
+    return memoised;
+}
+function useStableHookInstance(hookLogicalId) {
+    const ref = useRef(undefined);
+    if (!ref.current) {
+        ref.current = `${hookLogicalId}#${(Math.random() * 1e9) | 0}`;
+    }
+    return ref.current;
+}

package/lib/types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Wire-shape types for the events `@lensmcp/react-instrumentation`
+ * publishes. These mirror the schemas in `@lensmcp/protocol-types`
+ * (`RenderAttrs`, `EffectRunAttrs`) but include the identity fields the
+ * apps/react reducer needs to attribute renders to specific component
+ * instances.
+ */
+import type { RenderPhase, RenderWhy } from '@lensmcp/protocol-types';
+export type { RenderPhase, RenderWhy };
+export interface RenderRecord {
+    id: string;
+    parentRenderId?: string;
+    componentInstanceId: string;
+    componentLogicalId: string;
+    componentName: string;
+    page?: string;
+    route?: string;
+    rendererId?: string;
+    phase: RenderPhase;
+    actualDurationMs: number;
+    baseDurationMs: number;
+    startTime: number;
+    commitTime: number;
+    why: RenderWhy[];
+}
+export interface EffectRecord {
+    hookInstanceId: string;
+    hookLogicalId: string;
+    componentInstanceId?: string;
+    depsHash: string;
+    prevDepsHash?: string;
+    durationMs: number;
+    cleanupRan?: boolean;
+    source?: string;
+}
+export interface HookRecord {
+    hookInstanceId: string;
+    hookLogicalId: string;
+    componentInstanceId?: string;
+    hookType: 'useMemo' | 'useCallback';
+    depsHash: string;
+    prevDepsHash?: string;
+    recomputed: boolean;
+    source?: string;
+}
+export interface SlotChangeRecord {
+    slotLogicalId: string;
+    slotInstanceId: string;
+    fromComponent?: string;
+    toComponent?: string;
+    componentInstanceId?: string;
+    source?: string;
+}
+export interface ComponentMountRecord {
+    logicalId: string;
+    instanceId: string;
+    generation: number;
+    name: string;
+    source?: string;
+    page?: string;
+    route?: string;
+}
+/** Anything the lib publishes downstream of the client-runtime. */
+export type ReactPublishPayload = {
+    kind: 'render';
+    render: RenderRecord;
+} | {
+    kind: 'effect-run';
+    effect: EffectRecord;
+} | {
+    kind: 'hook-run';
+    hook: HookRecord;
+} | {
+    kind: 'slot-content-changed';
+    slot: SlotChangeRecord;
+} | {
+    kind: 'component-mount';
+    component: ComponentMountRecord;
+} | {
+    kind: 'component-unmount';
+    component: ComponentMountRecord;
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEtE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC;AAEvC,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,WAAW,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,SAAS,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,EAAE,SAAS,GAAG,aAAa,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,mEAAmE;AACnE,MAAM,MAAM,mBAAmB,GAC3B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,IAAI,EAAE,gBAAgB,CAAA;CAAE,GACxD;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,SAAS,EAAE,oBAAoB,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,mBAAmB,CAAC;IAAC,SAAS,EAAE,oBAAoB,CAAA;CAAE,CAAC"}

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@lensmcp/react-instrumentation",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./babel-plugin": {
+      "types": "./lib/babel-plugin.d.ts",
+      "import": "./lib/babel-plugin.js",
+      "default": "./lib/babel-plugin.js"
+    }
+  },
+  "dependencies": {
+    "@lensmcp/protocol-types": "1.0.0",
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@babel/core": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/babel__core": "^7.0.0",
+    "@types/react": "^19.0.0"
+  },
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/kiwiapps-ltd/lensmcp#readme",
+  "bugs": {
+    "url": "https://github.com/kiwiapps-ltd/lensmcp/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Zero-config React instrumentation for LensMCP (Babel transform + flow/render runtime).",
+  "keywords": [
+    "lensmcp",
+    "mcp",
+    "observability",
+    "ai-agents",
+    "claude",
+    "react",
+    "babel"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kiwiapps-ltd/lensmcp.git",
+    "directory": "libs/react-instrumentation"
+  }
+}