@component-compass/cli 0.1.24 → 0.1.25

package/dist/cli.js

@@ -43170,6 +43170,207 @@ var require_ignore = __commonJS({
   }
 });
 
+// src/upload.ts
+import { gzipSync } from "node:zlib";
+function statusUrl(host, receipt) {
+  const base2 = new URL(host);
+  const url = new URL(receipt.statusUrl, base2);
+  if (url.origin !== base2.origin || url.username || url.password) {
+    throw new Error("Upload status URL must have the same origin as the upload host");
+  }
+  return url.href;
+}
+async function getUploadStatus(opts) {
+  const url = statusUrl(opts.host, opts.receipt);
+  opts.signal?.throwIfAborted();
+  const response = await fetch(url, {
+    method: "GET",
+    redirect: "error",
+    headers: { Authorization: `Bearer ${opts.token}` },
+    ...opts.signal ? { signal: opts.signal } : {}
+  });
+  const retryAfterSeconds = parseRetryAfter(response.headers.get("Retry-After"));
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new UploadError(response.status, `Upload status failed (${response.status})`, retryAfterSeconds);
+  }
+  const status = await response.json();
+  if (retryAfterSeconds !== void 0) status.retryAfterSeconds = retryAfterSeconds;
+  return status;
+}
+function parseRetryAfter(retryAfter) {
+  if (retryAfter === null) return void 0;
+  const seconds = /^\d+(?:\.\d+)?$/.test(retryAfter.trim()) ? Number(retryAfter) : (Date.parse(retryAfter) - Date.now()) / 1e3;
+  return Number.isFinite(seconds) ? Math.max(0, seconds) : void 0;
+}
+function transientReason(err2) {
+  if (err2 instanceof UploadError) return TRANSIENT_STATUSES.has(err2.code) ? err2.message : void 0;
+  const seen2 = /* @__PURE__ */ new Set();
+  for (let current = err2; typeof current === "object" && current !== null && !seen2.has(current); current = current.cause) {
+    seen2.add(current);
+    const { code } = current;
+    if (typeof code === "string" && TRANSIENT_CODES.has(code)) {
+      return err2 instanceof Error ? `${err2.message} (${code})` : code;
+    }
+  }
+  return void 0;
+}
+function backoffDelay(attempt) {
+  return Math.min(3e4, 1e3 * 2 ** attempt);
+}
+async function pollUpload(opts) {
+  const url = statusUrl(opts.host, opts.receipt);
+  const controller = new AbortController();
+  const signal = controller.signal;
+  const abort = () => controller.abort(opts.signal?.reason);
+  opts.signal?.addEventListener("abort", abort, { once: true });
+  let lastFailure;
+  const timer = setTimeout(() => controller.abort(new UploadPendingError(opts.receipt, url, lastFailure)), opts.timeoutMs);
+  const cancelled = new Promise((_resolve, reject) => {
+    signal.addEventListener("abort", () => reject(signal.reason), { once: true });
+  });
+  async function run() {
+    opts.signal?.throwIfAborted();
+    let token = await opts.getToken();
+    for (let attempt = 0; ; attempt++) {
+      signal.throwIfAborted();
+      const inspect3 = () => getUploadStatus({ host: opts.host, receipt: opts.receipt, token, signal });
+      let status;
+      let hint;
+      try {
+        status = await inspect3().catch(async (err2) => {
+          if (!(err2 instanceof UploadError) || err2.code !== 401) throw err2;
+          signal.throwIfAborted();
+          token = await opts.refreshToken();
+          return await inspect3();
+        });
+      } catch (err2) {
+        const reason = transientReason(err2);
+        if (reason === void 0) throw err2;
+        lastFailure = { reason, error: err2 };
+        hint = err2 instanceof UploadError ? err2.retryAfterSeconds : void 0;
+      }
+      signal.throwIfAborted();
+      if (status) {
+        lastFailure = void 0;
+        opts.onStatus?.(status);
+        if (status.state === "failed") {
+          throw new UploadPollingError(
+            opts.receipt,
+            url,
+            "failed",
+            new Error(`Upload ${opts.receipt.uploadId} failed: ${status.error?.code ?? "processing_failed"}: ${status.error?.message ?? "Processing failed"}`)
+          );
+        }
+        if (status.readable && (status.state === "ready" || status.state === "duplicate")) {
+          return { status: status.state === "ready" ? "inserted" : "exists", scanId: status.scanId, url: status.url };
+        }
+        hint = status.retryAfterSeconds;
+      }
+      const delay = hint !== void 0 ? hint * 1e3 : backoffDelay(attempt);
+      await wait(Math.min(2147483647, Math.max(1e3, delay)), signal);
+    }
+  }
+  try {
+    return await Promise.race([run(), cancelled]);
+  } catch (err2) {
+    if (err2 instanceof UploadPendingError || err2 instanceof UploadPollingError) throw err2;
+    throw new UploadPollingError(opts.receipt, url, "unknown", err2);
+  } finally {
+    clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", abort);
+    controller.abort();
+  }
+}
+function wait(delay, signal) {
+  return new Promise((resolve14, reject) => {
+    signal?.throwIfAborted();
+    const abort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve14();
+    }, delay);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+async function submitArtifact(opts) {
+  const url = `${opts.host.replace(/\/$/, "")}/api/scans`;
+  const useGzip = opts.artifactJson.length > GZIP_THRESHOLD;
+  const body = useGzip ? gzipSync(Buffer.from(opts.artifactJson, "utf8")) : opts.artifactJson;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${opts.token}`
+  };
+  if (useGzip) headers["Content-Encoding"] = "gzip";
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await postArtifact(url, headers, body);
+    } catch (err2) {
+      if (attempt >= SUBMIT_ATTEMPTS || transientReason(err2) === void 0) throw err2;
+      const hint = err2 instanceof UploadError ? err2.retryAfterSeconds : void 0;
+      const backoff = backoffDelay(attempt - 1);
+      await wait(hint === void 0 ? backoff : Math.max(backoff, Math.min(hint * 1e3, 3e4)));
+    }
+  }
+}
+async function postArtifact(url, headers, body) {
+  const res = await fetch(url, { method: "POST", headers, body, redirect: "error" });
+  if (res.status === 202) {
+    return await res.json();
+  }
+  const text2 = await res.text().catch(() => "");
+  throw new UploadError(res.status, `Upload failed (${res.status}): ${text2 || res.statusText}`, parseRetryAfter(res.headers.get("Retry-After")));
+}
+var UploadPendingError, UploadPollingError, TRANSIENT_STATUSES, TRANSIENT_CODES, UploadError, GZIP_THRESHOLD, SUBMIT_ATTEMPTS;
+var init_upload = __esm({
+  "src/upload.ts"() {
+    "use strict";
+    UploadPendingError = class extends Error {
+      constructor(receipt, statusUrl2, lastFailure) {
+        const failure = lastFailure ? ` The last status check failed: ${lastFailure.reason}.` : "";
+        super(
+          `Upload ${receipt.uploadId} is still pending. Check ${statusUrl2}; the server job continues.${failure}`,
+          lastFailure ? { cause: lastFailure.error } : void 0
+        );
+        this.receipt = receipt;
+        this.statusUrl = statusUrl2;
+      }
+      receipt;
+      statusUrl;
+    };
+    UploadPollingError = class extends Error {
+      constructor(receipt, statusUrl2, outcome, cause) {
+        super(cause instanceof Error ? cause.message : String(cause), { cause });
+        this.receipt = receipt;
+        this.statusUrl = statusUrl2;
+        this.outcome = outcome;
+      }
+      receipt;
+      statusUrl;
+      outcome;
+      get code() {
+        return this.cause instanceof UploadError ? this.cause.code : void 0;
+      }
+    };
+    TRANSIENT_STATUSES = /* @__PURE__ */ new Set([502, 503, 504]);
+    TRANSIENT_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "ECONNREFUSED", "EPIPE", "EAI_AGAIN", "UND_ERR_SOCKET"]);
+    UploadError = class extends Error {
+      constructor(code, message, retryAfterSeconds) {
+        super(message);
+        this.code = code;
+        this.retryAfterSeconds = retryAfterSeconds;
+      }
+      code;
+      retryAfterSeconds;
+    };
+    GZIP_THRESHOLD = 1024 * 1024;
+    SUBMIT_ATTEMPTS = 3;
+  }
+});
+
 // src/auth/paths.ts
 import { homedir } from "node:os";
 import { join as join15 } from "node:path";
@@ -43407,44 +43608,6 @@ var init_session = __esm({
   }
 });
 
-// src/upload.ts
-import { gzipSync } from "node:zlib";
-async function uploadArtifact(opts) {
-  const url = `${opts.host.replace(/\/$/, "")}/api/scans`;
-  const useGzip = opts.artifactJson.length > GZIP_THRESHOLD;
-  const body = useGzip ? gzipSync(Buffer.from(opts.artifactJson, "utf8")) : opts.artifactJson;
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${opts.token}`
-  };
-  if (useGzip) headers["Content-Encoding"] = "gzip";
-  const res = await fetch(url, { method: "POST", headers, body });
-  if (res.status === 201 || res.status === 200) {
-    const json = await res.json();
-    return {
-      status: res.status === 201 ? "inserted" : "exists",
-      scanId: json.scanId,
-      url: json.url
-    };
-  }
-  const text2 = await res.text().catch(() => "");
-  throw new UploadError(res.status, `Upload failed (${res.status}): ${text2 || res.statusText}`);
-}
-var UploadError, GZIP_THRESHOLD;
-var init_upload = __esm({
-  "src/upload.ts"() {
-    "use strict";
-    UploadError = class extends Error {
-      constructor(code, message) {
-        super(message);
-        this.code = code;
-      }
-      code;
-    };
-    GZIP_THRESHOLD = 1024 * 1024;
-  }
-});
-
 // src/auth/upload-auth.ts
 var upload_auth_exports = {};
 __export(upload_auth_exports, {
@@ -43458,28 +43621,33 @@ async function createAuthedUploader(opts) {
     ...opts.configHost !== void 0 ? { configHost: opts.configHost } : {},
     store
   });
-  const ciToken = process.env["COMPONENT_COMPASS_TOKEN"];
-  if (ciToken) {
-    return {
-      base: base2,
-      async upload(artifactJson) {
-        return await uploadArtifact({ host: base2, token: ciToken, artifactJson });
-      }
-    };
+  const { COMPONENT_COMPASS_TOKEN: ciToken } = process.env;
+  const session = filePath !== void 0 ? { filePath } : {};
+  let token = ciToken || (await getAccessToken(base2, session)).accessToken;
+  async function refreshToken() {
+    if (ciToken) {
+      throw new UploadError(401, "COMPONENT_COMPASS_TOKEN was rejected (401); interactive login and token refresh are disabled. Supply a valid token.");
+    }
+    token = (await getAccessToken(base2, { ...session, force: true })).accessToken;
+    return token;
   }
-  let token = (await getAccessToken(base2, filePath !== void 0 ? { filePath } : {})).accessToken;
   return {
     base: base2,
     async upload(artifactJson) {
-      try {
-        return await uploadArtifact({ host: base2, token, artifactJson });
-      } catch (err2) {
-        if (err2 instanceof UploadError && err2.code === 401) {
-          token = (await getAccessToken(base2, { force: true, ...filePath !== void 0 ? { filePath } : {} })).accessToken;
-          return await uploadArtifact({ host: base2, token, artifactJson });
-        }
-        throw err2;
-      }
+      const submit = () => submitArtifact({ host: base2, token, artifactJson });
+      const receipt = await submit().catch(async (err2) => {
+        if (!(err2 instanceof UploadError) || err2.code !== 401) throw err2;
+        await refreshToken();
+        return await submit();
+      });
+      return await pollUpload({
+        host: base2,
+        receipt,
+        getToken: async () => token,
+        refreshToken,
+        timeoutMs: 3e5,
+        ...opts.onStatus ? { onStatus: opts.onStatus } : {}
+      });
     }
   };
 }
@@ -94573,6 +94741,236 @@ function walk2(graph, file, imported, seen2) {
   return null;
 }
 
+// ../reference-graph/dist/engine/helper-callers.js
+function findLocalDeclaration(fileGraph, ref) {
+  let scope = ref.scope;
+  while (true) {
+    const decl = fileGraph.declarations.get(`${scope}::${ref.symbol}`);
+    if (decl)
+      return decl;
+    if (scope === MODULE_SCOPE)
+      return null;
+    const parent = fileGraph.scopes.get(scope)?.parent;
+    if (parent === null || parent === void 0)
+      return null;
+    scope = parent;
+  }
+}
+function classifyDeclaration(decl, registry, fileGraph) {
+  if (decl.value.kind !== "Function" && decl.value.kind !== "ReturnTypeOf")
+    return "unknown";
+  if (fileGraph.dialect === "vue" && isSfcDeclaration(fileGraph, decl))
+    return "component";
+  return registry.hasLocal(fileGraph.filePath, decl.symbol) ? "component" : "helper";
+}
+var isSfcDeclaration = (fileGraph, decl) => fileGraph.exports.some((e) => e.kind === "default" && "local" in e && e.local === decl.symbol);
+function buildHelperCallers(graph, registry) {
+  const index = /* @__PURE__ */ new Map();
+  const callerKeysByHelper = /* @__PURE__ */ new Map();
+  const classificationCache = /* @__PURE__ */ new Map();
+  const refResolutionCache = /* @__PURE__ */ new Map();
+  function resolveRefCached(ref, callerFile, callerGraph) {
+    const key = `${callerFile}::${ref.symbol}`;
+    if (refResolutionCache.has(key)) {
+      return refResolutionCache.get(key) ?? null;
+    }
+    const result2 = resolveRefToDecl(ref, callerFile, callerGraph, graph);
+    refResolutionCache.set(key, result2);
+    return result2;
+  }
+  const pendingValueRefs = [];
+  for (const [file, fileGraph] of graph.files) {
+    for (const decl of fileGraph.declarations.values()) {
+      if (decl.scope !== MODULE_SCOPE)
+        continue;
+      const refs = [];
+      if (decl.value.kind === "Function") {
+        for (const r2 of decl.value.returns)
+          collectRefsInType(r2, refs);
+      } else if (decl.value.kind === "ReturnTypeOf") {
+        collectCalleeRefs(decl.value, refs);
+      }
+      for (const bc of fileGraph.bodyCalls) {
+        if (bc.ownerSymbol === decl.symbol)
+          refs.push(bc.callee);
+      }
+      const callerKey = { file, symbol: decl.symbol };
+      for (const ref of refs) {
+        const target = resolveRefCached(ref, file, fileGraph);
+        if (!target)
+          continue;
+        pendingValueRefs.push({ target, caller: callerKey });
+      }
+    }
+  }
+  const pendingJsxCalls = [];
+  for (const [file, fileGraph] of graph.files) {
+    for (let i2 = 0; i2 < fileGraph.jsxUsages.length; i2++) {
+      const usage = fileGraph.jsxUsages[i2];
+      if (!usage)
+        continue;
+      const target = resolveRefCached(usage.ref, file, fileGraph);
+      if (!target)
+        continue;
+      const ownership = fileGraph.ownership[i2];
+      if (!ownership?.ownerSymbolRef)
+        continue;
+      const callerTarget = resolveRefCached(ownership.ownerSymbolRef, file, fileGraph);
+      if (!callerTarget)
+        continue;
+      if (callerTarget.decl.scope !== MODULE_SCOPE)
+        continue;
+      pendingJsxCalls.push({
+        target,
+        caller: { file: callerTarget.file, symbol: callerTarget.decl.symbol }
+      });
+    }
+  }
+  function classifyKey(file, decl) {
+    const key = `${file}::${decl.symbol}`;
+    const hit = classificationCache.get(key);
+    if (hit !== void 0)
+      return hit;
+    const fileGraph = graph.files.get(file);
+    const result2 = fileGraph ? classifyDeclaration(decl, registry, fileGraph) : "unknown";
+    classificationCache.set(key, result2);
+    return result2;
+  }
+  for (const [file, fileGraph] of graph.files) {
+    for (const decl of fileGraph.declarations.values()) {
+      if (decl.scope !== MODULE_SCOPE)
+        continue;
+      if (decl.value.kind !== "Function" && decl.value.kind !== "ReturnTypeOf")
+        continue;
+      classifyKey(file, decl);
+    }
+  }
+  function recordCallerEdge(target, callerKey) {
+    const keyStr = `${target.file}::${target.decl.symbol}`;
+    const callerKeyStr = `${callerKey.file}::${callerKey.symbol}`;
+    let seen2 = callerKeysByHelper.get(keyStr);
+    if (!seen2) {
+      seen2 = /* @__PURE__ */ new Set();
+      callerKeysByHelper.set(keyStr, seen2);
+    }
+    if (seen2.has(callerKeyStr))
+      return;
+    seen2.add(callerKeyStr);
+    let callers = index.get(keyStr);
+    if (!callers) {
+      callers = /* @__PURE__ */ new Set();
+      index.set(keyStr, callers);
+    }
+    callers.add(callerKey);
+  }
+  for (const { target, caller } of pendingValueRefs) {
+    if (classifyKey(target.file, target.decl) !== "helper")
+      continue;
+    recordCallerEdge(target, caller);
+  }
+  for (const { target, caller } of pendingJsxCalls) {
+    if (classifyKey(target.file, target.decl) !== "helper")
+      continue;
+    recordCallerEdge(target, caller);
+  }
+  return {
+    get(key) {
+      return index.get(`${key.file}::${key.symbol}`);
+    },
+    classification(file, symbol2) {
+      return classificationCache.get(`${file}::${symbol2}`) ?? "unknown";
+    }
+  };
+}
+function collectCalleeRefs(t3, out2) {
+  switch (t3.kind) {
+    case "ReturnTypeOf":
+      collectCalleeRefs(t3.callee, out2);
+      return;
+    case "MemberOf":
+      collectCalleeRefs(t3.obj, out2);
+      return;
+    case "TypeOf":
+      out2.push(t3.ref);
+      return;
+    default:
+      return;
+  }
+}
+function collectRefsInType(t3, out2) {
+  switch (t3.kind) {
+    case "TypeOf":
+      out2.push(t3.ref);
+      return;
+    case "Union":
+      for (const u3 of t3.types)
+        collectRefsInType(u3, out2);
+      return;
+    case "ReturnTypeOf":
+      collectRefsInType(t3.callee, out2);
+      for (const a3 of t3.args)
+        collectRefsInType(a3, out2);
+      return;
+    case "Function":
+      for (const r2 of t3.returns)
+        collectRefsInType(r2, out2);
+      return;
+    case "Object":
+      for (const v of Object.values(t3.props))
+        collectRefsInType(v, out2);
+      return;
+    case "Array":
+      for (const e of t3.elements)
+        collectRefsInType(e, out2);
+      return;
+    case "MemberOf":
+      collectRefsInType(t3.obj, out2);
+      return;
+    case "ParameterOf":
+      return;
+    default:
+      return;
+  }
+}
+function resolveRefToDecl(ref, callerFile, callerGraph, graph) {
+  const localKey = `${MODULE_SCOPE}::${ref.symbol}`;
+  const localDecl = callerGraph.declarations.get(localKey);
+  if (localDecl)
+    return { file: callerFile, decl: localDecl };
+  const imp = callerGraph.importsByLocal.get(ref.symbol);
+  if (!imp)
+    return null;
+  const resolvedAbs = graph.moduleResolver(callerFile, imp.specifier);
+  if (!resolvedAbs)
+    return null;
+  const targetFile = graph.resolveToGraphKey ? graph.resolveToGraphKey(resolvedAbs) ?? resolvedAbs : resolvedAbs;
+  const targetGraph = graph.files.get(targetFile);
+  if (!targetGraph)
+    return null;
+  const chained = followReExportChain(graph, targetFile, imp.imported);
+  if (chained) {
+    const chainedGraph = graph.files.get(chained.file);
+    if (chainedGraph) {
+      const decl = chainedGraph.declarations.get(`${MODULE_SCOPE}::${chained.localExport}`);
+      if (decl)
+        return { file: chained.file, decl };
+    }
+  }
+  for (const exp of targetGraph.exports) {
+    if (exp.kind === "named" && "local" in exp && exp.exportedAs === imp.imported) {
+      const decl = targetGraph.declarations.get(`${MODULE_SCOPE}::${exp.local}`);
+      if (decl)
+        return { file: targetFile, decl };
+    }
+    if (exp.kind === "default" && "local" in exp && imp.imported === "default") {
+      const decl = targetGraph.declarations.get(`${MODULE_SCOPE}::${exp.local}`);
+      if (decl)
+        return { file: targetFile, decl };
+    }
+  }
+  return null;
+}
+
 // ../reference-graph/dist/engine/member-identity.js
 function effectiveExportName(imported, memberChain) {
   const first = memberChain[0];
@@ -94584,6 +94982,15 @@ function residualMemberChain(imported, memberChain) {
 function compoundExportName(root2, residual) {
   return residual.length === 0 ? root2 : `${root2}.${residual.join(".")}`;
 }
+function memberOfObjectPath(holder, path5) {
+  let cur = holder;
+  for (const segment of path5) {
+    if (cur?.kind !== "Object")
+      return void 0;
+    cur = cur.props[segment];
+  }
+  return cur;
+}
 function unparsedMemberDefinition(graph, resolvedAbs, imported) {
   if (graph.workspaceMembership?.(resolvedAbs) !== true)
     return null;
@@ -94663,7 +95070,9 @@ function evalInner(t3, ctx) {
   }
 }
 function evalCall(t3, ctx) {
-  if (t3.args.some(containsDynamicImport))
+  if (nonComponentProduct(ctx.graph, ctx.fileGraph, t3.callee, ctx.guard) !== null)
+    return "other";
+  if (t3.args.some((a3) => containsDynamicImport(a3)))
     return "component";
   const fns = resolveToFunctions(ctx.graph, ctx.fileGraph, t3.callee, ctx.argMap, ctx.guard);
   const resolvable = [];
@@ -94672,7 +95081,8 @@ function evalCall(t3, ctx) {
       resolvable.push(f);
   }
   if (resolvable.length === 0) {
-    const carries = t3.args.some((a3) => evalInner(a3, ctx) === "component" || isImportBackedLeaf(a3, ctx.graph, ctx.fileGraph, ctx.guard));
+    const isProductCall = (a3) => a3.kind === "ReturnTypeOf" && nonComponentProduct(ctx.graph, ctx.fileGraph, a3.callee, ctx.guard) !== null;
+    const carries = t3.args.some((a3) => evalInner(a3, ctx) === "component" || isImportBackedLeaf(a3, ctx.graph, ctx.fileGraph, ctx.guard) && !isProductCall(a3));
     if (!carries)
       return "unresolved";
     if (t3.callee.kind === "MemberOf" && !isImportBackedLeaf(t3.callee, ctx.graph, ctx.fileGraph, ctx.guard))
@@ -94709,43 +95119,75 @@ function isImportBackedLeaf(t3, graph, fileGraph, guard) {
     return false;
   return resolveReference(graph, fileGraph, cur.ref, guard).kind === "Unknown";
 }
+function nonComponentProduct(graph, fileGraph, callee, guard) {
+  const ref = callee.kind === "TypeOf" ? callee.ref : callee.kind === "MemberOf" && callee.obj.kind === "TypeOf" ? { ...callee.obj.ref, memberChain: [callee.member] } : null;
+  if (ref === null)
+    return null;
+  const imp = fileGraphForRef(graph, ref, fileGraph).importsByLocal.get(ref.symbol);
+  const entry = imp === void 0 ? null : libraryExportFor(imp, ref);
+  if (entry === null || entry.kind !== "non-component-product")
+    return null;
+  return isImportBackedLeaf(callee, graph, fileGraph, guard) ? entry.semantics : null;
+}
 function firstDynamicImport(t3) {
+  return searchDynamicImport(t3, null);
+}
+function searchDynamicImport(t3, peek) {
   switch (t3.kind) {
     case "DynamicImport":
       return t3;
     case "Function":
       for (const r2 of t3.returns) {
-        const hit = firstDynamicImport(r2);
+        const hit = searchDynamicImport(r2, peek);
         if (hit)
           return hit;
       }
       return null;
     case "ReturnTypeOf": {
-      const inCallee = firstDynamicImport(t3.callee);
+      const inCallee = searchDynamicImport(t3.callee, peek);
       if (inCallee)
         return inCallee;
       for (const a3 of t3.args) {
-        const hit = firstDynamicImport(a3);
+        const hit = searchDynamicImport(a3, peek);
         if (hit)
           return hit;
       }
       return null;
     }
     case "MemberOf":
-      return firstDynamicImport(t3.obj);
+      return searchDynamicImport(t3.obj, peek);
     case "Union":
       for (const u3 of t3.types) {
-        const hit = firstDynamicImport(u3);
+        const hit = searchDynamicImport(u3, peek);
+        if (hit)
+          return hit;
+      }
+      return null;
+    case "Object":
+      for (const v of Object.values(t3.props)) {
+        const hit = searchDynamicImport(v, peek);
         if (hit)
           return hit;
       }
       return null;
+    case "Array":
+      for (const e of t3.elements) {
+        const hit = searchDynamicImport(e, peek);
+        if (hit)
+          return hit;
+      }
+      return null;
+    case "TypeOf": {
+      const bound = peek?.(t3) ?? null;
+      return bound === null ? null : searchDynamicImport(bound, null);
+    }
     default:
       return null;
   }
 }
-function containsDynamicImport(t3) {
-  return firstDynamicImport(t3) !== null;
+function containsDynamicImport(t3, at) {
+  const peek = at === void 0 ? null : (ref) => findLocalDeclaration(fileGraphForRef(at.graph, ref.ref, at.fileGraph), ref.ref)?.value ?? null;
+  return searchDynamicImport(t3, peek) !== null;
 }
 
 // ../reference-graph/dist/engine/host-element.js
@@ -94783,12 +95225,26 @@ var RENDER_VERDICT = {
   opaque: () => "silent",
   "late-bound": () => "late-bound",
   data: () => "unresolved",
-  indeterminate: () => "unresolved"
+  indeterminate: () => "unresolved",
+  callable: () => "credit"
 };
 var VERDICT_ORDER = ["credit", "silent", "late-bound", "unresolved"];
 function creditedTerminals(e) {
   return e.filter((t3) => matchDenotation(t3, RENDER_VERDICT) === "credit");
 }
+var IS_CALLABLE = {
+  element: () => false,
+  foreign: () => false,
+  "host-string": () => false,
+  opaque: () => false,
+  "late-bound": () => false,
+  data: () => false,
+  indeterminate: () => false,
+  callable: () => true
+};
+function isCallable(t3) {
+  return matchDenotation(t3, IS_CALLABLE);
+}
 function renderOutcome(e) {
   const verdicts = e.map((t3) => matchDenotation(t3, RENDER_VERDICT));
   const winner = VERDICT_ORDER.find((v) => verdicts.includes(v)) ?? "unresolved";
@@ -94809,6 +95265,40 @@ function renderOutcome(e) {
 function isDataMethodRenderCall(type, graph, fileGraph, guard) {
   return type.callee.kind === "MemberOf" && !isImportBackedLeaf(type.callee, graph, fileGraph, guard);
 }
+function isLoader(value, graph, fileGraph, guard) {
+  if (value.kind === "Function")
+    return containsDynamicImport(value, { graph, fileGraph });
+  if (value.kind !== "TypeOf" && value.kind !== "MemberOf")
+    return false;
+  if (guard.pushNode(value) === "cycle")
+    return false;
+  try {
+    if (value.kind === "TypeOf")
+      return isLoader(resolveReference(graph, fileGraph, value.ref, guard), graph, fileGraph, guard);
+    const holder = objectLiteralOf(value.obj, graph, fileGraph, guard);
+    if (holder === null)
+      return false;
+    if (value.member !== DYNAMIC_MEMBER_KEY) {
+      const held = holder.props[value.member];
+      return held !== void 0 && isLoader(held, graph, fileGraph, guard);
+    }
+    const all = Object.values(holder.props);
+    return all.length > 0 && all.every((v) => isLoader(v, graph, fileGraph, guard));
+  } finally {
+    guard.popNode(value);
+  }
+}
+function objectLiteralOf(value, graph, fileGraph, guard) {
+  if (value.kind === "Object")
+    return value;
+  if (value.kind !== "TypeOf" || guard.pushNode(value) === "cycle")
+    return null;
+  try {
+    return objectLiteralOf(resolveReference(graph, fileGraph, value.ref, guard), graph, fileGraph, guard);
+  } finally {
+    guard.popNode(value);
+  }
+}
 var INDETERMINATE = { kind: "indeterminate" };
 function withSemantics(t3, semantics) {
   return { denotation: t3.denotation, viaTrail: t3.viaTrail, identity: t3.identity, semantics };
@@ -94826,7 +95316,8 @@ var CAME_TO_NOTHING = {
   opaque: () => true,
   "late-bound": () => true,
   data: () => false,
-  indeterminate: () => true
+  indeterminate: () => true,
+  callable: () => false
 };
 function cameToNothing(t3) {
   return matchDenotation(t3, CAME_TO_NOTHING);
@@ -94838,7 +95329,8 @@ var IS_LATE_BOUND = {
   opaque: () => false,
   "late-bound": () => true,
   data: () => false,
-  indeterminate: () => false
+  indeterminate: () => false,
+  callable: () => false
 };
 function relabel(denotation) {
   return (t3) => cameToNothing(t3) ? { denotation, viaTrail: t3.viaTrail, identity: t3.identity } : t3;
@@ -94856,7 +95348,8 @@ var AS_RETURNED_VALUE = {
   opaque: () => INDETERMINATE,
   "late-bound": () => INDETERMINATE,
   data: (d2) => d2,
-  indeterminate: (d2) => d2
+  indeterminate: (d2) => d2,
+  callable: (d2) => d2
 };
 function returnedValue(t3) {
   const denotation = matchDenotation(t3, AS_RETURNED_VALUE);
@@ -94959,25 +95452,27 @@ function isPassThroughWrapper(algResult, inner) {
   const algKeys = algResult.filter((t3) => !cameToNothing(t3));
   return algKeys.length > 0 && algKeys.every((t3) => t3.identity !== null && innerKeys.has(identityKey(t3.identity)));
 }
-function walkWithFolding(graph, fileGraph, type, argMap, guard = createCycleGuard(), identityFallback) {
-  return atLeastOne(walkInner(graph, fileGraph, type, argMap, guard, identityFallback).map(published));
+function walkWithFolding(graph, fileGraph, type, argMap, guard = createCycleGuard(), identityFallback, position = "value") {
+  return atLeastOne(walkInner(graph, fileGraph, type, argMap, guard, identityFallback, position).map(published));
 }
-function walkInner(graph, fileGraph, type, argMap, guard, identityFallback) {
+function walkInner(graph, fileGraph, type, argMap, guard, identityFallback, position) {
   const fallback = identityFallback ?? type;
   switch (type.kind) {
     case "ReturnTypeOf":
-      return walkReturnTypeOf(graph, fileGraph, type, argMap, guard);
+      return walkReturnTypeOf(graph, fileGraph, type, argMap, guard, position);
     case "MemberOf":
       if (type.member === DYNAMIC_MEMBER_KEY) {
-        return walkDynamicMember(graph, fileGraph, type, argMap, guard);
+        return walkDynamicMember(graph, fileGraph, type, argMap, guard, position);
       }
-      return walkStaticMember(graph, fileGraph, type, argMap, guard, fallback);
+      return walkStaticMember(graph, fileGraph, type, argMap, guard, fallback, position);
     case "Function":
-      return type.returns.flatMap((r2) => walkInner(graph, fileGraph, r2, argMap, guard, type)).map(returnedValue);
+      if (position === "tag")
+        return [{ denotation: { kind: "callable" }, identity: null, viaTrail: [] }];
+      return type.returns.flatMap((r2) => walkInner(graph, fileGraph, r2, argMap, guard, type, "value")).map(returnedValue);
     case "TypeOf":
-      return walkTypeOf(graph, fileGraph, type, argMap, guard, fallback);
+      return walkTypeOf(graph, fileGraph, type, argMap, guard, fallback, position);
     case "Union":
-      return type.types.flatMap((branch) => walkInner(graph, fileGraph, branch, argMap, guard, fallback));
+      return type.types.flatMap((branch) => walkInner(graph, fileGraph, branch, argMap, guard, fallback, position));
     case "ParameterOf":
       return walkParameter(graph, fileGraph, type, argMap, guard, fallback);
     case "DynamicImport":
@@ -95019,7 +95514,7 @@ function dynamicImportIdentity(graph, fileGraph, di) {
     resolvedFile
   };
 }
-function walkTypeOf(graph, fileGraph, type, argMap, guard, fallback) {
+function walkTypeOf(graph, fileGraph, type, argMap, guard, fallback, position) {
   if (guard.pushNode(type) === "cycle") {
     return [indeterminateTerminal()];
   }
@@ -95030,17 +95525,27 @@ function walkTypeOf(graph, fileGraph, type, argMap, guard, fallback) {
       return foldLeaf(graph, fileGraph, type, argMap, guard, fallback);
     }
     const innerGraph = resolved.kind === "Function" ? fileGraphForFunction(graph, fileGraph, resolved) : fileGraph;
-    const inner = walkInner(graph, innerGraph, resolved, argMap, guard, fallback);
+    const inner = walkInner(graph, innerGraph, resolved, argMap, guard, fallback, position);
     if (inner.every((t3) => t3.identity !== null))
       return inner;
-    const self2 = resolved.kind !== "ParameterOf" && evalKind(resolved, graph, innerGraph, argMap) === "component" ? deriveIdentity(type, fileGraph, graph) : null;
+    const derived = position === "tag" && inner.some((t3) => t3.identity === null && isCallable(t3)) || resolved.kind !== "ParameterOf" && evalKind(resolved, graph, innerGraph, argMap) === "component" ? deriveIdentity(type, fileGraph, graph) : null;
+    const self2 = position === "tag" ? withOwnDeclaration(derived, graph, fileGraph, type.ref) : derived;
     const stamp = self2 ?? deriveIdentity(fallback, fileGraph, graph);
     return inner.map((t3) => t3.identity === null ? { denotation: t3.denotation, viaTrail: t3.viaTrail, identity: stamp, semantics: t3.semantics } : t3);
   } finally {
     guard.popNode(type);
   }
 }
-function walkStaticMember(graph, fileGraph, type, argMap, guard, fallback) {
+function withOwnDeclaration(identity, graph, fileGraph, ref) {
+  if (identity === null || identity.kind !== "local" || ref.memberChain.length > 0)
+    return identity;
+  const lookup2 = fileGraphForRef(graph, ref, fileGraph);
+  if (identity.filePath !== lookup2.filePath || lookup2.importsByLocal.has(ref.symbol))
+    return identity;
+  const declaration2 = findLocalDeclaration(lookup2, ref);
+  return declaration2 === null ? identity : { ...identity, declaration: declaration2 };
+}
+function walkStaticMember(graph, fileGraph, type, argMap, guard, fallback, position) {
   if (guard.pushNode(type) === "cycle") {
     return [indeterminateTerminal()];
   }
@@ -95051,7 +95556,7 @@ function walkStaticMember(graph, fileGraph, type, argMap, guard, fallback) {
       const leaf = foldLeaf(graph, fileGraph, type, argMap, guard, fallback);
       if (!(leaf.length > 0 && leaf.every(cameToNothing)))
         return leaf;
-      const object = walkInner(graph, fileGraph, type.obj, argMap, guard);
+      const object = walkInner(graph, fileGraph, type.obj, argMap, guard, void 0, "value");
       const semantics = markedProduct(object);
       if (semantics !== null)
         return leaf.map((t3) => withSemantics(t3, semantics));
@@ -95062,36 +95567,24 @@ function walkStaticMember(graph, fileGraph, type, argMap, guard, fallback) {
       const value = obj.props[type.member];
       if (value === void 0)
         continue;
-      out2.push(...walkInner(graph, fileGraph, value, argMap, guard, fallback));
+      out2.push(...walkInner(graph, fileGraph, value, argMap, guard, fallback, position));
     }
     return out2.length > 0 ? out2 : [indeterminateTerminal()];
   } finally {
     guard.popNode(type);
   }
 }
-function walkReturnTypeOf(graph, fileGraph, type, argMap, guard) {
-  const returns = foldCall(graph, fileGraph, type, argMap, guard).map(returnedValue);
-  if (creditedTerminals(returns).length === 0) {
-    const semantics = nonComponentProduct(graph, fileGraph, type.callee, guard);
-    if (semantics !== null)
-      return returns.map((t3) => withSemantics(t3, semantics));
-  }
+function walkReturnTypeOf(graph, fileGraph, type, argMap, guard, position) {
+  const semantics = nonComponentProduct(graph, fileGraph, type.callee, guard);
+  if (semantics !== null)
+    return [withSemantics(indeterminateTerminal(), semantics)];
+  const returns = foldCall(graph, fileGraph, type, argMap, guard, position).map(returnedValue);
   if (!(returns.length > 0 && returns.every(cameToNothing)))
     return returns;
   const unseenHook = HOOK_NAME.test(deriveHocCallee(type.callee)) && isImportBackedLeaf(type.callee, graph, fileGraph, guard);
   return unseenHook ? returns.map(asLateBound("hook-result")) : returns;
 }
-function nonComponentProduct(graph, fileGraph, callee, guard) {
-  const ref = callee.kind === "TypeOf" ? callee.ref : callee.kind === "MemberOf" && callee.obj.kind === "TypeOf" ? { ...callee.obj.ref, memberChain: [callee.member] } : null;
-  if (ref === null)
-    return null;
-  const imp = fileGraphForRef(graph, ref, fileGraph).importsByLocal.get(ref.symbol);
-  const entry = imp === void 0 ? null : libraryExportFor(imp, ref);
-  if (entry === null || entry.kind !== "non-component-product")
-    return null;
-  return isImportBackedLeaf(callee, graph, fileGraph, guard) ? entry.semantics : null;
-}
-function foldCall(graph, fileGraph, type, argMap, guard) {
+function foldCall(graph, fileGraph, type, argMap, guard, position) {
   const lazyShape = findLazyImportArg(type.args, fileGraph);
   if (lazyShape) {
     const syntheticDI = {
@@ -95107,7 +95600,7 @@ function foldCall(graph, fileGraph, type, argMap, guard) {
     let inner2;
     try {
       const target = resolveDynamicImportTarget(graph, fileGraph, syntheticDI, guard);
-      inner2 = target ? walkInner(graph, target.targetFileGraph, target.value, argMap, guard) : walkInner(graph, fileGraph, syntheticDI, argMap, guard);
+      inner2 = target ? walkInner(graph, target.targetFileGraph, target.value, argMap, guard, void 0, position) : walkInner(graph, fileGraph, syntheticDI, argMap, guard, void 0, position);
     } finally {
       guard.pop(syntheticDI.originFile, guardKey);
     }
@@ -95130,14 +95623,14 @@ function foldCall(graph, fileGraph, type, argMap, guard) {
     }
     return [{ denotation: { kind: "foreign" }, viaTrail: [via], identity }];
   }
-  const dispatcherResult = walkDispatcherReturns(graph, fileGraph, type, argMap, guard);
+  const dispatcherResult = walkDispatcherReturns(graph, fileGraph, type, argMap, guard, position);
   if (dispatcherResult)
     return dispatcherResult;
   const passThroughIndex = passThroughParameterIndex(graph, fileGraph, type, argMap, guard);
   if (passThroughIndex !== null) {
     const wrapped = type.args[passThroughIndex];
     if (wrapped !== void 0) {
-      const inner2 = walkInner(graph, fileGraph, wrapped, argMap, guard);
+      const inner2 = walkInner(graph, fileGraph, wrapped, argMap, guard, void 0, position);
       return foldToWrappedArg(inner2, buildHocVia(type, wrapped, fileGraph));
     }
   }
@@ -95146,7 +95639,7 @@ function foldCall(graph, fileGraph, type, argMap, guard) {
   if (algHasNonUnknown) {
     const lastArg2 = type.args.at(-1);
     if (lastArg2 !== void 0) {
-      const inner2 = walkInner(graph, fileGraph, lastArg2, argMap, guard);
+      const inner2 = walkInner(graph, fileGraph, lastArg2, argMap, guard, void 0, position);
       if (isPassThroughWrapper(algResult, inner2)) {
         const via = buildHocVia(type, lastArg2, fileGraph);
         return inner2.filter((t3) => !cameToNothing(t3)).map((t3) => ({ denotation: t3.denotation, viaTrail: [via, ...t3.viaTrail], identity: t3.identity }));
@@ -95158,8 +95651,10 @@ function foldCall(graph, fileGraph, type, argMap, guard) {
   if (lastArg === void 0) {
     return [indeterminateTerminal()];
   }
-  const inner = walkInner(graph, fileGraph, lastArg, argMap, guard);
-  if (isDataMethodRenderCall(type, graph, fileGraph, guard)) {
+  const dataMethod = isDataMethodRenderCall(type, graph, fileGraph, guard);
+  const called = dataMethod || isLoader(lastArg, graph, fileGraph, guard);
+  const inner = walkInner(graph, fileGraph, lastArg, argMap, guard, void 0, called ? "value" : position);
+  if (dataMethod) {
     const nonUnknown = inner.filter((t3) => !cameToNothing(t3));
     if (nonUnknown.length > 0) {
       return nonUnknown.map((t3) => ({ denotation: t3.denotation, viaTrail: t3.viaTrail, identity: null }));
@@ -95190,7 +95685,7 @@ function passThroughParameterIndex(graph, fileGraph, type, argMap, guard) {
   }
   return index;
 }
-function walkDispatcherReturns(graph, fileGraph, type, argMap, guard) {
+function walkDispatcherReturns(graph, fileGraph, type, argMap, guard, position) {
   const calleeFns = resolveToFunctions(graph, fileGraph, type.callee, argMap, guard);
   const hasDispatcher = calleeFns.some(({ fn }) => fn.kind === "Function" && fn.returns.some(isDynamicMemberReturn));
   if (!hasDispatcher)
@@ -95204,7 +95699,7 @@ function walkDispatcherReturns(graph, fileGraph, type, argMap, guard) {
       argMap.bind(bindingRef, type.args);
     try {
       for (const ret of fn.returns) {
-        folded.push(...walkInner(graph, fnFileGraph, ret, argMap, guard));
+        folded.push(...walkInner(graph, fnFileGraph, ret, argMap, guard, void 0, position));
       }
     } finally {
       if (bindingRef)
@@ -95267,7 +95762,7 @@ function findFirstDynamicImport(t3, fileGraph, depthBudget) {
   }
   return null;
 }
-function walkDynamicMember(graph, fileGraph, type, argMap, guard) {
+function walkDynamicMember(graph, fileGraph, type, argMap, guard, position) {
   if (guard.pushNode(type) === "cycle") {
     return [indeterminateTerminal()];
   }
@@ -95285,7 +95780,7 @@ function walkDynamicMember(graph, fileGraph, type, argMap, guard) {
         column: mapBinding?.loc.column ?? 0
       };
       for (const propValue of Object.values(obj.props)) {
-        const inner = walkInner(graph, fileGraph, propValue, argMap, guard);
+        const inner = walkInner(graph, fileGraph, propValue, argMap, guard, void 0, position);
         const via = { kind: "dynamic-map", mapName, mapLoc };
         for (const t3 of inner) {
           if (cameToNothing(t3))
@@ -95708,236 +96203,6 @@ function resolveToFunctionsInner(graph, fileGraph, type, argMap, guard) {
 // ../reference-graph/dist/engine/index.js
 import { asTagName, computeOccurrenceId, serialiseComponentId, projectPropUsages, parseCompoundExport as parseCompoundExport2 } from "@component-compass/plugin-core";
 
-// ../reference-graph/dist/engine/helper-callers.js
-function findLocalDeclaration(fileGraph, ref) {
-  let scope = ref.scope;
-  while (true) {
-    const decl = fileGraph.declarations.get(`${scope}::${ref.symbol}`);
-    if (decl)
-      return decl;
-    if (scope === MODULE_SCOPE)
-      return null;
-    const parent = fileGraph.scopes.get(scope)?.parent;
-    if (parent === null || parent === void 0)
-      return null;
-    scope = parent;
-  }
-}
-function classifyDeclaration(decl, registry, fileGraph) {
-  if (decl.value.kind !== "Function" && decl.value.kind !== "ReturnTypeOf")
-    return "unknown";
-  if (fileGraph.dialect === "vue" && isSfcDeclaration(fileGraph, decl))
-    return "component";
-  return registry.hasLocal(fileGraph.filePath, decl.symbol) ? "component" : "helper";
-}
-var isSfcDeclaration = (fileGraph, decl) => fileGraph.exports.some((e) => e.kind === "default" && "local" in e && e.local === decl.symbol);
-function buildHelperCallers(graph, registry) {
-  const index = /* @__PURE__ */ new Map();
-  const callerKeysByHelper = /* @__PURE__ */ new Map();
-  const classificationCache = /* @__PURE__ */ new Map();
-  const refResolutionCache = /* @__PURE__ */ new Map();
-  function resolveRefCached(ref, callerFile, callerGraph) {
-    const key = `${callerFile}::${ref.symbol}`;
-    if (refResolutionCache.has(key)) {
-      return refResolutionCache.get(key) ?? null;
-    }
-    const result2 = resolveRefToDecl(ref, callerFile, callerGraph, graph);
-    refResolutionCache.set(key, result2);
-    return result2;
-  }
-  const pendingValueRefs = [];
-  for (const [file, fileGraph] of graph.files) {
-    for (const decl of fileGraph.declarations.values()) {
-      if (decl.scope !== MODULE_SCOPE)
-        continue;
-      const refs = [];
-      if (decl.value.kind === "Function") {
-        for (const r2 of decl.value.returns)
-          collectRefsInType(r2, refs);
-      } else if (decl.value.kind === "ReturnTypeOf") {
-        collectCalleeRefs(decl.value, refs);
-      }
-      for (const bc of fileGraph.bodyCalls) {
-        if (bc.ownerSymbol === decl.symbol)
-          refs.push(bc.callee);
-      }
-      const callerKey = { file, symbol: decl.symbol };
-      for (const ref of refs) {
-        const target = resolveRefCached(ref, file, fileGraph);
-        if (!target)
-          continue;
-        pendingValueRefs.push({ target, caller: callerKey });
-      }
-    }
-  }
-  const pendingJsxCalls = [];
-  for (const [file, fileGraph] of graph.files) {
-    for (let i2 = 0; i2 < fileGraph.jsxUsages.length; i2++) {
-      const usage = fileGraph.jsxUsages[i2];
-      if (!usage)
-        continue;
-      const target = resolveRefCached(usage.ref, file, fileGraph);
-      if (!target)
-        continue;
-      const ownership = fileGraph.ownership[i2];
-      if (!ownership?.ownerSymbolRef)
-        continue;
-      const callerTarget = resolveRefCached(ownership.ownerSymbolRef, file, fileGraph);
-      if (!callerTarget)
-        continue;
-      if (callerTarget.decl.scope !== MODULE_SCOPE)
-        continue;
-      pendingJsxCalls.push({
-        target,
-        caller: { file: callerTarget.file, symbol: callerTarget.decl.symbol }
-      });
-    }
-  }
-  function classifyKey(file, decl) {
-    const key = `${file}::${decl.symbol}`;
-    const hit = classificationCache.get(key);
-    if (hit !== void 0)
-      return hit;
-    const fileGraph = graph.files.get(file);
-    const result2 = fileGraph ? classifyDeclaration(decl, registry, fileGraph) : "unknown";
-    classificationCache.set(key, result2);
-    return result2;
-  }
-  for (const [file, fileGraph] of graph.files) {
-    for (const decl of fileGraph.declarations.values()) {
-      if (decl.scope !== MODULE_SCOPE)
-        continue;
-      if (decl.value.kind !== "Function" && decl.value.kind !== "ReturnTypeOf")
-        continue;
-      classifyKey(file, decl);
-    }
-  }
-  function recordCallerEdge(target, callerKey) {
-    const keyStr = `${target.file}::${target.decl.symbol}`;
-    const callerKeyStr = `${callerKey.file}::${callerKey.symbol}`;
-    let seen2 = callerKeysByHelper.get(keyStr);
-    if (!seen2) {
-      seen2 = /* @__PURE__ */ new Set();
-      callerKeysByHelper.set(keyStr, seen2);
-    }
-    if (seen2.has(callerKeyStr))
-      return;
-    seen2.add(callerKeyStr);
-    let callers = index.get(keyStr);
-    if (!callers) {
-      callers = /* @__PURE__ */ new Set();
-      index.set(keyStr, callers);
-    }
-    callers.add(callerKey);
-  }
-  for (const { target, caller } of pendingValueRefs) {
-    if (classifyKey(target.file, target.decl) !== "helper")
-      continue;
-    recordCallerEdge(target, caller);
-  }
-  for (const { target, caller } of pendingJsxCalls) {
-    if (classifyKey(target.file, target.decl) !== "helper")
-      continue;
-    recordCallerEdge(target, caller);
-  }
-  return {
-    get(key) {
-      return index.get(`${key.file}::${key.symbol}`);
-    },
-    classification(file, symbol2) {
-      return classificationCache.get(`${file}::${symbol2}`) ?? "unknown";
-    }
-  };
-}
-function collectCalleeRefs(t3, out2) {
-  switch (t3.kind) {
-    case "ReturnTypeOf":
-      collectCalleeRefs(t3.callee, out2);
-      return;
-    case "MemberOf":
-      collectCalleeRefs(t3.obj, out2);
-      return;
-    case "TypeOf":
-      out2.push(t3.ref);
-      return;
-    default:
-      return;
-  }
-}
-function collectRefsInType(t3, out2) {
-  switch (t3.kind) {
-    case "TypeOf":
-      out2.push(t3.ref);
-      return;
-    case "Union":
-      for (const u3 of t3.types)
-        collectRefsInType(u3, out2);
-      return;
-    case "ReturnTypeOf":
-      collectRefsInType(t3.callee, out2);
-      for (const a3 of t3.args)
-        collectRefsInType(a3, out2);
-      return;
-    case "Function":
-      for (const r2 of t3.returns)
-        collectRefsInType(r2, out2);
-      return;
-    case "Object":
-      for (const v of Object.values(t3.props))
-        collectRefsInType(v, out2);
-      return;
-    case "Array":
-      for (const e of t3.elements)
-        collectRefsInType(e, out2);
-      return;
-    case "MemberOf":
-      collectRefsInType(t3.obj, out2);
-      return;
-    case "ParameterOf":
-      return;
-    default:
-      return;
-  }
-}
-function resolveRefToDecl(ref, callerFile, callerGraph, graph) {
-  const localKey = `${MODULE_SCOPE}::${ref.symbol}`;
-  const localDecl = callerGraph.declarations.get(localKey);
-  if (localDecl)
-    return { file: callerFile, decl: localDecl };
-  const imp = callerGraph.importsByLocal.get(ref.symbol);
-  if (!imp)
-    return null;
-  const resolvedAbs = graph.moduleResolver(callerFile, imp.specifier);
-  if (!resolvedAbs)
-    return null;
-  const targetFile = graph.resolveToGraphKey ? graph.resolveToGraphKey(resolvedAbs) ?? resolvedAbs : resolvedAbs;
-  const targetGraph = graph.files.get(targetFile);
-  if (!targetGraph)
-    return null;
-  const chained = followReExportChain(graph, targetFile, imp.imported);
-  if (chained) {
-    const chainedGraph = graph.files.get(chained.file);
-    if (chainedGraph) {
-      const decl = chainedGraph.declarations.get(`${MODULE_SCOPE}::${chained.localExport}`);
-      if (decl)
-        return { file: chained.file, decl };
-    }
-  }
-  for (const exp of targetGraph.exports) {
-    if (exp.kind === "named" && "local" in exp && exp.exportedAs === imp.imported) {
-      const decl = targetGraph.declarations.get(`${MODULE_SCOPE}::${exp.local}`);
-      if (decl)
-        return { file: targetFile, decl };
-    }
-    if (exp.kind === "default" && "local" in exp && imp.imported === "default") {
-      const decl = targetGraph.declarations.get(`${MODULE_SCOPE}::${exp.local}`);
-      if (decl)
-        return { file: targetFile, decl };
-    }
-  }
-  return null;
-}
-
 // ../reference-graph/dist/engine/owner-resolution.js
 function resolveOwnerChain(ownerRef, graph, helperIndex, guard) {
   if (!ownerRef)
@@ -95996,12 +96261,28 @@ function narrowTo(registry, entries) {
   }
   return {
     hasLocal: (filePath, exportName) => survivingNames.has(entryKey(filePath, exportName)),
-    isComponentShaped: (filePath, exportName) => registry.isComponentShaped(filePath, exportName),
+    isComponent: (filePath, name, declaration2) => registry.isComponent(filePath, name, declaration2),
     declarationOf: (filePath, exportName) => registry.declarationOf(filePath, exportName),
+    isRenderedAsTag: (entry) => registry.isRenderedAsTag(entry),
+    isTagged: (filePath, name, declaration2) => registry.isTagged(filePath, name, declaration2),
     localEntries: () => entries
   };
 }
-function buildComponentRegistry(graph) {
+var CAN_HOLD_A_FUNCTION = {
+  TypeOf: true,
+  Function: true,
+  ReturnTypeOf: true,
+  ParameterOf: false,
+  MemberOf: true,
+  Union: true,
+  Object: false,
+  Array: false,
+  JSX: false,
+  Str: false,
+  Unknown: false,
+  DynamicImport: true
+};
+function buildComponentRegistry(graph, tagged = []) {
   const consumed = /* @__PURE__ */ new Set();
   for (const [file, fg] of graph.files) {
     for (const exp of fg.exports) {
@@ -96023,16 +96304,35 @@ function buildComponentRegistry(graph) {
         consumed.add(entryKey(target.file, target.symbol));
     }
   }
+  const taggedDeclaration = (filePath, name, declaration2) => {
+    const fg = graph.files.get(filePath);
+    if (fg === void 0)
+      return void 0;
+    if (declaration2 !== void 0)
+      return declaration2;
+    const named = findDeclaration(fg, name);
+    return named !== void 0 && CAN_HOLD_A_FUNCTION[named.value.kind] ? named : void 0;
+  };
+  const renderedAsTag = /* @__PURE__ */ new Set();
+  for (const { filePath, exportName, declaration: declaration2 } of tagged) {
+    const marked = taggedDeclaration(filePath, exportName, declaration2);
+    if (marked !== void 0)
+      renderedAsTag.add(marked);
+  }
+  const isTagged = (filePath, name, declaration2) => {
+    const marked = taggedDeclaration(filePath, name, declaration2);
+    return marked !== void 0 && renderedAsTag.has(marked);
+  };
   const byKey = /* @__PURE__ */ new Map();
   const entryIndex = /* @__PURE__ */ new Map();
   const entries = [];
+  const taggedEntries = /* @__PURE__ */ new Set();
   for (const [file, fg] of graph.files) {
     if (fg.dialect === "vue")
       continue;
     for (const decl of fg.declarations.values()) {
-      if (!consumed.has(entryKey(file, decl.symbol)))
-        continue;
-      if (!isAdmittedShape(decl.value, graph, fg))
+      const symbolKey = entryKey(file, decl.symbol);
+      if (!renderedAsTag.has(decl) && !(consumed.has(symbolKey) && isAdmittedShape(decl.value, graph, fg)))
         continue;
       const exportName = decl.exportedAs ?? decl.symbol;
       const entry = {
@@ -96043,6 +96343,8 @@ function buildComponentRegistry(graph) {
         loc: decl.loc,
         isDefault: decl.symbol === "default" || fg.exports.some((e) => e.kind === "default" && "local" in e && e.local === decl.symbol)
       };
+      if (renderedAsTag.has(decl))
+        taggedEntries.add(declarationKey(entry));
       const key = entryKey(file, exportName);
       if (!byKey.has(key)) {
         entryIndex.set(key, entries.length);
@@ -96056,20 +96358,28 @@ function buildComponentRegistry(graph) {
       byKey.set(key, entry);
     }
   }
-  const shapeCache = /* @__PURE__ */ new Map();
-  const isComponentShaped2 = (filePath, exportName) => {
-    const cacheKey = entryKey(filePath, exportName);
-    const cached = shapeCache.get(cacheKey);
+  const judge = (fg, name, declaration2) => {
+    const { root: root2, path: path5 } = parseCompoundExport(name);
+    const decl = declaration2 ?? findDeclaration(fg, root2);
+    if (decl === void 0)
+      return false;
+    if (path5.length > 0)
+      return isAdmittedMember(decl.value, path5, graph, fg);
+    return isAdmittedShape(decl.value, graph, fg) || renderedAsTag.has(decl);
+  };
+  const judgedByName = /* @__PURE__ */ new Map();
+  const isComponent2 = (filePath, name, declaration2) => {
+    const fg = graph.files.get(filePath);
+    if (fg === void 0 || fg.dialect === "vue")
+      return false;
+    if (declaration2 !== void 0)
+      return judge(fg, name, declaration2);
+    const cacheKey = entryKey(filePath, name);
+    const cached = judgedByName.get(cacheKey);
     if (cached !== void 0)
       return cached;
-    const fg = graph.files.get(filePath);
-    let result2 = false;
-    if (fg && fg.dialect !== "vue") {
-      const { root: root2, path: path5 } = parseCompoundExport(exportName);
-      const decl = findDeclaration(fg, root2);
-      result2 = decl !== void 0 && (path5.length === 0 ? isAdmittedShape(decl.value, graph, fg) : isAdmittedMember(decl.value, path5, graph, fg));
-    }
-    shapeCache.set(cacheKey, result2);
+    const result2 = judge(fg, name, void 0);
+    judgedByName.set(cacheKey, result2);
     return result2;
   };
   const declarationOf = (filePath, exportName) => {
@@ -96086,11 +96396,16 @@ function buildComponentRegistry(graph) {
   };
   return {
     hasLocal: (filePath, exportName) => byKey.has(entryKey(filePath, exportName)),
-    isComponentShaped: isComponentShaped2,
+    isComponent: isComponent2,
     declarationOf,
+    isRenderedAsTag: (entry) => taggedEntries.has(declarationKey(entry)),
+    isTagged,
     localEntries: () => entries
   };
 }
+function declarationKey(entry) {
+  return `${entryKey(entry.filePath, entry.symbol)}@${entry.loc.line}:${entry.loc.column}`;
+}
 function excludeFoldedHolders(registry, folded) {
   if (folded.size === 0)
     return registry;
@@ -96098,7 +96413,7 @@ function excludeFoldedHolders(registry, folded) {
   const survivors = [];
   for (const entry of registry.localEntries()) {
     const holder = folded.get(entryKey(entry.filePath, entry.symbol));
-    if (holder === void 0) {
+    if (holder === void 0 || registry.isRenderedAsTag(entry)) {
       survivors.push(entry);
       continue;
     }
@@ -96124,16 +96439,8 @@ function isAdmittedShape(value, graph, fg) {
   return Object.values(value.props).some((prop) => evalKind(prop, graph, fg) === "component");
 }
 function isAdmittedMember(holder, path5, graph, fg) {
-  let cur = holder;
-  for (const segment of path5) {
-    if (cur.kind !== "Object")
-      return false;
-    const next = cur.props[segment];
-    if (next === void 0)
-      return false;
-    cur = next;
-  }
-  return isAdmittedShape(cur, graph, fg);
+  const member = memberOfObjectPath(holder, path5);
+  return member !== void 0 && isAdmittedShape(member, graph, fg);
 }
 function findDeclaration(fg, name) {
   const atModuleScope = fg.declarations.get(`${MODULE_SCOPE}::${name}`);
@@ -96164,7 +96471,11 @@ function isHostElementRoot(ref) {
 function resolve5(graph, opts) {
   const occurrences = [];
   const argMap = createArgumentMap();
-  const registry = buildComponentRegistry(graph);
+  const tagEvaluations = /* @__PURE__ */ new Map();
+  for (const [filePath, fileGraph] of graph.files) {
+    tagEvaluations.set(filePath, fileGraph.jsxUsages.map((usage) => evaluateJsxUsage(graph, filePath, fileGraph, usage, argMap)));
+  }
+  const registry = buildComponentRegistry(graph, taggedDeclarations(graph, tagEvaluations));
   const helperIndex = buildHelperCallers(graph, excludeHostElementNames(registry, graph));
   const CODE_EXT = /\.(?:[cm]?[jt]sx?|vue)$/i;
   const HAS_EXT = /\.[^./\\]+$/;
@@ -96172,12 +96483,9 @@ function resolve5(graph, opts) {
     if (id2.kind !== "react-component" || id2.source.type !== "local")
       return true;
     const { filePath } = id2.source;
-    const declaring = graph.files.get(filePath);
-    if (declaring === void 0)
-      return !HAS_EXT.test(filePath) || CODE_EXT.test(filePath);
-    if (declaring.dialect === "vue")
+    if (graph.files.has(filePath))
       return true;
-    return registry.isComponentShaped(filePath, id2.export);
+    return !HAS_EXT.test(filePath) || CODE_EXT.test(filePath);
   };
   const composition = [];
   const compactSlice = (lengthBefore) => {
@@ -96207,119 +96515,21 @@ function resolve5(graph, opts) {
     }
     return occurrences.length - lengthBefore;
   };
-  const pushJsxUsageOccurrences = (filePath, fileGraph, usage, ownership) => {
-    const ownerRef = ownership?.ownerSymbolRef ?? null;
-    const viaOverride = ownership?.viaOverride;
-    const matchedImport = fileGraph.importsByLocal.get(usage.ref.symbol);
-    if (!matchedImport) {
-      const decl = findLocalDeclaration(fileGraph, usage.ref);
-      if (!decl)
-        return { kind: "unbound" };
-      return {
-        kind: "evaluated",
-        ...pushLocalOccurrence(occurrences, filePath, usage, decl, graph, fileGraph, argMap, ownerRef, helperIndex, opts, viaOverride)
-      };
-    }
-    const packageName = packageNameFromSpecifier(matchedImport.specifier);
-    const effectiveImported = effectiveExportName(matchedImport.imported, usage.ref.memberChain);
-    const residual = residualMemberChain(matchedImport.imported, usage.ref.memberChain);
-    const holderDefinition = (file, exportName) => {
-      if (residual.length === 0)
-        return void 0;
-      const loc = graph.files.get(file)?.declarations.get(`${MODULE_SCOPE}::${exportName}`)?.loc;
-      return loc === void 0 ? void 0 : { line: loc.line, column: loc.column };
-    };
-    if (!packageName) {
-      const resolvedAbsTarget2 = graph.moduleResolver(filePath, matchedImport.specifier);
-      if (!resolvedAbsTarget2)
-        return { kind: "import-failed", specifier: matchedImport.specifier };
-      const resolvedTarget = graph.resolveToGraphKey ? graph.resolveToGraphKey(resolvedAbsTarget2) ?? resolvedAbsTarget2 : resolvedAbsTarget2;
-      const refType = resolveReference(graph, fileGraph, usage.ref);
-      const evaluation = walkWithFolding(graph, fileGraph, refType, argMap);
-      const jsxTerminals = creditedTerminals(evaluation);
-      if (jsxTerminals.length === 0)
-        return { kind: "evaluated", evaluation, value: refType };
-      const chained = followReExportChain(graph, resolvedTarget, effectiveImported);
-      const canonicalFile = chained?.file ?? resolvedTarget;
-      let exportName = chained?.localExport ?? effectiveImported;
-      if (!chained) {
-        const targetGraph = graph.files.get(resolvedTarget);
-        if (targetGraph && effectiveImported === "default") {
-          const defaultExp = targetGraph.exports.find((e) => e.kind === "default");
-          if (defaultExp && "local" in defaultExp) {
-            exportName = defaultExp.local;
-          }
-        } else if (targetGraph) {
-          const namedExp = targetGraph.exports.find((e) => e.kind === "named" && "exportedAs" in e && e.exportedAs === effectiveImported && "local" in e);
-          if (namedExp && "local" in namedExp) {
-            exportName = namedExp.local;
-          }
-        }
-      }
-      const outerVia = viaOverride ?? {
-        kind: "direct-import",
-        specifier: matchedImport.specifier,
-        import: matchedImport.imported
-      };
-      const fallbackComponentId = {
-        kind: componentKindFor(fileGraph.dialect),
-        export: compoundExportName(exportName, residual),
-        source: { type: "local", filePath: canonicalFile }
-      };
-      const site = usageSite(filePath, usage);
-      const owners = usageOwners(graph, helperIndex, ownerRef, viaOverride, fileGraph.filePath);
-      const definition = holderDefinition(canonicalFile, exportName);
-      for (const ft of jsxTerminals) {
-        const rawComponentId = componentIdFromIdentity(ft.identity, fallbackComponentId, fileGraph.dialect, {
-          filePath,
-          resolveExternalLeaf: opts?.resolveExternalLeaf
-        });
-        emitOccurrence(occurrences, site, rawComponentId, owners, viaOverride !== void 0 ? [viaOverride] : [outerVia, ...ft.viaTrail], ft.identity === null ? definition : void 0);
-      }
-      return { kind: "evaluated", evaluation, value: refType };
-    }
-    const resolvedAbsTarget = graph.moduleResolver(filePath, matchedImport.specifier);
-    const resolvedNormTarget = resolvedAbsTarget !== null && graph.resolveToGraphKey ? graph.resolveToGraphKey(resolvedAbsTarget) ?? resolvedAbsTarget : resolvedAbsTarget;
-    const targetInGraph = resolvedNormTarget !== null && graph.files.has(resolvedNormTarget);
-    if (targetInGraph) {
-      const refType = resolveReference(graph, fileGraph, usage.ref);
-      const evaluation = walkWithFolding(graph, fileGraph, refType, argMap);
-      const jsxTerminals = creditedTerminals(evaluation);
-      if (jsxTerminals.length === 0)
-        return { kind: "evaluated", evaluation, value: refType };
-      const siblingFallback = workspaceSiblingFallback(graph, resolvedNormTarget, matchedImport, effectiveImported, fileGraph.dialect);
-      const localFallback = siblingFallback !== void 0 && siblingFallback.kind !== "custom-element" ? { ...siblingFallback, export: compoundExportName(siblingFallback.export, residual) } : siblingFallback;
-      const definition = siblingFallback !== void 0 && siblingFallback.kind !== "custom-element" && siblingFallback.source.type === "local" ? holderDefinition(siblingFallback.source.filePath, siblingFallback.export) : void 0;
-      for (const ft of jsxTerminals) {
-        pushOccurrence(occurrences, filePath, usage, matchedImport, compoundExportName(effectiveImported, residual), packageName, graph, fileGraph, ft, ownerRef, helperIndex, opts, localFallback, viaOverride, ft.identity === null ? definition : void 0);
-      }
-      return { kind: "evaluated", evaluation, value: refType };
-    }
-    const member = resolvedAbsTarget !== null ? unparsedMemberDefinition(graph, resolvedAbsTarget, effectiveImported) : null;
-    const sentinelFt = { denotation: { kind: "foreign" }, viaTrail: [], identity: null };
-    if (member !== null) {
-      const localFallback = {
-        kind: componentKindFor(fileGraph.dialect),
-        export: compoundExportName(member.exportName, residual),
-        source: { type: "local", filePath: member.absFile }
-      };
-      pushOccurrence(occurrences, filePath, usage, matchedImport, compoundExportName(effectiveImported, residual), packageName, graph, fileGraph, sentinelFt, ownerRef, helperIndex, opts, localFallback, viaOverride);
-    } else {
-      pushOccurrence(occurrences, filePath, usage, matchedImport, compoundExportName(effectiveImported, residual), packageName, graph, fileGraph, sentinelFt, ownerRef, helperIndex, opts, void 0, viaOverride);
-    }
-    return { kind: "evaluated", evaluation: [sentinelFt], value: null };
-  };
   for (const [filePath, fileGraph] of graph.files) {
+    const evaluations = tagEvaluations.get(filePath) ?? [];
     for (let usageIdx = 0; usageIdx < fileGraph.jsxUsages.length; usageIdx++) {
       const usage = fileGraph.jsxUsages[usageIdx];
-      if (!usage)
+      const evaluated = evaluations[usageIdx];
+      if (!usage || !evaluated)
         continue;
       const ownership = fileGraph.ownership[usageIdx];
       const lengthBefore = occurrences.length;
-      const outcome = pushJsxUsageOccurrences(filePath, fileGraph, usage, ownership);
+      if (evaluated.kind === "evaluated") {
+        emitTagCredits(occurrences, graph, filePath, fileGraph, usage, ownership, evaluated.credits, helperIndex, registry, opts);
+      }
       const admitted = stampComposition(lengthBefore, "jsx", usageIdx, ownership?.depth ?? 0, ownership?.parentUsageIdx);
       if (admitted === 0)
-        reportDroppedRender(opts, filePath, fileGraph.dialect, usage, outcome);
+        reportDroppedRender(opts, filePath, fileGraph.dialect, usage, evaluated);
     }
     for (let i2 = 0; i2 < fileGraph.tagUsages.length; i2++) {
       const usage = fileGraph.tagUsages[i2];
@@ -96384,7 +96594,7 @@ function resolve5(graph, opts) {
       if (foldedAway !== null)
         folded.set(entryKey(filePath, decl.symbol), foldedAway);
       const lengthBefore = occurrences.length;
-      pushArgumentSiteOccurrences(occurrences, filePath, decl, decl.value, holderJsx, graph, fileGraph, argMap, opts);
+      pushArgumentSiteOccurrences(occurrences, filePath, decl, decl.value, holderJsx, graph, fileGraph, argMap, registry, opts);
       compactSlice(lengthBefore);
     }
   }
@@ -96408,7 +96618,7 @@ function resolve5(graph, opts) {
       };
       const owners = () => chainOwners(graph, helperIndex, ownerRef);
       const lengthBefore = occurrences.length;
-      pushCallArgumentOccurrences(occurrences, filePath, call, owners, graph, fileGraph, argMap, opts);
+      pushCallArgumentOccurrences(occurrences, filePath, call, owners, graph, fileGraph, argMap, registry, opts);
       compactSlice(lengthBefore);
     }
   }
@@ -96572,29 +96782,191 @@ function usageOwners(graph, helperIndex, ownerRef, viaOverride, fallbackFile) {
   }
   return chainOwners(graph, helperIndex, ownerRef);
 }
-function pushOccurrence(occurrences, filePath, usage, matchedImport, effectiveImported, packageName, graph, fileGraph, ft, ownerRef, helperIndex, opts, fallbackOverride, viaOverride, definition) {
-  const fallback = fallbackOverride ?? {
-    kind: componentKindFor(fileGraph.dialect),
-    export: effectiveImported,
-    source: externalSource(packageName, matchedImport.specifier)
+function namesObjectMember(holder, path5) {
+  return path5.length === 0 || memberOfObjectPath(holder, path5) !== void 0;
+}
+function evaluateJsxUsage(graph, filePath, fileGraph, usage, argMap) {
+  if (fileGraph.dialect === "react" && isHostElementRoot(usage.ref))
+    return { kind: "host-element" };
+  const matchedImport = fileGraph.importsByLocal.get(usage.ref.symbol);
+  if (!matchedImport) {
+    const decl = findLocalDeclaration(fileGraph, usage.ref);
+    if (!decl)
+      return { kind: "unbound" };
+    const value = usage.ref.memberChain.length > 0 ? resolveReference(graph, fileGraph, usage.ref) : decl.value;
+    const evaluation = walkWithFolding(graph, fileGraph, value, argMap, createCycleGuard(), void 0, "tag");
+    const fallback2 = {
+      kind: componentKindFor(fileGraph.dialect),
+      export: compoundExportName(usage.ref.symbol, usage.ref.memberChain),
+      source: { type: "local", filePath }
+    };
+    const definition = { line: decl.loc.line, column: decl.loc.column };
+    const outerVia2 = { kind: "local-component" };
+    const rendered = usage.ref.memberChain.length === 0 ? { declaration: decl } : {};
+    const named = namesObjectMember(decl.value, usage.ref.memberChain);
+    const credits = creditedTerminals(evaluation).filter((t3) => t3.identity !== null || named).map((terminal) => ({
+      terminal,
+      fallback: fallback2,
+      outerVia: outerVia2,
+      ...terminal.identity === null ? { definition, ...rendered } : {}
+    }));
+    return { kind: "evaluated", evaluation, value, credits };
+  }
+  const packageName = packageNameFromSpecifier(matchedImport.specifier);
+  const effectiveImported = effectiveExportName(matchedImport.imported, usage.ref.memberChain);
+  const residual = residualMemberChain(matchedImport.imported, usage.ref.memberChain);
+  const holderDecl = (file, exportName) => {
+    const holderFile = graph.files.get(file);
+    return holderFile === void 0 ? void 0 : findDeclaration(holderFile, exportName);
   };
-  const rawComponentId = componentIdFromIdentity(ft.identity, fallback, fileGraph.dialect, {
-    filePath,
-    fallbackSpecifier: matchedImport.specifier,
-    resolveExternalLeaf: opts?.resolveExternalLeaf
-  });
-  const outerVia = viaOverride ?? {
+  const holderDefinition = (file, exportName) => {
+    if (residual.length === 0)
+      return void 0;
+    const loc = holderDecl(file, exportName)?.loc;
+    return loc === void 0 ? void 0 : { line: loc.line, column: loc.column };
+  };
+  const namesHolderMember = (file, exportName) => namesObjectMember(holderDecl(file, exportName)?.value, residual);
+  const outerVia = {
     kind: "direct-import",
     specifier: matchedImport.specifier,
     import: matchedImport.imported
   };
-  emitOccurrence(occurrences, usageSite(filePath, usage), rawComponentId, usageOwners(graph, helperIndex, ownerRef, viaOverride, filePath), viaOverride !== void 0 ? [viaOverride] : [outerVia, ...ft.viaTrail], definition);
+  if (!packageName) {
+    const resolvedAbsTarget2 = graph.moduleResolver(filePath, matchedImport.specifier);
+    if (!resolvedAbsTarget2)
+      return { kind: "import-failed", specifier: matchedImport.specifier };
+    const resolvedTarget = graph.resolveToGraphKey ? graph.resolveToGraphKey(resolvedAbsTarget2) ?? resolvedAbsTarget2 : resolvedAbsTarget2;
+    const refType = resolveReference(graph, fileGraph, usage.ref);
+    const evaluation = walkWithFolding(graph, fileGraph, refType, argMap, createCycleGuard(), void 0, "tag");
+    const jsxTerminals = creditedTerminals(evaluation);
+    if (jsxTerminals.length === 0)
+      return { kind: "evaluated", evaluation, value: refType, credits: [] };
+    const chained = followReExportChain(graph, resolvedTarget, effectiveImported);
+    const canonicalFile = chained?.file ?? resolvedTarget;
+    let exportName = chained?.localExport ?? effectiveImported;
+    if (!chained) {
+      const targetGraph = graph.files.get(resolvedTarget);
+      if (targetGraph && effectiveImported === "default") {
+        const defaultExp = targetGraph.exports.find((e) => e.kind === "default");
+        if (defaultExp && "local" in defaultExp) {
+          exportName = defaultExp.local;
+        }
+      } else if (targetGraph) {
+        const namedExp = targetGraph.exports.find((e) => e.kind === "named" && "exportedAs" in e && e.exportedAs === effectiveImported && "local" in e);
+        if (namedExp && "local" in namedExp) {
+          exportName = namedExp.local;
+        }
+      }
+    }
+    const fallback2 = {
+      kind: componentKindFor(fileGraph.dialect),
+      export: compoundExportName(exportName, residual),
+      source: { type: "local", filePath: canonicalFile }
+    };
+    const definition = holderDefinition(canonicalFile, exportName);
+    const named = namesHolderMember(canonicalFile, exportName);
+    const credits = jsxTerminals.filter((t3) => t3.identity !== null || named).map((terminal) => ({
+      terminal,
+      fallback: fallback2,
+      outerVia,
+      ...terminal.identity === null && definition !== void 0 ? { definition } : {}
+    }));
+    return { kind: "evaluated", evaluation, value: refType, credits };
+  }
+  const externalFallback = {
+    kind: componentKindFor(fileGraph.dialect),
+    export: compoundExportName(effectiveImported, residual),
+    source: externalSource(packageName, matchedImport.specifier)
+  };
+  const resolvedAbsTarget = graph.moduleResolver(filePath, matchedImport.specifier);
+  const resolvedNormTarget = resolvedAbsTarget !== null && graph.resolveToGraphKey ? graph.resolveToGraphKey(resolvedAbsTarget) ?? resolvedAbsTarget : resolvedAbsTarget;
+  const targetInGraph = resolvedNormTarget !== null && graph.files.has(resolvedNormTarget);
+  if (targetInGraph) {
+    const refType = resolveReference(graph, fileGraph, usage.ref);
+    const evaluation = walkWithFolding(graph, fileGraph, refType, argMap, createCycleGuard(), void 0, "tag");
+    const jsxTerminals = creditedTerminals(evaluation);
+    if (jsxTerminals.length === 0)
+      return { kind: "evaluated", evaluation, value: refType, credits: [] };
+    const siblingFallback = workspaceSiblingFallback(graph, resolvedNormTarget, matchedImport, effectiveImported, fileGraph.dialect);
+    const localFallback = siblingFallback !== void 0 && siblingFallback.kind !== "custom-element" ? { ...siblingFallback, export: compoundExportName(siblingFallback.export, residual) } : siblingFallback;
+    const localHolder = siblingFallback !== void 0 && siblingFallback.kind !== "custom-element" && siblingFallback.source.type === "local" ? { filePath: siblingFallback.source.filePath, exportName: siblingFallback.export } : void 0;
+    const definition = localHolder === void 0 ? void 0 : holderDefinition(localHolder.filePath, localHolder.exportName);
+    const named = localHolder === void 0 || namesHolderMember(localHolder.filePath, localHolder.exportName);
+    const fallback2 = localFallback ?? externalFallback;
+    const credits = jsxTerminals.filter((t3) => t3.identity !== null || named).map((terminal) => ({
+      terminal,
+      fallback: fallback2,
+      fallbackSpecifier: matchedImport.specifier,
+      outerVia,
+      ...terminal.identity === null && definition !== void 0 ? { definition } : {}
+    }));
+    return { kind: "evaluated", evaluation, value: refType, credits };
+  }
+  const member = resolvedAbsTarget !== null ? unparsedMemberDefinition(graph, resolvedAbsTarget, effectiveImported) : null;
+  const sentinel = { denotation: { kind: "foreign" }, viaTrail: [], identity: null };
+  const fallback = member !== null ? {
+    kind: componentKindFor(fileGraph.dialect),
+    export: compoundExportName(member.exportName, residual),
+    source: { type: "local", filePath: member.absFile }
+  } : externalFallback;
+  return {
+    kind: "evaluated",
+    evaluation: [sentinel],
+    value: null,
+    credits: [{ terminal: sentinel, fallback, fallbackSpecifier: matchedImport.specifier, outerVia }]
+  };
+}
+function carriedDeclaration(credit) {
+  const { identity } = credit.terminal;
+  if (identity === null)
+    return credit.declaration;
+  return identity.kind === "local" ? identity.declaration : void 0;
+}
+function taggedDeclarations(graph, tagEvaluations) {
+  const tagged = [];
+  for (const [filePath, evaluations] of tagEvaluations) {
+    const dialect = dialectForFile(graph, filePath);
+    for (const evaluated of evaluations) {
+      if (evaluated.kind !== "evaluated")
+        continue;
+      for (const credit of evaluated.credits) {
+        if (!isCallable(credit.terminal))
+          continue;
+        const { identity } = credit.terminal;
+        const id2 = buildComponentId(identity, credit.fallback, dialect);
+        if (id2.kind === "react-component" && id2.source.type === "local") {
+          const declaration2 = carriedDeclaration(credit);
+          tagged.push({ filePath: id2.source.filePath, exportName: id2.export, ...declaration2 !== void 0 ? { declaration: declaration2 } : {} });
+        }
+      }
+    }
+  }
+  return tagged;
+}
+function emitTagCredits(occurrences, graph, filePath, fileGraph, usage, ownership, credits, helperIndex, registry, opts) {
+  if (credits.length === 0)
+    return;
+  const viaOverride = ownership?.viaOverride;
+  const site = usageSite(filePath, usage);
+  const owners = usageOwners(graph, helperIndex, ownership?.ownerSymbolRef ?? null, viaOverride, filePath);
+  for (const credit of credits) {
+    const rawComponentId = componentIdFromIdentity(credit.terminal.identity, credit.fallback, fileGraph.dialect, {
+      filePath,
+      ...credit.fallbackSpecifier !== void 0 ? { fallbackSpecifier: credit.fallbackSpecifier } : {},
+      resolveExternalLeaf: opts?.resolveExternalLeaf
+    });
+    const declaration2 = carriedDeclaration(credit);
+    const stands = isCallable(credit.terminal) ? registryTagged(registry, graph, rawComponentId, declaration2) : registryHolds(registry, graph, rawComponentId, declaration2);
+    if (!stands)
+      continue;
+    emitOccurrence(occurrences, site, rawComponentId, owners, viaOverride !== void 0 ? [viaOverride] : [credit.outerVia, ...credit.terminal.viaTrail], credit.definition);
+  }
 }
 function reportDroppedRender(opts, filePath, dialect, usage, outcome) {
   const collector = opts?.collector;
   if (collector === void 0)
     return;
-  if (isHostElementRoot(usage.ref))
+  if (outcome.kind === "host-element")
     return;
   const at = { filePath, line: usage.loc.line, column: usage.loc.column };
   const positional = { ...at, symbol: usage.ref.symbol, memberChain: [...usage.ref.memberChain] };
@@ -96628,30 +97000,6 @@ function reportDroppedRender(opts, filePath, dialect, usage, outcome) {
   }
   collector.emit({ code: decided.code, severity: "info", ...positional });
 }
-function pushLocalOccurrence(occurrences, filePath, usage, decl, graph, fileGraph, argMap, ownerRef, helperIndex, opts, viaOverride) {
-  const value = usage.ref.memberChain.length > 0 ? resolveReference(graph, fileGraph, usage.ref) : decl.value;
-  const evaluation = walkWithFolding(graph, fileGraph, value, argMap);
-  const jsxTerminals = creditedTerminals(evaluation);
-  if (jsxTerminals.length === 0)
-    return { evaluation, value };
-  const outerVia = viaOverride ?? { kind: "local-component" };
-  const site = usageSite(filePath, usage);
-  const owners = usageOwners(graph, helperIndex, ownerRef, viaOverride, fileGraph.filePath);
-  const fallback = {
-    kind: componentKindFor(fileGraph.dialect),
-    export: compoundExportName(usage.ref.symbol, usage.ref.memberChain),
-    source: { type: "local", filePath }
-  };
-  const definition = { line: decl.loc.line, column: decl.loc.column };
-  for (const ft of jsxTerminals) {
-    const rawComponentId = componentIdFromIdentity(ft.identity, fallback, fileGraph.dialect, {
-      filePath,
-      resolveExternalLeaf: opts?.resolveExternalLeaf
-    });
-    emitOccurrence(occurrences, site, rawComponentId, owners, viaOverride !== void 0 ? [viaOverride] : [outerVia, ...ft.viaTrail], ft.identity === null ? definition : void 0);
-  }
-  return { evaluation, value };
-}
 function foldedHolder(holderJsx, filePath) {
   if (holderJsx.length === 0 || holderJsx.some((t3) => t3.identity === null))
     return null;
@@ -96659,7 +97007,7 @@ function foldedHolder(holderJsx, filePath) {
   const sameFileSingle = first !== void 0 && first !== null && first.kind === "local" && first.filePath === filePath && holderJsx.every((t3) => t3.identity !== null && t3.identity.kind === "local" && t3.identity.filePath === filePath && t3.identity.export === first.export);
   return { target: sameFileSingle ? { filePath, export: first.export } : null };
 }
-function pushArgumentSiteOccurrences(occurrences, filePath, holder, call, holderJsx, graph, fileGraph, argMap, opts, depth = 0) {
+function pushArgumentSiteOccurrences(occurrences, filePath, holder, call, holderJsx, graph, fileGraph, argMap, registry, opts, depth = 0) {
   const shape = callFoldShape(holderJsx);
   if (shape === "wrapper") {
     if (depth >= MAX_ARGUMENT_CALL_DEPTH || !call.args.some((a3) => a3.kind === "ReturnTypeOf"))
@@ -96668,7 +97016,7 @@ function pushArgumentSiteOccurrences(occurrences, filePath, holder, call, holder
     if (folded?.arg.kind !== "ReturnTypeOf")
       return;
     const innerJsx = creditedTerminals(walkWithFolding(graph, fileGraph, folded.arg, argMap));
-    pushArgumentSiteOccurrences(occurrences, filePath, holder, folded.arg, innerJsx, graph, fileGraph, argMap, opts, depth + 1);
+    pushArgumentSiteOccurrences(occurrences, filePath, holder, folded.arg, innerJsx, graph, fileGraph, argMap, registry, opts, depth + 1);
     return;
   }
   if (shape !== "product")
@@ -96681,7 +97029,7 @@ function pushArgumentSiteOccurrences(occurrences, filePath, holder, call, holder
     originFile: filePath
   };
   const rawOwnerComponentId = hasOnlyHostElementNames(holder.symbol, fileGraph) ? void 0 : ownerIdFromRef(graph, holderRef, filePath);
-  pushCallArgumentOccurrences(occurrences, filePath, call, () => [{ rawOwnerComponentId, viaPrefix: [] }], graph, fileGraph, argMap, opts, depth);
+  pushCallArgumentOccurrences(occurrences, filePath, call, () => [{ rawOwnerComponentId, viaPrefix: [] }], graph, fileGraph, argMap, registry, opts, depth);
 }
 var MAX_ARGUMENT_CALL_DEPTH = 2;
 function callFoldShape(jsx) {
@@ -96692,7 +97040,23 @@ function callFoldShape(jsx) {
     return "product";
   return credited === jsx.length ? "wrapper" : null;
 }
-function pushCallArgumentOccurrences(occurrences, filePath, call, owners, graph, fileGraph, argMap, opts, depth = 0) {
+function registryHolds(registry, graph, id2, declaration2) {
+  if (id2.kind === "custom-element" || id2.source.type !== "local")
+    return true;
+  if (graph.files.get(id2.source.filePath)?.dialect !== "react")
+    return true;
+  return registry.isComponent(id2.source.filePath, id2.export, declaration2);
+}
+function registryTagged(registry, graph, id2, declaration2) {
+  if (id2.kind !== "react-component" || id2.source.type !== "local")
+    return true;
+  if (graph.files.get(id2.source.filePath)?.dialect !== "react")
+    return true;
+  if (parseCompoundExport2(id2.export).isCompound)
+    return true;
+  return registry.isTagged(id2.source.filePath, id2.export, declaration2);
+}
+function pushCallArgumentOccurrences(occurrences, filePath, call, owners, graph, fileGraph, argMap, registry, opts, depth = 0) {
   let resolvedOwners;
   const seedIdentifier = (site, index, arg, hops) => {
     if (isHostElementName(arg.ref.symbol))
@@ -96707,6 +97071,8 @@ function pushCallArgumentOccurrences(occurrences, filePath, call, owners, graph,
         filePath,
         resolveExternalLeaf: opts?.resolveExternalLeaf
       });
+      if (!registryHolds(registry, graph, rawComponentId))
+        continue;
       resolvedOwners ??= owners();
       emitOccurrence(occurrences, { filePath, line: arg.ref.loc.line, column: arg.ref.loc.column, props: {}, events: [] }, rawComponentId, resolvedOwners, [outerVia, ...hops, ...ft.viaTrail], argDecl !== null ? { line: argDecl.loc.line, column: argDecl.loc.column } : void 0);
     }
@@ -101807,6 +102173,7 @@ var Logger = class {
 };
 
 // src/commands/scan.ts
+init_upload();
 import { errorMessage as errorMessage2 } from "@component-compass/ast-utils";
 
 // src/seeds.ts
@@ -103112,19 +103479,31 @@ async function runScan(opts) {
       const { createAuthedUploader: createAuthedUploader2 } = await Promise.resolve().then(() => (init_upload_auth(), upload_auth_exports));
       const uploader = await createAuthedUploader2({
         ...opts.hostOverride !== void 0 ? { flagHost: opts.hostOverride } : {},
-        ...cfg.host !== void 0 ? { configHost: cfg.host } : {}
+        ...cfg.host !== void 0 ? { configHost: cfg.host } : {},
+        onStatus: (status) => {
+          if (status.state === "queued" || status.state === "processing" || !status.readable && status.state === "duplicate") {
+            log2.info(`Upload ${status.state}${status.stage ? ` (${status.stage})` : ""}; waiting for publication.`);
+          }
+        }
       });
       const result2 = await uploader.upload(JSON.stringify(scanOutput));
       upload = result2.status === "inserted" ? "ok" : "exists";
+      const scanUrl = new URL(result2.url, uploader.base).href;
       log2.info(
-        result2.status === "inserted" ? `Uploaded scan ${result2.scanId} \u2192 ${uploader.base}${result2.url}` : `Scan ${result2.scanId} already exists at ${uploader.base}${result2.url}; no changes.`
+        result2.status === "inserted" ? `Uploaded scan ${result2.scanId} \u2192 ${scanUrl}` : `Scan ${result2.scanId} already exists at ${scanUrl}; no changes.`
       );
     } catch (err2) {
       upload = "failed";
       const { formatAuthError: formatAuthError2 } = await Promise.resolve().then(() => (init_session(), session_exports));
-      const authMsg = formatAuthError2(err2);
+      const authMsg = formatAuthError2(err2 instanceof UploadPollingError ? err2.cause : err2);
       const msg = authMsg ?? (err2 instanceof Error ? err2.message : String(err2));
-      log2.error(`Upload failed: ${msg}`);
+      if (err2 instanceof UploadPollingError) {
+        const outcome = err2.outcome === "unknown" ? "outcome unknown" : "failed";
+        const continuation = err2.outcome === "unknown" ? " The server job may still be processing or may have completed." : "";
+        log2.error(`Upload ${outcome}: ${msg}. Check upload ${err2.receipt.uploadId} at ${err2.statusUrl}.${continuation}`);
+      } else {
+        log2.error(`Upload ${err2 instanceof UploadPendingError ? "pending" : "failed"}: ${msg}`);
+      }
     }
   }
   return { output: scanOutput, upload };