@flotrace/runtime-core 2.0.1 → 2.2.1

package/dist/index.mjs

@@ -1551,8 +1551,8 @@ function runAnalysis(tree, fiberRefMap2) {
 }
 function schedulePropDrillingAnalysis(tree, fiberRefMap2, client2) {
   if (analyzeTimer) clearTimeout(analyzeTimer);
-  const now = Date.now();
-  const elapsed = now - lastAnalysisTime;
+  const now2 = Date.now();
+  const elapsed = now2 - lastAnalysisTime;
   const delay = elapsed >= ANALYZE_INTERVAL_MS ? 0 : ANALYZE_INTERVAL_MS - elapsed;
   analyzeTimer = setTimeout(() => {
     analyzeTimer = null;
@@ -2579,7 +2579,7 @@ function executeSnapshot(root) {
     }
     previousFlatTree = currentFlatTree;
     if (pendingLocalStateCorrelations.length > 0) {
-      const now = Date.now();
+      const now2 = Date.now();
       const toSend = pendingLocalStateCorrelations.splice(0);
       for (const corr of toSend) {
         try {
@@ -2588,7 +2588,7 @@ function executeSnapshot(root) {
             requestId: corr.requestId,
             componentName: corr.componentName,
             hookIndex: corr.hookIndex,
-            timestamp: now
+            timestamp: now2
           });
         } catch {
         }
@@ -3033,6 +3033,7 @@ var activeUnsubscribers = [];
 var isInstalled4 = false;
 var debounceTimers = /* @__PURE__ */ new Map();
 var DEBOUNCE_MS = 200;
+var trackedStores = /* @__PURE__ */ new Map();
 function installZustandTracker(stores, client2) {
   if (isInstalled4) {
     console.warn("[FloTrace] Zustand tracker already installed, reinstalling");
@@ -3048,6 +3049,7 @@ function installZustandTracker(stores, client2) {
       continue;
     }
     try {
+      trackedStores.set(storeName, store);
       const initialState = store.getState();
       sendStoreUpdate(storeName, initialState, Object.keys(initialState), client2);
       const unsubscribe = store.subscribe((newState, prevState) => {
@@ -3077,9 +3079,20 @@ function uninstallZustandTracker() {
     }
   }
   activeUnsubscribers = [];
+  trackedStores.clear();
   isInstalled4 = false;
   console.log("[FloTrace] Zustand tracker uninstalled");
 }
+function getZustandSnapshot() {
+  const snapshot = /* @__PURE__ */ new Map();
+  for (const [name, store] of trackedStores) {
+    try {
+      snapshot.set(name, store.getState());
+    } catch {
+    }
+  }
+  return snapshot;
+}
 function scheduleStoreUpdate(storeName, prevState, newState, client2) {
   let changedKeys;
   try {
@@ -3118,6 +3131,7 @@ var isInstalled5 = false;
 var debounceTimer = null;
 var previousState = null;
 var DEBOUNCE_MS2 = 200;
+var trackedStore = null;
 function isReduxStore(obj) {
   return typeof obj === "object" && obj !== null && typeof obj.getState === "function" && typeof obj.subscribe === "function" && typeof obj.dispatch === "function";
 }
@@ -3129,6 +3143,7 @@ function installReduxTracker(store, client2) {
   isInstalled5 = true;
   console.log("[FloTrace] Installing Redux tracker");
   try {
+    trackedStore = store;
     const initialState = store.getState();
     previousState = initialState;
     sendReduxUpdate(initialState, Object.keys(initialState), client2);
@@ -3160,9 +3175,18 @@ function uninstallReduxTracker() {
     activeUnsubscribe = null;
   }
   previousState = null;
+  trackedStore = null;
   isInstalled5 = false;
   console.log("[FloTrace] Redux tracker uninstalled");
 }
+function getReduxSnapshot() {
+  if (!trackedStore) return null;
+  try {
+    return trackedStore.getState();
+  } catch {
+    return null;
+  }
+}
 function scheduleReduxUpdate(newState, client2) {
   let changedKeys;
   try {
@@ -3200,6 +3224,7 @@ var queryUnsubscribe = null;
 var mutationUnsubscribe = null;
 var debounceTimer2 = null;
 var DEBOUNCE_MS3 = 300;
+var trackedClient = null;
 var MAX_EVENTS_PER_QUERY = 50;
 var queryTracking = /* @__PURE__ */ new Map();
 var CORRELATION_WINDOW_MS = 500;
@@ -3222,6 +3247,7 @@ function installTanStackQueryTracker(queryClient, client2) {
   isInstalled6 = true;
   console.log("[FloTrace] Installing TanStack Query tracker");
   try {
+    trackedClient = queryClient;
     const queryCache = queryClient.getQueryCache();
     const mutationCache = queryClient.getMutationCache();
     for (const query of queryCache.getAll()) {
@@ -3286,9 +3312,24 @@ function uninstallTanStackQueryTracker() {
     clearTimeout(pending.timeoutId);
   }
   pendingCorrelations.clear();
+  trackedClient = null;
   isInstalled6 = false;
   console.log("[FloTrace] TanStack Query tracker uninstalled");
 }
+function getTanstackSnapshot() {
+  const snapshot = /* @__PURE__ */ new Map();
+  if (!trackedClient) return snapshot;
+  try {
+    const queryCache = trackedClient.getQueryCache();
+    for (const query of queryCache.getAll()) {
+      if (query.state.data !== void 0) {
+        snapshot.set(query.queryHash, { queryKey: query.queryKey, data: query.state.data });
+      }
+    }
+  } catch {
+  }
+  return snapshot;
+}
 function computeDataHash(data) {
   if (data === null || data === void 0) return "__null__";
   try {
@@ -3351,11 +3392,11 @@ function updateQueryTracking(query, eventType) {
       }
     }
     if (tracking.prevFetchStatus === "idle" && currentFetchStatus === "fetching") {
-      const now = Date.now();
+      const now2 = Date.now();
       for (const pending of pendingCorrelations.values()) {
         if (pending.idleQueryHashes.has(query.queryHash)) {
           pending.affectedQueries.set(query.queryHash, {
-            fetchStartedAt: now,
+            fetchStartedAt: now2,
             queryKey: query.queryKey
           });
         }
@@ -3367,7 +3408,7 @@ function updateQueryTracking(query, eventType) {
 }
 function openCorrelationWindow(mutation, queryCache, mutationCache, client2) {
   const correlationId = `corr-${++correlationCounter}`;
-  const now = Date.now();
+  const now2 = Date.now();
   const idleQueryHashes = /* @__PURE__ */ new Set();
   for (const query of queryCache.getAll()) {
     if (query.state.fetchStatus === "idle") {
@@ -3381,7 +3422,7 @@ function openCorrelationWindow(mutation, queryCache, mutationCache, client2) {
     correlationId,
     mutationId: mutation.mutationId,
     mutationKey: mutation.options.mutationKey,
-    completedAt: now,
+    completedAt: now2,
     idleQueryHashes,
     affectedQueries: /* @__PURE__ */ new Map(),
     timeoutId
@@ -3581,6 +3622,319 @@ function safeCall(fn, fallback) {
   }
 }
 
+// src/valueTraceResolver.ts
+var FIBER_TAG_CONTEXT_PROVIDER = 10;
+var BUDGET_MS = 50;
+var SCAN_DEPTH = 3;
+var MAX_PROP_CHAIN_DEPTH = 30;
+function now() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function walkPath(root, path) {
+  let cur = root;
+  for (const key of path) {
+    if (cur === null || cur === void 0 || typeof cur !== "object") return void 0;
+    cur = cur[key];
+  }
+  return cur;
+}
+function getHookValueAt(fiber, hookIndex) {
+  let hook = fiber.memoizedState;
+  let i = 0;
+  while (hook && i < hookIndex) {
+    hook = hook.next;
+    i++;
+  }
+  if (!hook) return void 0;
+  return hook.memoizedState;
+}
+function valuesMatch(target, targetFp, candidate) {
+  const targetIsObject = target !== null && typeof target === "object";
+  const candidateIsObject = candidate !== null && typeof candidate === "object";
+  if (targetIsObject && candidateIsObject && target === candidate) return "exact";
+  if (!shouldFlagRename(target) || !shouldFlagRename(candidate)) return null;
+  if (valueFingerprint(candidate) === targetFp) return "fingerprint-match";
+  return null;
+}
+function findMatchingPathInObject(target, targetFp, container, currentPath, depth, deadline) {
+  if (now() > deadline) return null;
+  if (depth > SCAN_DEPTH) return null;
+  if (container === null || typeof container !== "object") return null;
+  const selfMatch = valuesMatch(target, targetFp, container);
+  if (selfMatch) return { path: [...currentPath], confidence: selfMatch };
+  if (Array.isArray(container)) {
+    for (let i = 0; i < Math.min(container.length, 50); i++) {
+      const child = container[i];
+      const directMatch = valuesMatch(target, targetFp, child);
+      if (directMatch) return { path: [...currentPath, String(i)], confidence: directMatch };
+      const nested = findMatchingPathInObject(target, targetFp, child, [...currentPath, String(i)], depth + 1, deadline);
+      if (nested) return nested;
+    }
+  } else {
+    for (const key of Object.keys(container)) {
+      const child = container[key];
+      const directMatch = valuesMatch(target, targetFp, child);
+      if (directMatch) return { path: [...currentPath, key], confidence: directMatch };
+      const nested = findMatchingPathInObject(target, targetFp, child, [...currentPath, key], depth + 1, deadline);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+function buildFiberToNodeIdMap() {
+  const reverse = /* @__PURE__ */ new Map();
+  for (const [nodeId, fiber] of getFiberRefMap()) {
+    reverse.set(fiber, nodeId);
+  }
+  return reverse;
+}
+function resolveValueTrace(input) {
+  const startedAt = now();
+  const deadline = startedAt + BUDGET_MS;
+  const steps = [];
+  const base = {
+    rootNodeId: input.nodeId,
+    rootPropPath: input.propPath,
+    rootHookPath: input.hookPath,
+    steps,
+    resolvedAtMs: now()
+  };
+  const fiber = getFiberRefMap().get(input.nodeId);
+  if (!fiber) {
+    return { ...base, error: "no-fiber", resolvedAtMs: now() };
+  }
+  let rootValue;
+  if (input.propPath && input.propPath.length > 0) {
+    if (!fiber.memoizedProps) return { ...base, error: "value-not-found", resolvedAtMs: now() };
+    rootValue = walkPath(fiber.memoizedProps, input.propPath);
+  } else if (input.hookPath) {
+    const hookValue = getHookValueAt(fiber, input.hookPath.hookIndex);
+    rootValue = input.hookPath.subPath && input.hookPath.subPath.length > 0 ? walkPath(hookValue, input.hookPath.subPath) : hookValue;
+  } else {
+    return { ...base, error: "value-not-found", resolvedAtMs: now() };
+  }
+  if (rootValue === void 0) {
+    return { ...base, error: "value-not-found", resolvedAtMs: now() };
+  }
+  const rootFp = valueFingerprint(rootValue);
+  const fiberToNodeId = buildFiberToNodeIdMap();
+  const rootComponentName = getComponentNameFromFiber(fiber) ?? "Unknown";
+  if (input.propPath) {
+    steps.push({
+      kind: "prop",
+      nodeId: input.nodeId,
+      componentName: rootComponentName,
+      propPath: input.propPath,
+      confidence: "exact"
+    });
+  } else if (input.hookPath) {
+    steps.push({
+      kind: "hook-state",
+      nodeId: input.nodeId,
+      componentName: rootComponentName,
+      hookIndex: input.hookPath.hookIndex,
+      hookType: "unknown",
+      // Cheap: full hook classification is expensive; caller can fetch separately.
+      subPath: input.hookPath.subPath,
+      confidence: "exact"
+    });
+  }
+  if (input.propPath) {
+    let current = fiber.return;
+    let hops = 0;
+    while (current && hops < MAX_PROP_CHAIN_DEPTH) {
+      if (now() > deadline) return { ...base, steps, truncated: true, resolvedAtMs: now() };
+      if (current.tag !== FIBER_TAG_CONTEXT_PROVIDER) {
+        const props = current.memoizedProps;
+        if (props) {
+          const match = findMatchingPathInObject(rootValue, rootFp, props, [], 0, deadline);
+          if (match) {
+            const ancestorNodeId = fiberToNodeId.get(current);
+            const ancestorName = getComponentNameFromFiber(current) ?? "Unknown";
+            if (ancestorNodeId) {
+              steps.push({
+                kind: "prop",
+                nodeId: ancestorNodeId,
+                componentName: ancestorName,
+                propPath: match.path,
+                confidence: match.confidence
+              });
+            }
+          }
+        }
+      }
+      current = current.return;
+      hops++;
+    }
+  }
+  if (input.hookPath) {
+    const origin = findFetchOrigin(rootValue);
+    if (origin) {
+      steps.push({
+        kind: "api",
+        requestId: origin,
+        method: "UNKNOWN",
+        urlPath: "",
+        ageMs: 0
+      });
+      return { ...base, steps, resolvedAtMs: now() };
+    }
+  }
+  const derivedMatch = findDerivationMatch(fiber, rootValue, rootFp, rootComponentName);
+  if (derivedMatch) {
+    steps.push({ ...derivedMatch, nodeId: input.nodeId });
+    return { ...base, steps, resolvedAtMs: now() };
+  }
+  const contextMatch = findContextMatch(fiber, rootValue, rootFp, fiberToNodeId);
+  if (contextMatch) {
+    steps.push(contextMatch.step);
+    const providerStoreMatch = findStoreMatch(contextMatch.providerValue, valueFingerprint(contextMatch.providerValue), deadline);
+    if (providerStoreMatch) {
+      steps.push({
+        kind: "store",
+        source: providerStoreMatch.source,
+        storeName: providerStoreMatch.storeName,
+        keyPath: providerStoreMatch.keyPath,
+        confidence: providerStoreMatch.confidence
+      });
+      const origin = findFetchOrigin(providerStoreMatch.matchedValue);
+      if (origin) {
+        steps.push({ kind: "api", requestId: origin, method: "UNKNOWN", urlPath: "", ageMs: 0 });
+      }
+    } else {
+      const origin = findFetchOrigin(contextMatch.providerValue);
+      if (origin) {
+        steps.push({ kind: "api", requestId: origin, method: "UNKNOWN", urlPath: "", ageMs: 0 });
+      }
+    }
+    return { ...base, steps, resolvedAtMs: now() };
+  }
+  const storeMatch = findStoreMatch(rootValue, rootFp, deadline);
+  if (storeMatch) {
+    steps.push({
+      kind: "store",
+      source: storeMatch.source,
+      storeName: storeMatch.storeName,
+      keyPath: storeMatch.keyPath,
+      confidence: storeMatch.confidence
+    });
+    const origin = findFetchOrigin(storeMatch.matchedValue);
+    if (origin) {
+      steps.push({
+        kind: "api",
+        requestId: origin,
+        method: "UNKNOWN",
+        urlPath: "",
+        ageMs: 0
+      });
+    }
+  }
+  return { ...base, steps, resolvedAtMs: now() };
+}
+function findContextMatch(consumer, target, targetFp, fiberToNodeId) {
+  const deps = consumer.dependencies?.firstContext;
+  if (!deps) return null;
+  let dep = deps;
+  while (dep) {
+    const match = valuesMatch(target, targetFp, dep.memoizedValue);
+    if (match) {
+      const provider = findNearestProvider(consumer, dep.context);
+      const step = {
+        kind: "context",
+        contextName: dep.context.displayName || "Context",
+        providerNodeId: provider ? fiberToNodeId.get(provider) : void 0,
+        confidence: match
+      };
+      const providerValue = provider?.memoizedProps?.value ?? dep.memoizedValue;
+      return { step, providerValue };
+    }
+    dep = dep.next;
+  }
+  return null;
+}
+function findDerivationMatch(fiber, target, targetFp, componentName) {
+  let hook = fiber.memoizedState;
+  let index = 0;
+  while (hook) {
+    const ms = hook.memoizedState;
+    if (Array.isArray(ms) && ms.length === 2 && Array.isArray(ms[1])) {
+      const [computed, deps] = ms;
+      const match = valuesMatch(target, targetFp, computed);
+      if (match) {
+        const hookType = typeof computed === "function" ? "useCallback" : "useMemo";
+        return {
+          kind: "derived",
+          nodeId: "",
+          componentName,
+          hookIndex: index,
+          hookType,
+          depCount: deps.length,
+          confidence: match
+        };
+      }
+    }
+    hook = hook.next;
+    index++;
+  }
+  return null;
+}
+function findNearestProvider(consumer, contextObj) {
+  let current = consumer.return;
+  let hops = 0;
+  while (current && hops < MAX_PROP_CHAIN_DEPTH) {
+    if (current.tag === FIBER_TAG_CONTEXT_PROVIDER) {
+      const providerType = current.type;
+      if (providerType && providerType._context === contextObj) return current;
+    }
+    current = current.return;
+    hops++;
+  }
+  return null;
+}
+function findStoreMatch(target, targetFp, deadline) {
+  for (const [storeName, state] of getZustandSnapshot()) {
+    if (now() > deadline) return null;
+    const hit = findMatchingPathInObject(target, targetFp, state, [], 0, deadline);
+    if (hit) {
+      return {
+        source: "zustand",
+        storeName,
+        keyPath: hit.path,
+        confidence: hit.confidence,
+        matchedValue: walkPath(state, hit.path)
+      };
+    }
+  }
+  const redux = getReduxSnapshot();
+  if (redux) {
+    if (now() > deadline) return null;
+    const hit = findMatchingPathInObject(target, targetFp, redux, [], 0, deadline);
+    if (hit) {
+      return {
+        source: "redux",
+        storeName: "redux",
+        keyPath: hit.path,
+        confidence: hit.confidence,
+        matchedValue: walkPath(redux, hit.path)
+      };
+    }
+  }
+  for (const [queryHash, entry] of getTanstackSnapshot()) {
+    if (now() > deadline) return null;
+    const hit = findMatchingPathInObject(target, targetFp, entry.data, [], 0, deadline);
+    if (hit) {
+      return {
+        source: "tanstack-query",
+        storeName: queryHash,
+        keyPath: hit.path,
+        confidence: hit.confidence,
+        matchedValue: walkPath(entry.data, hit.path)
+      };
+    }
+  }
+  return null;
+}
+
 // src/frameworkDetect.ts
 function detectWebFramework() {
   if (typeof document === "undefined") return {};
@@ -3615,8 +3969,11 @@ export {
   getNodeEffects,
   getNodeHooks,
   getNodeProps,
+  getReduxSnapshot,
+  getTanstackSnapshot,
   getTimeline,
   getWebSocketClient,
+  getZustandSnapshot,
   hasActiveTags,
   inspectEffects,
   inspectHooks,
@@ -3633,6 +3990,7 @@ export {
   requestFullSnapshot,
   requestTreeSnapshot,
   resetNextjsDetection,
+  resolveValueTrace,
   serializeProps,
   serializeValue,
   tagFetchData,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flotrace/runtime-core",
-  "version": "2.0.1",
+  "version": "2.2.1",
   "description": "Platform-agnostic core for FloTrace runtime — fiber walker, analyzers, trackers. Shared by @flotrace/runtime (web) and @flotrace/runtime-native (React Native).",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",