@lensmcp/react-instrumentation 1.18.4 → 1.18.6

package/lib/flow-fetch.js

@@ -1,143 +1 @@
-/**
- * Flow-header propagation across the network boundary. When a request is
- * made while a flow is active (inside `runInFlow`/`withFlow`), inject
- * `x-lensmcp-flow-id` + `x-lensmcp-origin-node-id` headers so the backend
- * (`TraceInterceptor` in `@lensmcp/nest-instrumentation`) stamps its
- * server-request + span + db-query events with the SAME flowId. That is
- * what lets `story.compile` and `graph.*` correlate a single user action
- * all the way from the click to the DB query.
- *
- * Works in the browser and in Node (both have a global `fetch`). The
- * header is read at *call time* (synchronous), so a `fetch()` invoked
- * inside the synchronous portion of a flow is tagged even though the
- * awaited continuation runs after the flow stack unwinds.
- */
-import { activeFlow, beginBackgroundFlow, extendFlowWindow, publish } from './publish.js';
-/**
- * Monkeypatch `globalThis.fetch` to inject flow headers. Returns an
- * uninstall function that restores the original. No-op (returns a no-op
- * uninstaller) if there's no global fetch.
- */
-let pageLoadFlowStarted = false;
-export function installFlowFetch(options = {}) {
-    const g = globalThis;
-    if (typeof g.fetch !== 'function')
-        return () => undefined;
-    // installFlowFetch runs at ENTRY-MODULE eval (the babel transform injects
-    // it before the root render) — earlier than any mount effect. That makes
-    // it the one reliable place to declare the PAGE LOAD itself a flow, so the
-    // boot-time fetches (/me, list queries…) and the renders they trigger all
-    // stitch into one trace. A refresh without this produced NO flow at all.
-    if (!pageLoadFlowStarted && typeof location !== 'undefined' && typeof document !== 'undefined') {
-        pageLoadFlowStarted = true;
-        beginBackgroundFlow({ originType: 'page-load', originNodeId: `page:${location.pathname}` });
-    }
-    const flowHeader = options.flowHeader ?? 'x-lensmcp-flow-id';
-    const originHeader = options.originHeader ?? 'x-lensmcp-origin-node-id';
-    const original = g.fetch.bind(globalThis);
-    // Tell the injected client runtime's own (inner) fetch wrapper to stop
-    // emitting: from here on THIS wrapper publishes the network events, and
-    // both firing double-counts every request in the timeline.
-    globalThis['__LENSMCP_FLOW_FETCH__'] = true;
-    const patched = ((input, init) => {
-        // Sync stack (a wrapped handler) OR the causality window (page-load,
-        // post-response continuations) — both mean this fetch belongs to a flow.
-        const flow = activeFlow();
-        if (!flow?.flowId)
-            return original(input, init);
-        // Merge onto any caller-supplied headers (+ a Request's own headers).
-        const requestHeaders = typeof input === 'object' && input !== null && 'headers' in input
-            ? input.headers
-            : undefined;
-        const headers = new Headers(init?.headers ?? requestHeaders ?? undefined);
-        if (!headers.has(flowHeader))
-            headers.set(flowHeader, flow.flowId);
-        if (flow.originNodeId && !headers.has(originHeader)) {
-            headers.set(originHeader, flow.originNodeId);
-        }
-        const result = original(input, { ...init, headers });
-        publishFetchLeg(flow, input, init, result);
-        return result;
-    });
-    g.fetch = patched;
-    return () => {
-        g.fetch = original;
-    };
-}
-/**
- * Publish the flow's network leg: a start event (synchronous — stamped from
- * the flow stack) and a completion event (asynchronous — the flow has
- * unwound by then, so its context is attached explicitly). Together with
- * the backend's server-request event (same flowId via the header) this is
- * what lets a story read click → fetch → server → DB.
- */
-function publishFetchLeg(flow, input, init, result) {
-    const url = typeof input === 'string'
-        ? input
-        : input instanceof URL
-            ? input.href
-            : (input.url ?? String(input));
-    const method = init?.method ??
-        (typeof input === 'object' && input !== null && 'method' in input
-            ? (input.method ?? 'GET')
-            : 'GET');
-    const startedAt = Date.now();
-    const flowContext = {
-        flowId: flow.flowId,
-        ...(flow.originType ? { originType: flow.originType } : {}),
-        ...(flow.originNodeId ? { originNodeId: flow.originNodeId } : {}),
-    };
-    publish({
-        source: 'react',
-        category: 'network',
-        severity: 'info',
-        title: `fetch ${method} ${url}`,
-        fingerprint: `flow-fetch:${method}:${url}`,
-        raw: { kind: 'fetch-start', url, method },
-    });
-    // Observe on a branch — never alter the caller's promise chain.
-    void result.then((res) => {
-        // Re-open the causality window: the state update + re-render that
-        // consume this response land in the next ticks and belong to this flow.
-        extendFlowWindow(flow);
-        publish({
-            source: 'react',
-            category: 'network',
-            // A 4xx/5xx IS an error. This said `warning`, and the runtime reducer
-            // routes only `severity === 'error'` into
-            // `runtime://browser/failed-requests` — so every failed request in an
-            // app using flow-fetch was invisible to the lens. Measured on
-            // foodguard: 116 non-ok responses (98×401, 10×503, 8×502) captured in
-            // the event log, none of them reported.
-            severity: res.ok ? 'info' : 'error',
-            title: `fetch ${method} ${url} → ${res.status}${res.statusText ? ` ${res.statusText}` : ''}`,
-            // The STATUS is part of the identity. Without it a 200 and a 401 to
-            // the same endpoint shared one fingerprint, so five distinct failures
-            // deduped into whatever happened to be seen first.
-            fingerprint: `flow-fetch:${method}:${url}:${res.status}`,
-            context: flowContext,
-            raw: {
-                kind: 'fetch-done',
-                url,
-                method,
-                status: res.status,
-                statusText: res.statusText,
-                ok: res.ok,
-                startedAt,
-                durationMs: Date.now() - startedAt,
-            },
-        });
-    }, (err) => {
-        extendFlowWindow(flow);
-        publish({
-            source: 'react',
-            category: 'network',
-            severity: 'error',
-            title: `fetch ${method} ${url} failed`,
-            message: err instanceof Error ? err.message : String(err),
-            fingerprint: `flow-fetch:${method}:${url}:error`,
-            context: flowContext,
-            raw: { kind: 'fetch-error', url, method, startedAt, durationMs: Date.now() - startedAt },
-        });
-    });
-}
+"use strict";var $=Object.defineProperty;var l=(o,e)=>$(o,"name",{value:e,configurable:!0});var m=Object.defineProperty,f=l((o,e)=>m(o,"name",{value:e,configurable:!0}),"f");import{activeFlow as T,beginBackgroundFlow as b,extendFlowWindow as g,publish as h}from"./publish.js";let w=!1;export function installFlowFetch(o={}){const e=globalThis;if(typeof e.fetch!="function")return()=>{};!w&&typeof location<"u"&&typeof document<"u"&&(w=!0,b({originType:"page-load",originNodeId:`page:${location.pathname}`}));const c=o.flowHeader??"x-lensmcp-flow-id",d=o.originHeader??"x-lensmcp-origin-node-id",r=e.fetch.bind(globalThis);globalThis.__LENSMCP_FLOW_FETCH__=!0;const n=f(((i,s)=>{const t=T();if(!t?.flowId)return r(i,s);const y=typeof i=="object"&&i!==null&&"headers"in i?i.headers:void 0,a=new Headers(s?.headers??y??void 0);a.has(c)||a.set(c,t.flowId),t.originNodeId&&!a.has(d)&&a.set(d,t.originNodeId);const u=r(i,{...s,headers:a});return p(t,i,s,u),u}),"patched");return e.fetch=n,()=>{e.fetch=r}}l(installFlowFetch,"installFlowFetch"),f(installFlowFetch,"installFlowFetch");function p(o,e,c,d){const r=typeof e=="string"?e:e instanceof URL?e.href:e.url??String(e),n=c?.method??(typeof e=="object"&&e!==null&&"method"in e?e.method??"GET":"GET"),i=Date.now(),s={flowId:o.flowId,...o.originType?{originType:o.originType}:{},...o.originNodeId?{originNodeId:o.originNodeId}:{}};h({source:"react",category:"network",severity:"info",title:`fetch ${n} ${r}`,fingerprint:`flow-fetch:${n}:${r}`,raw:{kind:"fetch-start",url:r,method:n}}),d.then(t=>{g(o),h({source:"react",category:"network",severity:t.ok?"info":"error",title:`fetch ${n} ${r} \u2192 ${t.status}${t.statusText?` ${t.statusText}`:""}`,fingerprint:`flow-fetch:${n}:${r}:${t.status}`,context:s,raw:{kind:"fetch-done",url:r,method:n,status:t.status,statusText:t.statusText,ok:t.ok,startedAt:i,durationMs:Date.now()-i}})},t=>{g(o),h({source:"react",category:"network",severity:"error",title:`fetch ${n} ${r} failed`,message:t instanceof Error?t.message:String(t),fingerprint:`flow-fetch:${n}:${r}:error`,context:s,raw:{kind:"fetch-error",url:r,method:n,startedAt:i,durationMs:Date.now()-i}})})}l(p,"m"),f(p,"publishFetchLeg");

package/lib/hoc.js

@@ -1,45 +1 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Profiler, } from 'react';
-import { publish } from './publish.js';
-import { makeInstanceId } from './identity.js';
-/**
- * `withTraceComponent(MyComponent)` — opt-in tracer for projects that
- * can't enable the global Babel transform. Wraps the component in a
- * Profiler and emits a `render` event on every commit.
- */
-export function withTraceComponent(Wrapped, opts = {}) {
-    const name = opts.componentName ?? Wrapped.displayName ?? Wrapped.name ?? 'TracedComponent';
-    const file = opts.source ?? '(unknown)';
-    const logicalId = `react:component:${file}:${name}`;
-    function Traced(props) {
-        let lastRenderId;
-        const onRender = (_id, phase, actualDuration, baseDuration, startTime, commitTime) => {
-            const { instanceId } = makeInstanceId(logicalId);
-            const record = {
-                id: instanceId,
-                parentRenderId: lastRenderId,
-                componentInstanceId: instanceId,
-                componentLogicalId: logicalId,
-                componentName: name,
-                phase: phase === 'mount' ? 'mount' : 'update',
-                actualDurationMs: actualDuration,
-                baseDurationMs: baseDuration,
-                startTime,
-                commitTime,
-                why: [{ type: 'force', reason: 'withTraceComponent' }],
-            };
-            lastRenderId = instanceId;
-            publish({
-                source: 'react',
-                category: 'render',
-                severity: 'info',
-                title: `render ${name} (${phase})`,
-                fingerprint: `react-render:${logicalId}`,
-                raw: { kind: 'render', render: record },
-            });
-        };
-        return (_jsx(Profiler, { id: logicalId, onRender: onRender, children: _jsx(Wrapped, { ...props }) }));
-    }
-    Traced.displayName = `Traced(${name})`;
-    return Traced;
-}
+"use strict";var I=Object.defineProperty;var o=(e,n)=>I(e,"name",{value:n,configurable:!0});var T=Object.defineProperty,i=o((e,n)=>T(e,"name",{value:n,configurable:!0}),"t");import{jsx as d}from"react/jsx-runtime";import{Profiler as w}from"react";import{publish as $}from"./publish.js";import{makeInstanceId as g}from"./identity.js";export function withTraceComponent(e,n={}){const r=n.componentName??e.displayName??e.name??"TracedComponent",t=`react:component:${n.source??"(unknown)"}:${r}`;function a(p){let m;return d(w,{id:t,onRender:i((b,s,u,f,l,h)=>{const{instanceId:c}=g(t),y={id:c,parentRenderId:m,componentInstanceId:c,componentLogicalId:t,componentName:r,phase:s==="mount"?"mount":"update",actualDurationMs:u,baseDurationMs:f,startTime:l,commitTime:h,why:[{type:"force",reason:"withTraceComponent"}]};m=c,$({source:"react",category:"render",severity:"info",title:`render ${r} (${s})`,fingerprint:`react-render:${t}`,raw:{kind:"render",render:y}})},"onRender"),children:d(e,{...p})})}return o(a,"a"),i(a,"Traced"),a.displayName=`Traced(${r})`,a}o(withTraceComponent,"withTraceComponent"),i(withTraceComponent,"withTraceComponent");

package/lib/identity.js

@@ -1,74 +1 @@
-/**
- * Identity helpers — produce stable `logicalId` and per-mount
- * `instanceId` values for components, hooks, and slots. Mirrors the
- * shapes documented in `planning/02-data-model.md#logicalid`.
- */
-const generations = new Map();
-let entropy = 0;
-export function nextGeneration(logicalId) {
-    const g = (generations.get(logicalId) ?? 0) + 1;
-    generations.set(logicalId, g);
-    return g;
-}
-export function shortHash() {
-    entropy = (entropy + 1) % 0xffffffff;
-    return ((Date.now() & 0xfff) ^ entropy).toString(36).slice(-4);
-}
-export function componentLogicalId(file, name) {
-    return `react:component:${file}:${name}`;
-}
-export function hookLogicalId(file, componentName, hookName, index) {
-    return `react:hook:${file}:${componentName}:${hookName}:${index}`;
-}
-export function slotLogicalId(file, line, kind) {
-    return `react:slot:${file}:${line}:${kind}`;
-}
-export function makeInstanceId(logicalId) {
-    const generation = nextGeneration(logicalId);
-    return {
-        instanceId: `${logicalId}#${generation}#${shortHash()}`,
-        generation,
-    };
-}
-/**
- * Cheap deterministic hash over an array of dependency values. Used by
- * the traced hooks to compute `depsHash` so the reducer can decide
- * whether a hook re-ran because of a dep change.
- */
-export function depsHash(deps) {
-    if (!deps)
-        return 'no-deps';
-    let h = 5381;
-    for (const dep of deps) {
-        const repr = canonical(dep);
-        for (let i = 0; i < repr.length; i++) {
-            h = (h * 33) ^ repr.charCodeAt(i);
-        }
-    }
-    return (h >>> 0).toString(36);
-}
-function canonical(v) {
-    if (v === null)
-        return 'null';
-    if (v === undefined)
-        return 'undefined';
-    const t = typeof v;
-    if (t === 'string' || t === 'number' || t === 'boolean' || t === 'bigint') {
-        return `${t}:${String(v)}`;
-    }
-    if (t === 'function') {
-        const name = v.name ?? 'anonymous';
-        return `fn:${name}:${v.toString().length}`;
-    }
-    try {
-        return `obj:${JSON.stringify(v)}`;
-    }
-    catch {
-        return `obj:circular`;
-    }
-}
-/** Test hook to reset generation counters between smoke iterations. */
-export function resetIdentityState() {
-    generations.clear();
-    entropy = 0;
-}
+"use strict";var f=Object.defineProperty;var e=(t,n)=>f(t,"name",{value:n,configurable:!0});var l=Object.defineProperty,o=e((t,n)=>l(t,"name",{value:n,configurable:!0}),"e");const u=new Map;let c=0;export function nextGeneration(t){const n=(u.get(t)??0)+1;return u.set(t,n),n}e(nextGeneration,"nextGeneration"),o(nextGeneration,"nextGeneration");export function shortHash(){return c=(c+1)%4294967295,(Date.now()&4095^c).toString(36).slice(-4)}e(shortHash,"shortHash"),o(shortHash,"shortHash");export function componentLogicalId(t,n){return`react:component:${t}:${n}`}e(componentLogicalId,"componentLogicalId"),o(componentLogicalId,"componentLogicalId");export function hookLogicalId(t,n,r,i){return`react:hook:${t}:${n}:${r}:${i}`}e(hookLogicalId,"hookLogicalId"),o(hookLogicalId,"hookLogicalId");export function slotLogicalId(t,n,r){return`react:slot:${t}:${n}:${r}`}e(slotLogicalId,"slotLogicalId"),o(slotLogicalId,"slotLogicalId");export function makeInstanceId(t){const n=nextGeneration(t);return{instanceId:`${t}#${n}#${shortHash()}`,generation:n}}e(makeInstanceId,"makeInstanceId"),o(makeInstanceId,"makeInstanceId");export function depsHash(t){if(!t)return"no-deps";let n=5381;for(const r of t){const i=s(r);for(let a=0;a<i.length;a++)n=n*33^i.charCodeAt(a)}return(n>>>0).toString(36)}e(depsHash,"depsHash"),o(depsHash,"depsHash");function s(t){if(t===null)return"null";if(t===void 0)return"undefined";const n=typeof t;if(n==="string"||n==="number"||n==="boolean"||n==="bigint")return`${n}:${String(t)}`;if(n==="function")return`fn:${t.name??"anonymous"}:${t.toString().length}`;try{return`obj:${JSON.stringify(t)}`}catch{return"obj:circular"}}e(s,"a"),o(s,"canonical");export function resetIdentityState(){u.clear(),c=0}e(resetIdentityState,"resetIdentityState"),o(resetIdentityState,"resetIdentityState");

package/lib/lensmcp-root.js

@@ -1,59 +1 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Profiler, useMemo, useRef, } from 'react';
-import { LensmcpContext } from './context.js';
-import { publish } from './publish.js';
-import { makeInstanceId } from './identity.js';
-import { installFiberRenderPublisher } from './fiber-renders.js';
-// Per-component render attribution rides the client runtime's DevTools-hook
-// bus (see fiber-renders.ts). Module-scope so importing LensmcpRoot (the
-// babel autoWrapRoot path) is enough — no API change for consumers.
-if (typeof window !== 'undefined')
-    installFiberRenderPublisher();
-/**
- * Wraps the React tree in a `<Profiler>` and a context provider so the
- * hook helpers can tag their events with the right renderer / page /
- * route. Drop-in:
- *
- *   ReactDOM.createRoot(el).render(
- *     <LensmcpRoot page="home" route="/">
- *       <App />
- *     </LensmcpRoot>
- *   );
- */
-export function LensmcpRoot(props) {
-    const rendererId = props.rendererId ?? 'lensmcp-root';
-    const ctxValue = useMemo(() => ({ rendererId, page: props.page, route: props.route }), [rendererId, props.page, props.route]);
-    const renderIdsRef = useRef(new Map());
-    const lastRenderIdRef = useRef(undefined);
-    const onRender = (id, phase, actualDuration, baseDuration, startTime, commitTime) => {
-        const logicalId = `render:${rendererId}:${id}`;
-        const { instanceId } = makeInstanceId(logicalId);
-        const renderRecord = {
-            id: instanceId,
-            parentRenderId: lastRenderIdRef.current,
-            componentInstanceId: instanceId,
-            componentLogicalId: logicalId,
-            componentName: id,
-            page: props.page,
-            route: props.route,
-            rendererId,
-            phase: phase === 'mount' ? 'mount' : 'update',
-            actualDurationMs: actualDuration,
-            baseDurationMs: baseDuration,
-            startTime,
-            commitTime,
-            why: [{ type: 'force', reason: 'profiler-onrender' }],
-        };
-        lastRenderIdRef.current = instanceId;
-        renderIdsRef.current.set(id, instanceId);
-        publish({
-            source: 'react',
-            category: 'render',
-            severity: 'info',
-            title: `render ${id} (${phase})`,
-            fingerprint: `react-render:${logicalId}`,
-            raw: { kind: 'render', render: renderRecord },
-        });
-    };
-    return (_jsx(LensmcpContext.Provider, { value: ctxValue, children: _jsx(Profiler, { id: rendererId, onRender: onRender, children: props.children }) }));
-}
+"use strict";var v=Object.defineProperty;var a=(e,r)=>v(e,"name",{value:r,configurable:!0});var y=Object.defineProperty,d=a((e,r)=>y(e,"name",{value:r,configurable:!0}),"d");import{jsx as c}from"react/jsx-runtime";import{Profiler as R,useMemo as w,useRef as m}from"react";import{LensmcpContext as $}from"./context.js";import{publish as M}from"./publish.js";import{makeInstanceId as x}from"./identity.js";import{installFiberRenderPublisher as L}from"./fiber-renders.js";typeof window<"u"&&L();export function LensmcpRoot(e){const r=e.rendererId??"lensmcp-root",p=w(()=>({rendererId:r,page:e.page,route:e.route}),[r,e.page,e.route]),u=m(new Map),i=m(void 0),f=d((n,s,l,g,I,h)=>{const t=`render:${r}:${n}`,{instanceId:o}=x(t),b={id:o,parentRenderId:i.current,componentInstanceId:o,componentLogicalId:t,componentName:n,page:e.page,route:e.route,rendererId:r,phase:s==="mount"?"mount":"update",actualDurationMs:l,baseDurationMs:g,startTime:I,commitTime:h,why:[{type:"force",reason:"profiler-onrender"}]};i.current=o,u.current.set(n,o),M({source:"react",category:"render",severity:"info",title:`render ${n} (${s})`,fingerprint:`react-render:${t}`,raw:{kind:"render",render:b}})},"onRender");return c($.Provider,{value:p,children:c(R,{id:r,onRender:f,children:e.children})})}a(LensmcpRoot,"LensmcpRoot"),d(LensmcpRoot,"LensmcpRoot");

package/lib/publish.js

@@ -1,236 +1 @@
-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');
-/**
- * INPUT-CHANGE taming (the "an AI streamed text into an input → hundreds of flows" fix). Two rules,
- * applied ONLY to `originType: 'input-change'` (clicks/submits keep one-flow-per-invocation):
- *
- *  1. A PROGRAMMATIC change (the event arg is untrusted — `isTrusted === false`) is a CONSEQUENCE,
- *     never a user intent: it must not mint a flow. The handler runs as-is and its effects inherit the
- *     ambient flow (the click/submit that started the stream), which is the true causality; a live
- *     ambient window is extended so a long stream keeps attributing to its trigger.
- *  2. A TRUSTED burst on the SAME element (typing) COALESCES: invocations within a sliding window reuse
- *     the burst's flow and publish NO second origin — one editing burst = one flow, not one per keystroke.
- */
-const INPUT_COALESCE_MS = 2000;
-const inputBursts = new Map();
-/** The event's trust, wherever React put it (SyntheticEvent.nativeEvent or a raw DOM event). */
-function eventTrust(arg) {
-    if (arg == null || typeof arg !== 'object')
-        return undefined;
-    const ev = arg;
-    const nested = ev.nativeEvent;
-    if (nested != null && typeof nested === 'object') {
-        const trusted = nested.isTrusted;
-        if (typeof trusted === 'boolean')
-            return trusted;
-    }
-    if (typeof ev.isTrusted === 'boolean')
-        return ev.isTrusted;
-    return undefined;
-}
-function pruneInputBursts(now) {
-    if (inputBursts.size <= 64)
-        return;
-    for (const [key, burst] of inputBursts)
-        if (now >= burst.until)
-            inputBursts.delete(key);
-}
-/**
- * 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 publishOrigin = () => {
-        // 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 },
-        });
-    };
-    const flowed = function flowed(...args) {
-        if (spec.originType === 'input-change') {
-            // Rule 1 — a programmatic (untrusted) input change never mints a flow; it inherits the ambient
-            // one (the interaction that caused it). Keep a LIVE window alive so a long stream stays attributed.
-            if (eventTrust(args[0]) === false) {
-                if (currentFlow() == null && windowedFlow() != null)
-                    extendFlowWindow();
-                return handler(...args);
-            }
-            // Rule 2 — a trusted burst on the same element coalesces into ONE flow (sliding window).
-            const key = spec.originNodeId ?? 'input';
-            const now = Date.now();
-            const burst = inputBursts.get(key);
-            if (burst && now < burst.until) {
-                burst.until = now + INPUT_COALESCE_MS;
-                return runInFlow(burst.spec, () => handler(...args)); // same flow, no second origin event
-            }
-            const burstSpec = { flowId: newFlowId(), originType: 'input-change', originNodeId: spec.originNodeId };
-            inputBursts.set(key, { spec: burstSpec, until: now + INPUT_COALESCE_MS });
-            pruneInputBursts(now);
-            return runInFlow(burstSpec, () => {
-                publishOrigin();
-                return handler(...args);
-            });
-        }
-        const flowId = newFlowId();
-        return runInFlow({
-            flowId,
-            originType: spec.originType ?? 'user-click',
-            originNodeId: spec.originNodeId,
-        }, () => {
-            publishOrigin();
-            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);
-}
+"use strict";var F=Object.defineProperty;var i=(e,o)=>F(e,"name",{value:o,configurable:!0});var v=Object.defineProperty,n=i((e,o)=>v(e,"name",{value:o,configurable:!0}),"t");const u=[],B=200,g=[],S=4e3;let l;export function extendFlowWindow(e){const o=e??currentFlow()??l?.spec;o&&(l={spec:o,until:Date.now()+4e3})}i(extendFlowWindow,"extendFlowWindow"),n(extendFlowWindow,"extendFlowWindow");function p(){return l&&Date.now()<l.until?l.spec:void 0}i(p,"w"),n(p,"windowedFlow");export function activeFlow(){return currentFlow()??p()}i(activeFlow,"activeFlow"),n(activeFlow,"activeFlow");export function beginBackgroundFlow(e){const o={flowId:w(),originType:e.originType,...e.originNodeId?{originNodeId:e.originNodeId}:{}};return l={spec:o,until:Date.now()+4e3},publish({source:"react",category:"runtime",severity:"info",title:e.originType,fingerprint:`flow-origin:${e.originNodeId??e.originType}`,raw:{kind:"flow-origin",originNodeId:e.originNodeId}}),o}i(beginBackgroundFlow,"beginBackgroundFlow"),n(beginBackgroundFlow,"beginBackgroundFlow");export function setPublisher(e){if(globalThis.__LENSMCP_PUBLISH__=e,e)for(;u.length;){const o=u.shift();if(o)try{e(o)}catch{}}}i(setPublisher,"setPublisher"),n(setPublisher,"setPublisher");export function runInFlow(e,o){g.push(e),l={spec:e,until:Date.now()+4e3};try{return o()}finally{g.pop()}}i(runInFlow,"runInFlow"),n(runInFlow,"runInFlow");export function currentFlow(){return g[g.length-1]}i(currentFlow,"currentFlow"),n(currentFlow,"currentFlow");const N=Symbol.for("lensmcp.flowed"),h=2e3,c=new Map;function T(e){if(e==null||typeof e!="object")return;const o=e,t=o.nativeEvent;if(t!=null&&typeof t=="object"){const r=t.isTrusted;if(typeof r=="boolean")return r}if(typeof o.isTrusted=="boolean")return o.isTrusted}i(T,"S"),n(T,"eventTrust");function b(e){if(!(c.size<=64))for(const[o,t]of c)e>=t.until&&c.delete(o)}i(b,"F"),n(b,"pruneInputBursts");export function withFlow(e,o={}){if(typeof e!="function"||e[N])return e;const t=n(()=>{publish({source:"react",category:"runtime",severity:"info",title:o.originType??"user-click",fingerprint:`flow-origin:${o.originNodeId??"unknown"}`,raw:{kind:"flow-origin",originNodeId:o.originNodeId}})},"publishOrigin"),r=n(function(...d){if(o.originType==="input-change"){if(T(d[0])===!1)return currentFlow()==null&&p()!=null&&extendFlowWindow(),e(...d);const I=o.originNodeId??"input",s=Date.now(),f=c.get(I);if(f&&s<f.until)return f.until=s+h,runInFlow(f.spec,()=>e(...d));const y={flowId:w(),originType:"input-change",originNodeId:o.originNodeId};return c.set(I,{spec:y,until:s+h}),b(s),runInFlow(y,()=>(t(),e(...d)))}const x=w();return runInFlow({flowId:x,originType:o.originType??"user-click",originNodeId:o.originNodeId},()=>(t(),e(...d)))},"flowed");return r[N]=!0,r}i(withFlow,"withFlow"),n(withFlow,"withFlow");let a=0;function w(){return a=(a+1)%65535,`flow:${Date.now().toString(36)}:${a.toString(36)}`}i(w,"g"),n(w,"newFlowId");export function publish(e){const o=currentFlow()??(e.context?.flowId?void 0:p()),t=o==null?e:{...e,context:{...o.flowId?{flowId:o.flowId}:{},...o.originType?{originType:o.originType}:{},...o.originNodeId?{originNodeId:o.originNodeId}:{},...o.causedByNodeId?{causedByNodeId:o.causedByNodeId}:{},...e.context}},r=globalThis.__LENSMCP_PUBLISH__;if(r)try{r(t);return}catch{}u.length>=200&&u.shift(),u.push(t)}i(publish,"publish"),n(publish,"publish");export function drainQueue(){return u.splice(0,u.length)}i(drainQueue,"drainQueue"),n(drainQueue,"drainQueue");

package/lib/trace-slot.js

@@ -1,67 +1 @@
-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';
-}
+"use strict";var m=Object.defineProperty;var o=(e,n)=>m(e,"name",{value:n,configurable:!0});var p=Object.defineProperty,a=o((e,n)=>p(e,"name",{value:n,configurable:!0}),"c");import{jsx as d}from"react/jsx-runtime";import{Children as l,Fragment as y,useEffect as I,useRef as u}from"react";import{publish as g}from"./publish.js";import{makeInstanceId as b}from"./identity.js";import{useLensmcpContext as h}from"./context.js";export function TraceSlot(e){const n=h(),t=u(void 0),c=u(void 0);c.current||(c.current=b(`react:slot:${e.id}`).instanceId);const i=c.current,r=f(e.children);return I(()=>{if(t.current!==r){const s=t.current;t.current=r,g({source:"react",category:"render",severity:"info",title:`slot ${e.id}: ${s??"(none)"} \u2192 ${r}`,fingerprint:`slot-change:${e.id}`,raw:{kind:"slot-content-changed",slot:{slotLogicalId:`react:slot:${e.id}`,slotInstanceId:i,fromComponent:s,toComponent:r,componentInstanceId:n.componentInstanceId}}})}},[r,e.id,i,n.componentInstanceId]),d(y,{children:e.children})}o(TraceSlot,"TraceSlot"),a(TraceSlot,"TraceSlot");function f(e){const n=l.toArray(e)[0];if(!n)return"(empty)";if(typeof n=="string"||typeof n=="number")return"(text)";if(typeof n=="boolean")return"(boolean)";if(Array.isArray(n))return"(array)";if(typeof n=="object"&&n&&"type"in n){const t=n.type;return typeof t=="string"?t:typeof t=="function"?t.displayName??t.name??"AnonymousComponent":"unknown"}return"unknown"}o(f,"g"),a(f,"describeChild");