@lensmcp/react-instrumentation 1.0.0

package/lib/context.d.ts

@@ -0,0 +1,15 @@
+export interface LensmcpIdentityContext {
+    rendererId: string;
+    page?: string;
+    route?: string;
+    /** Optional override — when set, hook helpers tag their events with
+     *  this component instance instead of falling back to a synthetic id. */
+    componentInstanceId?: string;
+    /** Stable component logicalId (file + name), if known. */
+    componentLogicalId?: string;
+    /** Optional parent render id (set by LensmcpRoot's Profiler onRender). */
+    lastRenderId?: string;
+}
+export declare const LensmcpContext: import("react").Context<LensmcpIdentityContext>;
+export declare function useLensmcpContext(): LensmcpIdentityContext;
+//# sourceMappingURL=context.d.ts.map

package/lib/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/lib/context.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;6EACyE;IACzE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,0DAA0D;IAC1D,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAID,eAAO,MAAM,cAAc,iDAAoD,CAAC;AAEhF,wBAAgB,iBAAiB,IAAI,sBAAsB,CAE1D"}

package/lib/context.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from 'react';
+const defaultCtx = { rendererId: 'lensmcp-root' };
+export const LensmcpContext = createContext(defaultCtx);
+export function useLensmcpContext() {
+    return useContext(LensmcpContext);
+}

package/lib/flow-fetch.d.ts

@@ -0,0 +1,8 @@
+export interface FlowFetchOptions {
+    /** Header carrying the flow id. Default `x-lensmcp-flow-id`. */
+    flowHeader?: string;
+    /** Header carrying the origin node id. Default `x-lensmcp-origin-node-id`. */
+    originHeader?: string;
+}
+export declare function installFlowFetch(options?: FlowFetchOptions): () => void;
+//# sourceMappingURL=flow-fetch.d.ts.map

package/lib/flow-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-fetch.d.ts","sourceRoot":"","sources":["../../src/lib/flow-fetch.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,gBAAgB;IAC/B,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAWD,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,gBAAqB,GAAG,MAAM,IAAI,CA2C3E"}

package/lib/flow-fetch.js

@@ -0,0 +1,121 @@
+/**
+ * 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);
+    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',
+            severity: res.ok ? 'info' : 'warning',
+            title: `fetch ${method} ${url} → ${res.status}`,
+            fingerprint: `flow-fetch:${method}:${url}`,
+            context: flowContext,
+            raw: { kind: 'fetch-done', url, method, status: res.status, 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}`,
+            context: flowContext,
+            raw: { kind: 'fetch-error', url, method, startedAt, durationMs: Date.now() - startedAt },
+        });
+    });
+}

package/lib/hoc.d.ts

@@ -0,0 +1,13 @@
+import { type ComponentType } from 'react';
+export interface WithTraceOptions {
+    componentName?: string;
+    /** Source file path — set this for projects that can't enable the JSX transform. */
+    source?: string;
+}
+/**
+ * `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 declare function withTraceComponent<P extends object>(Wrapped: ComponentType<P>, opts?: WithTraceOptions): ComponentType<P>;
+//# sourceMappingURL=hoc.d.ts.map

package/lib/hoc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hoc.d.ts","sourceRoot":"","sources":["../../src/lib/hoc.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EAGnB,MAAM,OAAO,CAAC;AAKf,MAAM,WAAW,gBAAgB;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,EACjD,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,EACzB,IAAI,GAAE,gBAAqB,GAC1B,aAAa,CAAC,CAAC,CAAC,CA+ClB"}

package/lib/hoc.js

@@ -0,0 +1,45 @@
+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;
+}

package/lib/identity.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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`.
+ */
+export declare function nextGeneration(logicalId: string): number;
+export declare function shortHash(): string;
+export declare function componentLogicalId(file: string, name: string): string;
+export declare function hookLogicalId(file: string, componentName: string, hookName: string, index: number): string;
+export declare function slotLogicalId(file: string, line: number, kind: string): string;
+export declare function makeInstanceId(logicalId: string): {
+    instanceId: string;
+    generation: number;
+};
+/**
+ * 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 declare function depsHash(deps: readonly unknown[] | undefined): string;
+/** Test hook to reset generation counters between smoke iterations. */
+export declare function resetIdentityState(): void;
+//# sourceMappingURL=identity.d.ts.map

package/lib/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../src/lib/identity.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAIxD;AAED,wBAAgB,SAAS,IAAI,MAAM,CAGlC;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,MAAM,CAER;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAMA;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,GAAG,MAAM,CAUrE;AAoBD,uEAAuE;AACvE,wBAAgB,kBAAkB,IAAI,IAAI,CAGzC"}

package/lib/identity.js

@@ -0,0 +1,74 @@
+/**
+ * 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;
+}

package/lib/lensmcp-root.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from 'react';
+export interface LensmcpRootProps {
+    /** Stable id for this renderer (defaults to "lensmcp-root"). */
+    rendererId?: string;
+    /** Logical page/route label. The reducer uses this to group renders. */
+    page?: string;
+    route?: string;
+    children: ReactNode;
+}
+/**
+ * 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 declare function LensmcpRoot(props: LensmcpRootProps): ReactNode;
+//# sourceMappingURL=lensmcp-root.d.ts.map

package/lib/lensmcp-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lensmcp-root.d.ts","sourceRoot":"","sources":["../../src/lib/lensmcp-root.tsx"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EAGf,MAAM,OAAO,CAAC;AAMf,MAAM,WAAW,gBAAgB;IAC/B,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG,SAAS,CAuD9D"}

package/lib/lensmcp-root.js

@@ -0,0 +1,53 @@
+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';
+/**
+ * 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 }) }));
+}

package/lib/publish.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Single publish channel + module-level "current flow" stack. The
+ * `@lensmcp/client-runtime` injected into the served HTML sets
+ * `window.__LENSMCP_PUBLISH__` to a function that takes a partial event
+ * and forwards it to the LensMCP bus (via WebSocket in dev, or via the
+ * FrontMCP server transport in production).
+ *
+ * If the channel isn't installed we silently no-op — this keeps the
+ * library safe to import from any React tree (tests, SSR, etc).
+ */
+import type { ReactPublishPayload } from './types.js';
+export type PublishCategory = 'render' | 'state' | 'runtime' | 'network' | 'visual' | 'trace';
+export interface FlowSpec {
+    flowId: string;
+    originType?: string;
+    originNodeId?: string;
+    causedByNodeId?: string;
+}
+export interface PublishEnvelope {
+    source: 'react' | 'valtio' | 'client-runtime' | 'visual';
+    category: PublishCategory;
+    severity?: 'debug' | 'info' | 'warning' | 'error';
+    title: string;
+    message?: string;
+    fingerprint?: string;
+    /** Optional context overrides; auto-stamped flow context is merged underneath. */
+    context?: Partial<{
+        flowId: string;
+        originType: string;
+        originNodeId: string;
+        causedByNodeId: string;
+        route: string;
+        url: string;
+    }>;
+    raw: ReactPublishPayload | Record<string, unknown>;
+}
+type PublishFn = (event: PublishEnvelope) => void;
+declare global {
+    var __LENSMCP_PUBLISH__: PublishFn | undefined;
+}
+export declare function extendFlowWindow(spec?: FlowSpec): void;
+/** The flow that owns work happening NOW: sync stack first, else the window. */
+export declare function activeFlow(): FlowSpec | undefined;
+/**
+ * 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 declare function beginBackgroundFlow(origin: {
+    originType: string;
+    originNodeId?: string;
+}): FlowSpec;
+export declare function setPublisher(fn: PublishFn | undefined): void;
+/**
+ * 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 declare function runInFlow<T>(spec: FlowSpec, fn: () => T): T;
+export declare function currentFlow(): FlowSpec | undefined;
+/**
+ * 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 declare function withFlow<TArgs extends unknown[], TResult>(handler: (...args: TArgs) => TResult, spec?: {
+    originType?: string;
+    originNodeId?: string;
+}): (...args: TArgs) => TResult;
+export declare function publish(env: PublishEnvelope): void;
+/** Test hook — only useful in unit tests / smokes. */
+export declare function drainQueue(): PublishEnvelope[];
+export {};
+//# sourceMappingURL=publish.d.ts.map

package/lib/publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../src/lib/publish.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,MAAM,MAAM,eAAe,GACvB,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GACT,QAAQ,GACR,OAAO,CAAC;AAEZ,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,gBAAgB,GAAG,QAAQ,CAAC;IACzD,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kFAAkF;IAClF,OAAO,CAAC,EAAE,OAAO,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;QACrB,cAAc,EAAE,MAAM,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;KACb,CAAC,CAAC;IACH,GAAG,EAAE,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpD;AAED,KAAK,SAAS,GAAG,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;AAElD,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,mBAAmB,EAAE,SAAS,GAAG,SAAS,CAAC;CAChD;AAmBD,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,CAGtD;AAMD,gFAAgF;AAChF,wBAAgB,UAAU,IAAI,QAAQ,GAAG,SAAS,CAEjD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,QAAQ,CAgBnG;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI,CAc5D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQ3D;AAED,wBAAgB,WAAW,IAAI,QAAQ,GAAG,SAAS,CAElD;AAKD;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACvD,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,EACpC,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GACxD,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAgC7B;AAQD,wBAAgB,OAAO,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI,CA6BlD;AAED,sDAAsD;AACtD,wBAAgB,UAAU,IAAI,eAAe,EAAE,CAE9C"}