nuxt-devtools-observatory 0.1.7 → 0.1.9

package/dist/module.mjs

@@ -1,12 +1,10 @@
-import { defineNuxtModule, createResolver, addVitePlugin, addPlugin } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addVitePlugin, addPlugin, addServerPlugin } from '@nuxt/kit';
 import { parse } from '@babel/parser';
 import _traverse from '@babel/traverse';
 import _generate from '@babel/generator';
 import * as t from '@babel/types';
 
-const traverse$2 = _traverse.default ?? _traverse;
-const generate$2 = _generate.default ?? _generate;
-function extractScriptBlock$2(code) {
+function extractScriptBlock(code) {
   const openTagRE = /<script(\s[^>]*)?>/i;
   const openMatch = openTagRE.exec(code);
   if (!openMatch) {
@@ -19,7 +17,13 @@ function extractScriptBlock$2(code) {
   }
   return { content: code.slice(start, end), start, end };
 }
+
+const traverse$2 = _traverse.default ?? _traverse;
+const generate$2 = _generate.default ?? _generate;
 const FETCH_FNS = /* @__PURE__ */ new Set(["useFetch", "useAsyncData", "useLazyFetch", "useLazyAsyncData"]);
+function isHandlerExpression(node) {
+  return Boolean(node && (t.isIdentifier(node) || t.isArrowFunctionExpression(node) || t.isFunctionExpression(node)));
+}
 function fetchInstrumentPlugin() {
   return {
     name: "vite-plugin-observatory-fetch",
@@ -29,13 +33,13 @@ function fetchInstrumentPlugin() {
       if (!isVue && !id.endsWith(".ts") && !id.endsWith(".js")) {
         return;
       }
-      if (id.includes("node_modules")) {
+      if (id.includes("node_modules") || id.includes("composable-registry") || id.includes("provide-inject-registry") || id.includes("fetch-registry")) {
         return;
       }
       let scriptCode = code;
       let scriptStart = 0;
       if (isVue) {
-        const block = extractScriptBlock$2(code);
+        const block = extractScriptBlock(code);
         if (!block) {
           return null;
         }
@@ -51,7 +55,10 @@ function fetchInstrumentPlugin() {
           plugins: ["typescript"]
         });
         let modified = false;
-        const hasImport = scriptCode.includes("__devFetch");
+        let needsFetchCallHelper = false;
+        let needsFetchHandlerHelper = false;
+        const hasFetchCallImport = scriptCode.includes("__devFetchCall");
+        const hasFetchHandlerImport = scriptCode.includes("__devFetchHandler");
         traverse$2(ast, {
           CallExpression(path) {
             if (path.node.__observatoryTransformed) {
@@ -64,7 +71,7 @@ function fetchInstrumentPlugin() {
             if (!FETCH_FNS.has(callee.name)) {
               return;
             }
-            if (path.parent && t.isCallExpression(path.parent) && t.isIdentifier(path.parent.callee) && path.parent.callee.name === "__devFetch") {
+            if (path.parent && t.isCallExpression(path.parent) && t.isIdentifier(path.parent.callee) && ["__devFetchCall", "__devFetchHandler"].includes(path.parent.callee.name)) {
               return;
             }
             const originalName = callee.name;
@@ -76,22 +83,35 @@ function fetchInstrumentPlugin() {
               return t.isExpression(node) ? node : void 0;
             }
             if (originalName === "useAsyncData" || originalName === "useLazyAsyncData") {
-              if (args.length === 1 && getExpr(args[0])) {
+              if (args.length === 1 && isHandlerExpression(getExpr(args[0]))) {
                 handlerArg = getExpr(args[0]);
-              } else if (args.length >= 2 && getExpr(args[0]) && getExpr(args[1])) {
+              } else if (args.length >= 2 && getExpr(args[0]) && isHandlerExpression(getExpr(args[1]))) {
                 keyArg = getExpr(args[0]);
                 handlerArg = getExpr(args[1]);
                 optsArg = getExpr(args[2]) ?? t.objectExpression([]);
               } else {
-                return;
+                keyArg = getExpr(args[0]) ?? t.stringLiteral("");
+                optsArg = getExpr(args[1]) ?? t.objectExpression([]);
+                handlerArg = void 0;
               }
             } else {
               keyArg = getExpr(args[0]) ?? t.stringLiteral("");
               optsArg = getExpr(args[1]) ?? t.objectExpression([]);
             }
             let key = originalName;
-            if (keyArg && t.isStringLiteral(keyArg)) {
-              key = keyArg.value.replace(/[^a-z0-9]/gi, "-").replace(/^-+|-+$/g, "");
+            if (originalName === "useFetch" || originalName === "useLazyFetch") {
+              if (optsArg && t.isObjectExpression(optsArg)) {
+                const keyProp = optsArg.properties.find(
+                  (property) => t.isObjectProperty(property) && t.isIdentifier(property.key) && property.key.name === "key" && t.isStringLiteral(property.value)
+                );
+                if (keyProp && t.isStringLiteral(keyProp.value)) {
+                  key = keyProp.value.value;
+                } else if (keyArg && t.isStringLiteral(keyArg)) {
+                  key = keyArg.value.replace(/[^a-z0-9]/gi, "-").replace(/^-+|-+$/g, "");
+                }
+              } else if (keyArg && t.isStringLiteral(keyArg)) {
+                key = keyArg.value.replace(/[^a-z0-9]/gi, "-").replace(/^-+|-+$/g, "");
+              }
             }
             const loc = path.node.loc;
             const meta = t.objectExpression([
@@ -100,9 +120,9 @@ function fetchInstrumentPlugin() {
               t.objectProperty(t.identifier("line"), t.numericLiteral(loc?.start.line ?? 0)),
               t.objectProperty(t.identifier("originalFn"), t.stringLiteral(originalName))
             ]);
-            if (originalName === "useAsyncData" || originalName === "useLazyAsyncData") {
+            if ((originalName === "useAsyncData" || originalName === "useLazyAsyncData") && handlerArg) {
               if (handlerArg) {
-                const wrappedHandlerFn = t.arrowFunctionExpression(
+                const wrappedHandler = t.arrowFunctionExpression(
                   [t.restElement(t.identifier("args"))],
                   t.conditionalExpression(
                     t.logicalExpression(
@@ -111,41 +131,38 @@ function fetchInstrumentPlugin() {
                       t.memberExpression(t.identifier("process"), t.identifier("client"))
                     ),
                     t.callExpression(
-                      t.callExpression(
-                        t.identifier("__devFetch"),
-                        [handlerArg, keyArg ?? t.stringLiteral(key), meta]
-                      ),
+                      t.callExpression(t.identifier("__devFetchHandler"), [handlerArg, keyArg ?? t.stringLiteral(key), meta]),
                       [t.spreadElement(t.identifier("args"))]
                     ),
-                    t.callExpression(
-                      handlerArg,
-                      [t.spreadElement(t.identifier("args"))]
-                    )
+                    t.callExpression(handlerArg, [t.spreadElement(t.identifier("args"))])
                   )
                 );
-                wrappedHandlerFn.__observatoryTransformed = true;
-                let newCall;
+                wrappedHandler.__observatoryTransformed = true;
+                needsFetchHandlerHelper = true;
                 if (keyArg) {
-                  newCall = t.callExpression(t.identifier(originalName), [
+                  const newCall = t.callExpression(t.identifier(originalName), [
                     keyArg,
-                    wrappedHandlerFn,
+                    wrappedHandler,
                     optsArg ?? t.objectExpression([])
                   ]);
+                  newCall.__observatoryTransformed = true;
+                  path.replaceWith(newCall);
                 } else {
-                  newCall = t.callExpression(t.identifier(originalName), [wrappedHandlerFn]);
+                  const newCall = t.callExpression(t.identifier(originalName), [wrappedHandler]);
+                  newCall.__observatoryTransformed = true;
+                  path.replaceWith(newCall);
                 }
-                newCall.__observatoryTransformed = true;
-                path.replaceWith(newCall);
                 modified = true;
               }
             } else {
-              const newCall = t.callExpression(t.identifier("__devFetch"), [
+              const newCall = t.callExpression(t.identifier("__devFetchCall"), [
                 t.identifier(originalName),
                 keyArg ?? t.stringLiteral(""),
                 optsArg ?? t.objectExpression([]),
                 meta
               ]);
               newCall.__observatoryTransformed = true;
+              needsFetchCallHelper = true;
               path.replaceWith(newCall);
               modified = true;
             }
@@ -154,8 +171,12 @@ function fetchInstrumentPlugin() {
         if (!modified) {
           return null;
         }
-        const importStatement = hasImport ? "" : `import { __devFetch } from 'nuxt-devtools-observatory/runtime/fetch-registry';
-`;
+        const importNames = [
+          needsFetchCallHelper && !hasFetchCallImport ? "__devFetchCall" : "",
+          needsFetchHandlerHelper && !hasFetchHandlerImport ? "__devFetchHandler" : ""
+        ].filter(Boolean);
+        const importStatement = importNames.length ? `import { ${importNames.join(", ")} } from 'nuxt-devtools-observatory/runtime/fetch-registry';
+` : "";
         const output = generate$2(ast, { retainLines: true }, scriptCode);
         let finalCode;
         if (isVue) {
@@ -177,26 +198,13 @@ function fetchInstrumentPlugin() {
 
 const traverse$1 = _traverse.default ?? _traverse;
 const generate$1 = _generate.default ?? _generate;
-function extractScriptBlock$1(code) {
-  const openTagRE = /<script(\s[^>]*)?>/i;
-  const openMatch = openTagRE.exec(code);
-  if (!openMatch) {
-    return null;
-  }
-  const start = openMatch.index + openMatch[0].length;
-  const end = code.indexOf("<\/script>", start);
-  if (end === -1) {
-    return null;
-  }
-  return { content: code.slice(start, end), start, end };
-}
 function provideInjectPlugin() {
   return {
     name: "vite-plugin-observatory-provide-inject",
     enforce: "pre",
     transform(code, id) {
       const isVue = id.endsWith(".vue");
-      if (!isVue && !id.endsWith(".ts")) {
+      if (!isVue && !id.endsWith(".ts") && !id.endsWith(".js")) {
         return;
       }
       if (id.includes("node_modules") || id.includes("composable-registry") || id.includes("provide-inject-registry") || id.includes("fetch-registry")) {
@@ -205,7 +213,7 @@ function provideInjectPlugin() {
       let scriptCode = code;
       let scriptStart = 0;
       if (isVue) {
-        const block = extractScriptBlock$1(code);
+        const block = extractScriptBlock(code);
         if (!block) {
           return null;
         }
@@ -272,19 +280,6 @@ function provideInjectPlugin() {
 
 const traverse = _traverse.default ?? _traverse;
 const generate = _generate.default ?? _generate;
-function extractScriptBlock(code) {
-  const openTagRE = /<script(\s[^>]*)?>/i;
-  const openMatch = openTagRE.exec(code);
-  if (!openMatch) {
-    return null;
-  }
-  const start = openMatch.index + openMatch[0].length;
-  const end = code.indexOf("<\/script>", start);
-  if (end === -1) {
-    return null;
-  }
-  return { content: code.slice(start, end), start, end };
-}
 const COMPOSABLE_RE = /\buse[A-Z]/;
 const SKIP_LIST = /* @__PURE__ */ new Set([
   "useFetch",
@@ -309,7 +304,7 @@ function composableTrackerPlugin() {
     enforce: "pre",
     transform(code, id) {
       const isVue = id.endsWith(".vue");
-      if (!isVue && !id.endsWith(".ts")) {
+      if (!isVue && !id.endsWith(".ts") && !id.endsWith(".js")) {
         return;
       }
       if (id.includes("node_modules") || id.includes("composable-registry") || id.includes("provide-inject-registry") || id.includes("fetch-registry")) {
@@ -551,12 +546,10 @@ const module$1 = defineNuxtModule({
     }
     addPlugin(resolver.resolve("./runtime/plugin"));
     if (options.fetchDashboard) {
-      nuxt.hook("nitro:config", (nitroConfig) => {
-        nitroConfig.plugins = nitroConfig.plugins || [];
-        nitroConfig.plugins.push(resolver.resolve("./nitro/fetch-capture"));
-      });
+      addServerPlugin(resolver.resolve("./runtime/nitro/fetch-capture"));
     }
     const CLIENT_PORT = 4949;
+    const clientOrigin = `http://localhost:${CLIENT_PORT}`;
     nuxt.hook("vite:serverCreated", async (_viteServer, env) => {
       if (!env.isClient) {
         return;
@@ -566,7 +559,7 @@ const module$1 = defineNuxtModule({
       const inner = await createServer({
         root: resolver.resolve("../client"),
         base: "/",
-        server: { port: CLIENT_PORT, strictPort: false, cors: true },
+        server: { port: CLIENT_PORT, strictPort: true, cors: true },
         appType: "spa",
         configFile: false,
         plugins: [vue()],
@@ -575,7 +568,7 @@ const module$1 = defineNuxtModule({
       await inner.listen();
       nuxt.hook("close", () => inner.close());
     });
-    const base = `http://localhost:${CLIENT_PORT}`;
+    const base = clientOrigin;
     nuxt.hook("devtools:customTabs", (tabs) => {
       if (options.fetchDashboard) {
         tabs.push({
@@ -619,7 +612,8 @@ const module$1 = defineNuxtModule({
       }
     });
     nuxt.options.runtimeConfig.public.observatory = {
-      heatmapThreshold: options.heatmapThreshold ?? 5
+      heatmapThreshold: options.heatmapThreshold ?? 5,
+      clientOrigin
     };
   }
 });

package/dist/runtime/composables/composable-registry.js

@@ -95,10 +95,16 @@ export function __trackComposable(name, callFn, meta) {
     }
     originalClearInterval(id2);
   });
-  const trackedWatchers = [];
+  const effectsBefore = new Set(instance?.scope?.effects ?? []);
+  const mountedHooksBefore = instance?.bm?.length ?? 0;
+  const unmountedHooksBefore = instance?.um?.length ?? 0;
   const result = callFn();
   window.setInterval = originalSetInterval;
   window.clearInterval = originalClearInterval;
+  const trackedWatchers = (instance?.scope?.effects ?? []).filter((effect) => !effectsBefore.has(effect)).map((effect) => ({
+    effect,
+    stop: () => effect.stop?.()
+  }));
   const refs = {};
   if (result && typeof result === "object") {
     for (const [key, val] of Object.entries(result)) {
@@ -121,8 +127,8 @@ export function __trackComposable(name, callFn, meta) {
     watcherCount: trackedWatchers.length,
     intervalCount: trackedIntervals.length,
     lifecycle: {
-      hasOnMounted: false,
-      hasOnUnmounted: false,
+      hasOnMounted: (instance?.bm?.length ?? 0) > mountedHooksBefore,
+      hasOnUnmounted: (instance?.um?.length ?? 0) > unmountedHooksBefore,
       watchersCleaned: true,
       intervalsCleaned: true
     },
@@ -131,7 +137,7 @@ export function __trackComposable(name, callFn, meta) {
   };
   registry.register(entry);
   onUnmounted(() => {
-    const leakedWatchers = trackedWatchers.filter((w) => !w.stopped);
+    const leakedWatchers = trackedWatchers.filter((w) => w.effect.active);
     const leakedIntervals = trackedIntervals.filter((id2) => !clearedIntervals.has(id2));
     const leak = leakedWatchers.length > 0 || leakedIntervals.length > 0;
     const reasons = [];

package/dist/runtime/composables/fetch-registry.d.ts

@@ -14,6 +14,24 @@ export interface FetchEntry {
     file?: string;
     line?: number;
 }
+interface FetchResponse extends Response {
+    _data?: unknown;
+}
+interface FetchOptions {
+    server?: boolean;
+    onResponse?: (ctx: {
+        response: FetchResponse;
+    }) => void;
+    onResponseError?: (ctx: {
+        response: FetchResponse;
+    }) => void;
+    [key: string]: unknown;
+}
+interface FetchMeta {
+    key: string;
+    file: string;
+    line: number;
+}
 /**
  * Sets up the fetch registry, which tracks all fetch requests and their
  * associated metadata (e.g. duration, size, origin).
@@ -56,8 +74,6 @@ export declare function setupFetchRegistry(): {
         readonly line?: number | undefined;
     }>>>;
 };
-export declare function __devFetch(originalFn: (...args: unknown[]) => unknown, arg1: ((...args: unknown[]) => unknown) | string, arg2: Record<string, unknown>, meta: {
-    key: string;
-    file: string;
-    line: number;
-}): unknown;
+export declare function __devFetchHandler(handler: (...args: unknown[]) => unknown, key: unknown, meta: FetchMeta): (...args: unknown[]) => Promise<unknown>;
+export declare function __devFetchCall(originalFn: (url: string, opts: FetchOptions) => Promise<unknown>, url: string, opts: FetchOptions, meta: FetchMeta): Promise<unknown>;
+export {};

package/dist/runtime/composables/fetch-registry.js

@@ -14,42 +14,8 @@ export function setupFetchRegistry() {
     entries.value.set(id, updated);
     emit("fetch:update", updated);
   }
-  function safeValue(val) {
-    if (val === void 0 || val === null) {
-      return val;
-    }
-    if (typeof val === "function") {
-      return void 0;
-    }
-    if (typeof val === "object") {
-      try {
-        return JSON.parse(JSON.stringify(val));
-      } catch {
-        return String(val);
-      }
-    }
-    return val;
-  }
-  function sanitize(entry) {
-    return {
-      id: entry.id,
-      key: entry.key,
-      url: entry.url,
-      status: entry.status,
-      origin: entry.origin,
-      startTime: entry.startTime,
-      endTime: entry.endTime,
-      ms: entry.ms,
-      size: entry.size,
-      cached: entry.cached,
-      payload: safeValue(entry.payload),
-      error: safeValue(entry.error),
-      file: entry.file,
-      line: entry.line
-    };
-  }
   function getAll() {
-    return [...entries.value.values()].map(sanitize);
+    return [...entries.value.values()];
   }
   function clear() {
     entries.value.clear();
@@ -64,97 +30,103 @@ export function setupFetchRegistry() {
   }
   return { register, update, getAll, clear, entries: readonly(entries) };
 }
-export function __devFetch(originalFn, arg1, arg2, meta) {
+export function __devFetchHandler(handler, key, meta) {
   if (!import.meta.dev || !import.meta.client) {
-    if (typeof arg1 === "function") {
-      return (...args) => arg1(...args);
-    }
-    return originalFn(arg1, arg2);
+    return (...args) => Promise.resolve(handler(...args));
   }
   const registry = window.__observatory__?.fetch;
   if (!registry) {
-    return typeof arg1 === "function" ? originalFn(arg1, arg2) : originalFn(arg1, arg2);
+    return (...args) => Promise.resolve(handler(...args));
   }
-  if (typeof arg1 === "function") {
-    const handler = arg1;
-    return function wrappedHandler(...handlerArgs) {
-      const id = `${meta.key}::${Date.now()}`;
-      const startTime = performance.now();
-      const origin = import.meta.server ? "ssr" : "csr";
-      registry.register({
-        id,
-        key: meta.key,
-        url: meta.key,
-        // No URL in useAsyncData, use key as identifier
-        status: "pending",
-        origin,
-        startTime,
-        cached: false,
-        file: meta.file,
-        line: meta.line
-      });
-      return Promise.resolve(handler(...handlerArgs)).then((result) => {
-        registry.update(id, {
-          status: "ok",
-          endTime: performance.now(),
-          ms: Math.round(performance.now() - startTime),
-          payload: result
-        });
-        return result;
-      }).catch((error) => {
-        registry.update(id, {
-          status: "error",
-          endTime: performance.now(),
-          ms: Math.round(performance.now() - startTime),
-          error
-        });
-        throw error;
-      });
-    };
-  } else {
-    const url = arg1;
-    const opts = arg2 || {};
-    const id = `${meta.key}::${Date.now()}`;
+  const normalizedKey = typeof key === "string" ? key : "useAsyncData";
+  return (...args) => {
+    const id = `${normalizedKey}::${Date.now()}`;
     const startTime = performance.now();
-    const origin = import.meta.server ? "ssr" : "csr";
     registry.register({
       id,
-      key: meta.key,
-      url: typeof url === "string" ? url : String(url),
+      key: normalizedKey,
+      url: normalizedKey,
       status: "pending",
-      origin,
+      origin: "csr",
       startTime,
       cached: false,
       file: meta.file,
       line: meta.line
     });
-    return originalFn(url, {
-      ...opts,
-      onResponse({ response }) {
-        const ms = Math.round(performance.now() - startTime);
-        const size = Number(response.headers?.get("content-length")) || void 0;
-        const cached = response.headers?.get("x-nuxt-cache") === "HIT";
-        registry.update(id, {
-          status: response.ok ? "ok" : "error",
-          endTime: performance.now(),
-          ms,
-          size,
-          cached
-        });
-        if (typeof opts.onResponse === "function") {
-          opts.onResponse({ response });
-        }
-      },
-      onResponseError({ response }) {
-        registry.update(id, {
-          status: "error",
-          endTime: performance.now(),
-          ms: Math.round(performance.now() - startTime)
-        });
-        if (typeof opts.onResponseError === "function") {
-          opts.onResponseError({ response });
-        }
-      }
+    return Promise.resolve(handler(...args)).then((result) => {
+      registry.update(id, {
+        status: "ok",
+        endTime: performance.now(),
+        ms: Math.round(performance.now() - startTime),
+        payload: result
+      });
+      return result;
+    }).catch((error) => {
+      registry.update(id, {
+        status: "error",
+        endTime: performance.now(),
+        ms: Math.round(performance.now() - startTime),
+        error
+      });
+      throw error;
     });
+  };
+}
+export function __devFetchCall(originalFn, url, opts, meta) {
+  if (!import.meta.dev || !import.meta.client) {
+    return originalFn(url, opts);
+  }
+  const registry = window.__observatory__?.fetch;
+  if (!registry) {
+    return originalFn(url, opts);
+  }
+  const id = `${meta.key}::${Date.now()}`;
+  const startTime = performance.now();
+  const payload = window.__NUXT__?.data ?? {};
+  const fromPayload = Object.prototype.hasOwnProperty.call(payload, meta.key);
+  const origin = fromPayload ? "ssr" : "csr";
+  registry.register({
+    id,
+    key: meta.key,
+    url: typeof url === "string" ? url : String(url),
+    status: fromPayload ? "cached" : "pending",
+    origin,
+    startTime,
+    cached: fromPayload,
+    payload: fromPayload ? payload[meta.key] : void 0,
+    file: meta.file,
+    line: meta.line
+  });
+  if (fromPayload) {
+    return originalFn(url, opts);
   }
+  return originalFn(url, {
+    ...opts,
+    onResponse({ response }) {
+      const ms = Math.round(performance.now() - startTime);
+      const size = Number(response.headers?.get("content-length")) || void 0;
+      const cached = response.headers?.get("x-nuxt-cache") === "HIT";
+      registry.update(id, {
+        status: cached ? "cached" : response.ok ? "ok" : "error",
+        endTime: performance.now(),
+        ms,
+        size,
+        cached,
+        payload: response._data
+      });
+      if (typeof opts.onResponse === "function") {
+        opts.onResponse({ response });
+      }
+    },
+    onResponseError({ response }) {
+      registry.update(id, {
+        status: "error",
+        endTime: performance.now(),
+        ms: Math.round(performance.now() - startTime)
+      });
+      if (typeof opts.onResponseError === "function") {
+        opts.onResponseError({ response });
+      }
+    }
+  });
 }

package/dist/runtime/composables/provide-inject-registry.d.ts

@@ -3,6 +3,8 @@ export interface ProvideEntry {
     componentName: string;
     componentFile: string;
     componentUid: number;
+    parentUid?: number;
+    parentFile?: string;
     isReactive: boolean;
     valueSnapshot: unknown;
     line: number;
@@ -12,6 +14,8 @@ export interface InjectEntry {
     componentName: string;
     componentFile: string;
     componentUid: number;
+    parentUid?: number;
+    parentFile?: string;
     resolved: boolean;
     resolvedFromFile?: string;
     resolvedFromUid?: number;

package/dist/runtime/composables/provide-inject-registry.js

@@ -79,6 +79,8 @@ export function __devProvide(key, value, meta) {
     componentName: instance?.type?.__name ?? "unknown",
     componentFile: meta.file,
     componentUid: instance?.uid ?? -1,
+    parentUid: instance?.parent?.uid,
+    parentFile: instance?.parent?.type?.__file,
     isReactive: isRef(value) || isReactive(value),
     valueSnapshot: safeSnapshot(unref(value)),
     line: meta.line
@@ -100,6 +102,8 @@ export function __devInject(key, defaultValue, meta) {
     componentName: instance?.type?.__name ?? "unknown",
     componentFile: meta.file,
     componentUid: instance?.uid ?? -1,
+    parentUid: instance?.parent?.uid,
+    parentFile: instance?.parent?.type?.__file,
     resolved: resolved !== void 0,
     resolvedFromFile: providerInfo?.file,
     resolvedFromUid: providerInfo?.uid,

package/dist/runtime/composables/render-registry.d.ts

@@ -25,12 +25,11 @@ export interface RenderEntry {
  * Sets up a render registry for the given Nuxt app.
  * @param {{ vueApp: import('vue').App }} nuxtApp - The Nuxt app object.
  * @param {object} nuxtApp.vueApp - The Vue app instance.
- * @param {number} threshold - The minimum number of renders required for a component to be tracked.
  * @returns {object} The render registry object.
  */
 export declare function setupRenderRegistry(nuxtApp: {
     vueApp: import('vue').App;
-}, threshold: number): {
+}): {
     getAll: () => RenderEntry[];
     snapshot: () => RenderEntry[];
 };