@component-compass/cli 0.1.24 → 0.1.26

package/dist/cli.js

@@ -40398,7 +40398,7 @@ var require_pattern2 = __commonJS({
       const absolute = [];
       const relative7 = [];
       for (const pattern of patterns) {
-        if (isAbsolute13(pattern)) {
+        if (isAbsolute14(pattern)) {
           absolute.push(pattern);
         } else {
           relative7.push(pattern);
@@ -40407,10 +40407,10 @@ var require_pattern2 = __commonJS({
       return [absolute, relative7];
     }
     exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
-    function isAbsolute13(pattern) {
+    function isAbsolute14(pattern) {
       return path5.isAbsolute(pattern);
     }
-    exports.isAbsolute = isAbsolute13;
+    exports.isAbsolute = isAbsolute14;
   }
 });
 
@@ -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 } : {}
+      });
     }
   };
 }
@@ -45262,7 +45430,7 @@ var init_auth = __esm({
 
 // src/commands/scan.ts
 import { performance as performance3 } from "node:perf_hooks";
-import { isAbsolute as isAbsolute11, relative as relative6, resolve as resolve11 } from "node:path";
+import { isAbsolute as isAbsolute12, relative as relative6, resolve as resolve11 } from "node:path";
 import { readFile as readFile5 } from "node:fs/promises";
 
 // src/config/loader.ts
@@ -67312,7 +67480,7 @@ function requireUtil$2() {
         }
         path5 = url.path;
       }
-      var isAbsolute13 = exports$1.isAbsolute(path5);
+      var isAbsolute14 = exports$1.isAbsolute(path5);
       var parts = [];
       var start = 0;
       var i2 = 0;
@@ -67347,7 +67515,7 @@ function requireUtil$2() {
       }
       path5 = parts.join("/");
       if (path5 === "") {
-        path5 = isAbsolute13 ? "/" : ".";
+        path5 = isAbsolute14 ? "/" : ".";
       }
       if (url) {
         url.path = path5;
@@ -75179,9 +75347,9 @@ Url.prototype.resolveObject = function(relative7) {
   if (hasTrailingSlash && srcPath.join("/").substr(-1) !== "/") {
     srcPath.push("");
   }
-  var isAbsolute13 = srcPath[0] === "" || srcPath[0] && srcPath[0].charAt(0) === "/";
+  var isAbsolute14 = srcPath[0] === "" || srcPath[0] && srcPath[0].charAt(0) === "/";
   if (psychotic) {
-    result2.hostname = result2.host = isAbsolute13 ? "" : srcPath.length ? srcPath.shift() : "";
+    result2.hostname = result2.host = isAbsolute14 ? "" : srcPath.length ? srcPath.shift() : "";
     authInHost = result2.host && result2.host.indexOf("@") > 0 ? result2.host.split("@") : false;
     if (authInHost) {
       result2.auth = authInHost.shift();
@@ -75189,7 +75357,7 @@ Url.prototype.resolveObject = function(relative7) {
     }
   }
   mustEndAbs = mustEndAbs || result2.host && srcPath.length;
-  if (mustEndAbs && !isAbsolute13) {
+  if (mustEndAbs && !isAbsolute14) {
     srcPath.unshift("");
   }
   if (!srcPath.length) {
@@ -77143,7 +77311,7 @@ function requireInput() {
   if (hasRequiredInput) return input;
   hasRequiredInput = 1;
   let { nanoid } = /* @__PURE__ */ requireNonSecure();
-  let { isAbsolute: isAbsolute13, resolve: resolve14 } = require$$1;
+  let { isAbsolute: isAbsolute14, resolve: resolve14 } = require$$1;
   let { SourceMapConsumer, SourceMapGenerator } = /* @__PURE__ */ requireSourceMap$1();
   let { fileURLToPath: fileURLToPath3, pathToFileURL } = require$$2;
   let CssSyntaxError = /* @__PURE__ */ requireCssSyntaxError();
@@ -77151,7 +77319,7 @@ function requireInput() {
   let terminalHighlight = /* @__PURE__ */ requireTerminalHighlight();
   let lineToIndexCache = /* @__PURE__ */ Symbol("lineToIndexCache");
   let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
-  let pathAvailable = Boolean(resolve14 && isAbsolute13);
+  let pathAvailable = Boolean(resolve14 && isAbsolute14);
   function getLineToIndex(input2) {
     if (input2[lineToIndexCache]) return input2[lineToIndexCache];
     let lines = input2.css.split("\n");
@@ -77182,7 +77350,7 @@ function requireInput() {
       this.document = this.css;
       if (opts.document) this.document = opts.document.toString();
       if (opts.from) {
-        if (!pathAvailable || /^\w+:\/\//.test(opts.from) || isAbsolute13(opts.from)) {
+        if (!pathAvailable || /^\w+:\/\//.test(opts.from) || isAbsolute14(opts.from)) {
           this.file = opts.from;
         } else {
           this.file = resolve14(opts.from);
@@ -77318,7 +77486,7 @@ function requireInput() {
         to = consumer.originalPositionFor({ column: endColumn, line: endLine });
       }
       let fromUrl;
-      if (isAbsolute13(from2.source)) {
+      if (isAbsolute14(from2.source)) {
         fromUrl = pathToFileURL(from2.source);
       } else {
         fromUrl = new URL(
@@ -94298,6 +94466,9 @@ function createArgumentMap() {
   };
 }
 
+// ../reference-graph/dist/engine/binding.js
+import { isAbsolute as isAbsolute8 } from "node:path";
+
 // ../reference-graph/dist/engine/cycle-detection.js
 var MAX_REFERENCE_DEPTH = 32;
 function createCycleGuard() {
@@ -94360,130 +94531,25 @@ function libraryStubFor(imp, ref) {
   return libraryExportFor(imp, ref)?.kind === "identity-preserving" ? { kind: "Function", returns: [{ kind: "ParameterOf", fn: ref, index: 0 }] } : null;
 }
 
-// ../reference-graph/dist/engine/resolve-reference.js
-function resolveReference(graph, fileGraph, ref, guard = createCycleGuard()) {
-  const lookupGraph = fileGraphForRef(graph, ref, fileGraph);
-  let scope = ref.scope;
-  while (true) {
-    const decl = lookupGraph.declarations.get(`${scope}::${ref.symbol}`);
-    if (decl) {
-      return wrapWithMemberChain(decl.value, ref.memberChain);
-    }
-    if (scope === MODULE_SCOPE)
-      break;
-    const parent = lookupGraph.scopes.get(scope)?.parent;
-    if (parent === null || parent === void 0)
-      break;
-    scope = parent;
-  }
-  const imp = lookupGraph.importsByLocal.get(ref.symbol);
-  if (!imp)
-    return { kind: "Unknown" };
-  const stub = libraryStubFor(imp, ref);
-  if (stub)
-    return stub;
-  const resolvedFile = graph.moduleResolver(lookupGraph.filePath, imp.specifier);
-  if (!resolvedFile)
-    return { kind: "Unknown" };
-  const targetFile = graph.resolveToGraphKey ? graph.resolveToGraphKey(resolvedFile) ?? resolvedFile : resolvedFile;
-  const found = findExport(graph, targetFile, imp.imported, /* @__PURE__ */ new Set());
-  if (!found)
-    return { kind: "Unknown" };
-  const { record: exp, fileGraph: expFileGraph } = found;
-  return resolveExport(graph, expFileGraph, exp, ref.memberChain, guard);
+// ../reference-graph/dist/engine/member-identity.js
+function effectiveExportName(imported, memberChain) {
+  const first = memberChain[0];
+  return imported === "*" && first !== void 0 ? first : imported;
 }
-function findExport(graph, file, imported, seen2) {
-  const seenKey = `${file}::${imported}`;
-  if (seen2.has(seenKey))
-    return null;
-  seen2.add(seenKey);
-  const target = graph.files.get(file);
-  if (!target)
-    return null;
-  for (const exp of target.exports) {
-    if (exp.kind === "named" && exp.exportedAs === imported)
-      return { record: exp, fileGraph: target };
-    if (exp.kind === "default" && imported === "default")
-      return { record: exp, fileGraph: target };
-  }
-  for (const exp of target.exports) {
-    if (exp.kind !== "star")
-      continue;
-    const resolvedFrom = graph.moduleResolver(file, exp.from);
-    if (!resolvedFrom)
-      continue;
-    const nextFile = graph.resolveToGraphKey ? graph.resolveToGraphKey(resolvedFrom) ?? resolvedFrom : resolvedFrom;
-    const result2 = findExport(graph, nextFile, imported, seen2);
-    if (result2)
-      return result2;
-  }
-  return null;
+function residualMemberChain(imported, memberChain) {
+  return imported === "*" && memberChain.length > 0 ? memberChain.slice(1) : memberChain;
 }
-function resolveExport(graph, fileGraph, exp, memberChain, guard) {
-  if (exp.kind === "named" && "local" in exp) {
-    const guardResult = guard.push(fileGraph.filePath, exp.local);
-    if (guardResult !== "ok")
-      return { kind: "Unknown" };
-    try {
-      const localRef = {
-        symbol: exp.local,
-        scope: MODULE_SCOPE,
-        memberChain,
-        loc: { line: 0, column: 0 }
-      };
-      return resolveReference(graph, fileGraph, localRef, guard);
-    } finally {
-      guard.pop(fileGraph.filePath, exp.local);
-    }
-  }
-  if (exp.kind === "named" && "from" in exp) {
-    const resolvedFrom = graph.moduleResolver(fileGraph.filePath, exp.from);
-    if (!resolvedFrom)
-      return { kind: "Unknown" };
-    const targetFile = graph.resolveToGraphKey ? graph.resolveToGraphKey(resolvedFrom) ?? resolvedFrom : resolvedFrom;
-    const innerFound = findExport(graph, targetFile, exp.fromImported, /* @__PURE__ */ new Set());
-    if (!innerFound)
-      return { kind: "Unknown" };
-    const guardResult = guard.push(fileGraph.filePath, exp.exportedAs);
-    if (guardResult !== "ok")
-      return { kind: "Unknown" };
-    try {
-      return resolveExport(graph, innerFound.fileGraph, innerFound.record, memberChain, guard);
-    } finally {
-      guard.pop(fileGraph.filePath, exp.exportedAs);
-    }
-  }
-  if (exp.kind === "default" && "local" in exp) {
-    const guardResult = guard.push(fileGraph.filePath, exp.local);
-    if (guardResult !== "ok")
-      return { kind: "Unknown" };
-    try {
-      const localRef = {
-        symbol: exp.local,
-        scope: MODULE_SCOPE,
-        memberChain,
-        loc: { line: 0, column: 0 }
-      };
-      return resolveReference(graph, fileGraph, localRef, guard);
-    } finally {
-      guard.pop(fileGraph.filePath, exp.local);
-    }
-  }
-  return { kind: "Unknown" };
+function compoundExportName(root2, residual) {
+  return residual.length === 0 ? root2 : `${root2}.${residual.join(".")}`;
 }
-function wrapWithMemberChain(t3, chain) {
-  let result2 = t3;
-  for (const member of chain) {
-    result2 = { kind: "MemberOf", obj: result2, member };
+function memberOfObjectPath(holder, path5) {
+  let cur = holder;
+  for (const segment of path5) {
+    if (cur?.kind !== "Object")
+      return void 0;
+    cur = cur.props[segment];
   }
-  return result2;
-}
-function fileGraphForRef(graph, ref, fallback) {
-  if (!ref.originFile)
-    return fallback;
-  if (ref.originFile === fallback.filePath)
-    return fallback;
-  return graph.files.get(ref.originFile) ?? fallback;
+  return cur;
 }
 
 // ../reference-graph/dist/engine/specifier.js
@@ -94513,82 +94579,333 @@ function externalSubpath(pkg, specifier) {
   return void 0;
 }
 
-// ../reference-graph/dist/engine/re-export-chain.js
-function followReExportChain(graph, file, imported) {
-  return walk2(graph, file, imported, /* @__PURE__ */ new Set());
+// ../reference-graph/dist/engine/binding.js
+var NO_EXPORT = { kind: "no-export" };
+var UNBOUND = { kind: "unbound" };
+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 walk2(graph, file, imported, seen2) {
-  const seenKey = `${file}::${imported}`;
+function fileGraphForRef(graph, ref, fallback) {
+  if (!ref.originFile || ref.originFile === fallback.filePath)
+    return fallback;
+  return graph.files.get(ref.originFile) ?? fallback;
+}
+function graphKeyFor(graph, abs) {
+  return graph.resolveToGraphKey ? graph.resolveToGraphKey(abs) : abs;
+}
+function exportRecordFor(fileGraph, name) {
+  return fileGraph.exports.find((e) => e.kind === "named" && e.exportedAs === name || e.kind === "default" && name === "default");
+}
+function resolveBinding(graph, fileGraph, ref, guard = createCycleGuard()) {
+  const found = bindingIn(graph, fileGraphForRef(graph, ref, fileGraph), ref, guard, /* @__PURE__ */ new Set());
+  return withWalkIdentity(graph, found, ref.memberChain);
+}
+function resolveModuleExport(graph, fromFile, specifier, imported, memberChain, guard = createCycleGuard()) {
+  const found = moduleExport(graph, fromFile, specifier, imported, memberChain, guard, /* @__PURE__ */ new Set());
+  return withWalkIdentity(graph, { ...found, module: { specifier, imported, target: found.target } }, memberChain);
+}
+function bindingIn(graph, fileGraph, ref, guard, chain) {
+  const decl = findLocalDeclaration(fileGraph, ref);
+  if (decl) {
+    return { binding: { kind: "declaration", file: fileGraph.filePath, decl, path: ref.memberChain, inScope: true }, end: null };
+  }
+  const imp = fileGraph.importsByLocal.get(ref.symbol);
+  if (!imp)
+    return { binding: UNBOUND, end: null };
+  const stub = libraryStubFor(imp, ref);
+  if (stub) {
+    const binding2 = {
+      kind: "package-export",
+      specifier: imp.specifier,
+      exportName: effectiveExportName(imp.imported, ref.memberChain),
+      path: residualMemberChain(imp.imported, ref.memberChain),
+      stub
+    };
+    return { binding: binding2, end: null };
+  }
+  const found = moduleExport(graph, fileGraph.filePath, imp.specifier, imp.imported, ref.memberChain, guard, chain);
+  return { ...found, module: { specifier: imp.specifier, imported: imp.imported, target: found.target } };
+}
+function moduleExport(graph, fromFile, specifier, imported, memberChain, guard, chain) {
+  const exportName = effectiveExportName(imported, memberChain);
+  const path5 = residualMemberChain(imported, memberChain);
+  const target = moduleTarget(graph, fromFile, specifier, exportName, path5);
+  if (target.kind === "outside")
+    return { binding: target.binding, end: null, target };
+  if (imported === "*" && memberChain.length === 0)
+    return { binding: NO_EXPORT, end: null, target };
+  const found = exportIn(graph, target.key, exportName, path5, guard, chain);
+  const b = found.binding;
+  if (imported === "*" && (b.kind === "declaration" || b.kind === "package-export")) {
+    return { binding: { ...b, mainGap: "namespace-member" }, end: found.end, target };
+  }
+  return { binding: b, end: found.end, target };
+}
+function moduleTarget(graph, fromFile, specifier, exportName, path5) {
+  const isPackage = packageNameFromSpecifier(specifier) !== null;
+  const abs = graph.moduleResolver(fromFile, specifier);
+  if (!abs) {
+    const binding3 = isPackage ? { kind: "package-export", specifier, exportName, path: path5, stub: null } : { kind: "import-failed", specifier, exportName, path: path5 };
+    return { kind: "outside", binding: binding3, graphKey: null, member: false };
+  }
+  const graphKey = graphKeyFor(graph, abs);
+  const key = graphKey ?? abs;
+  if (graph.files.has(key))
+    return { kind: "parsed", key };
+  if (graph.workspaceMembership?.(abs) === true) {
+    return { kind: "outside", binding: { kind: "unparsed", file: abs, exportName, path: path5 }, graphKey, member: true };
+  }
+  const binding2 = isPackage ? { kind: "package-export", specifier, exportName, path: path5, stub: null } : { kind: "unparsed", file: key, exportName, path: path5 };
+  return { kind: "outside", binding: binding2, graphKey, member: false };
+}
+function exportIn(graph, file, name, path5, guard, chain) {
+  const again = soughtAgain(chain, file, name);
+  const found = findExportRecord(graph, file, name, /* @__PURE__ */ new Set());
+  if (!found)
+    return { binding: packageStarExport(graph, file, name, path5, /* @__PURE__ */ new Set()) ?? NO_EXPORT, end: null };
+  const inner = followRecord(graph, found, file, name, path5, guard, chain);
+  return again ? { binding: inner.binding, end: null } : inner;
+}
+function followRecord(graph, found, file, name, path5, guard, chain) {
+  const onChain = recordOnChain(graph, file, name, chain);
+  if (onChain?.record === found.record)
+    return bindingForRecord(graph, found.fileGraph, found.record, name, path5, guard, chain);
+  const { binding: binding2 } = bindingForRecord(graph, found.fileGraph, found.record, name, path5, guard, new Set(chain));
+  const end = onChain ? bindingForRecord(graph, onChain.fileGraph, onChain.record, name, path5, guard, chain).end : null;
+  return { binding: binding2, end };
+}
+function soughtAgain(chain, file, name) {
+  const key = `${file}::${name}`;
+  if (chain.has(key))
+    return true;
+  chain.add(key);
+  return false;
+}
+function findExportRecord(graph, file, name, seen2) {
+  const seenKey = `${file}::${name}`;
   if (seen2.has(seenKey))
     return null;
   seen2.add(seenKey);
-  const target = graph.files.get(file);
-  if (!target)
+  const fileGraph = graph.files.get(file);
+  if (!fileGraph)
     return null;
-  const exp = target.exports.find((e) => e.kind === "named" && "exportedAs" in e && e.exportedAs === imported || e.kind === "default" && imported === "default");
-  if (exp) {
-    if (exp.kind === "named" && "from" in exp) {
-      const nextAbs = graph.moduleResolver(file, exp.from);
-      if (!nextAbs)
-        return { file, localExport: imported };
-      const nextKey = graph.resolveToGraphKey ? graph.resolveToGraphKey(nextAbs) : nextAbs;
-      if (!nextKey)
-        return { file, localExport: imported };
-      return walk2(graph, nextKey, exp.fromImported, seen2) ?? {
-        file: nextKey,
-        localExport: exp.fromImported
-      };
-    }
-    if ("local" in exp) {
-      const imp = target.importsByLocal.get(exp.local);
-      if (imp && imp.imported !== "*" && !packageNameFromSpecifier(imp.specifier)) {
-        const nextAbs = graph.moduleResolver(file, imp.specifier);
-        const nextKey = nextAbs && (graph.resolveToGraphKey ? graph.resolveToGraphKey(nextAbs) : nextAbs);
-        if (nextKey) {
-          const leaf = walk2(graph, nextKey, imp.imported, seen2);
-          if (leaf)
-            return leaf;
-          if (graph.lazyReExportResolution && !graph.files.has(nextKey)) {
-            return { file: nextKey, localExport: imp.imported };
-          }
-        }
-      }
-      return { file, localExport: exp.local };
-    }
-    return { file, localExport: imported };
+  const record = exportRecordFor(fileGraph, name);
+  if (record)
+    return { record, fileGraph };
+  for (const star of fileGraph.exports) {
+    if (star.kind !== "star")
+      continue;
+    const abs = graph.moduleResolver(file, star.from);
+    if (!abs)
+      continue;
+    const found = findExportRecord(graph, graphKeyFor(graph, abs) ?? abs, name, seen2);
+    if (found)
+      return found;
   }
-  for (const starExp of target.exports) {
-    if (starExp.kind !== "star")
+  return null;
+}
+function packageStarExport(graph, file, name, path5, seen2) {
+  if (name === "default")
+    return null;
+  const outside = [];
+  const visit2 = (f) => {
+    if (seen2.has(f))
+      return;
+    seen2.add(f);
+    const fileGraph = graph.files.get(f);
+    if (!fileGraph)
+      return;
+    for (const star of fileGraph.exports) {
+      if (star.kind !== "star")
+        continue;
+      const target = moduleTarget(graph, f, star.from, name, path5);
+      if (target.kind === "parsed")
+        visit2(target.key);
+      else
+        outside.push(target.binding);
+    }
+  };
+  visit2(file);
+  return outside.length === 1 && outside[0]?.kind === "package-export" ? outside[0] : null;
+}
+function recordOnChain(graph, file, name, chain) {
+  const fileGraph = graph.files.get(file);
+  if (!fileGraph)
+    return null;
+  const record = exportRecordFor(fileGraph, name);
+  if (record)
+    return { record, fileGraph };
+  for (const star of fileGraph.exports) {
+    if (star.kind !== "star")
       continue;
-    const nextAbs = graph.moduleResolver(file, starExp.from);
-    if (!nextAbs)
+    const abs = graph.moduleResolver(file, star.from);
+    if (!abs)
       continue;
-    const nextKey = graph.resolveToGraphKey ? graph.resolveToGraphKey(nextAbs) : nextAbs;
-    if (!nextKey)
+    const next = graphKeyFor(graph, abs);
+    if (next === null || soughtAgain(chain, next, name))
       continue;
-    const result2 = walk2(graph, nextKey, imported, seen2);
-    if (result2)
-      return result2;
+    const found = recordOnChain(graph, next, name, chain);
+    if (found)
+      return found;
   }
   return null;
 }
-
-// ../reference-graph/dist/engine/member-identity.js
-function effectiveExportName(imported, memberChain) {
-  const first = memberChain[0];
-  return imported === "*" && first !== void 0 ? first : imported;
+function bindingForRecord(graph, fg, exp, name, path5, guard, chain) {
+  if (exp.kind === "star")
+    return { binding: NO_EXPORT, end: null };
+  if ("local" in exp) {
+    const here = { file: fg.filePath, name: exp.local };
+    if (guard.push(fg.filePath, exp.local) !== "ok")
+      return { binding: NO_EXPORT, end: here };
+    try {
+      const ref = { symbol: exp.local, scope: MODULE_SCOPE, memberChain: [...path5], loc: { line: 0, column: 0 } };
+      const found2 = bindingIn(graph, fg, ref, guard, chain);
+      const b = found2.binding;
+      const followed = found2.module !== void 0 && found2.module.imported !== "*" && packageNameFromSpecifier(found2.module.specifier) === null && found2.module.target.kind === "parsed";
+      return {
+        binding: b.kind === "declaration" ? { ...b, inScope: false } : leftGraphThrough(b, fg.filePath),
+        end: (followed ? found2.end : null) ?? here
+      };
+    } finally {
+      guard.pop(fg.filePath, exp.local);
+    }
+  }
+  const target = moduleTarget(graph, fg.filePath, exp.from, exp.fromImported, path5);
+  if (target.kind === "outside") {
+    const end = target.graphKey === null ? { file: fg.filePath, name } : { file: target.graphKey, name: exp.fromImported };
+    return { binding: leftGraphThrough(target.binding, null), end };
+  }
+  const next = { file: target.key, name: exp.fromImported };
+  const again = soughtAgain(chain, target.key, exp.fromImported);
+  const found = findExportRecord(graph, target.key, exp.fromImported, /* @__PURE__ */ new Set());
+  if (!found)
+    return { binding: packageStarExport(graph, target.key, exp.fromImported, path5, /* @__PURE__ */ new Set()) ?? NO_EXPORT, end: next };
+  if (guard.push(fg.filePath, exp.exportedAs) !== "ok")
+    return { binding: NO_EXPORT, end: next };
+  try {
+    const inner = followRecord(graph, found, target.key, exp.fromImported, path5, guard, chain);
+    return { binding: inner.binding, end: (again ? null : inner.end) ?? next };
+  } finally {
+    guard.pop(fg.filePath, exp.exportedAs);
+  }
+}
+function leftGraphThrough(b, barrel) {
+  if (b.kind === "unparsed" && b.mainGap === void 0) {
+    return { ...b, mainGap: { kind: "through-parsed-barrel", barrel } };
+  }
+  return b;
+}
+function withWalkIdentity(graph, found, memberChain) {
+  const { binding: binding2, module } = found;
+  if (module === void 0)
+    return binding2;
+  if (binding2.kind === "package-export" && binding2.mainGap === void 0)
+    return binding2;
+  const { specifier, imported, target } = module;
+  const name = effectiveExportName(imported, memberChain);
+  const residual = residualMemberChain(imported, memberChain);
+  const isPackage = packageNameFromSpecifier(specifier) !== null;
+  const asWritten = (resolvedFile) => ({
+    kind: "imported",
+    specifier,
+    imported: compoundExportName(name, residual),
+    resolvedFile
+  });
+  const local = (file, exportName) => ({
+    kind: "local",
+    filePath: file,
+    export: compoundExportName(exportName, residual)
+  });
+  let walked;
+  if (target.kind === "outside") {
+    if (isPackage || target.member || binding2.kind !== "unparsed")
+      return binding2;
+    walked = asWritten(target.graphKey);
+  } else if (isPackage) {
+    const file = found.end?.file ?? target.key;
+    walked = graph.files.has(file) ? local(file, found.end?.name ?? name) : asWritten(null);
+  } else {
+    walked = found.end ? local(found.end.file, found.end.name) : asWritten(target.key);
+  }
+  return sameIdentity(walked, naturalIdentity(binding2)) ? binding2 : { ...binding2, walkIdentity: walked };
 }
-function residualMemberChain(imported, memberChain) {
-  return imported === "*" && memberChain.length > 0 ? memberChain.slice(1) : memberChain;
+function sameIdentity(a3, b) {
+  if (b === null || a3.kind !== b.kind)
+    return false;
+  if (a3.kind === "local" && b.kind === "local")
+    return a3.filePath === b.filePath && a3.export === b.export;
+  if (a3.kind === "imported" && b.kind === "imported") {
+    return a3.specifier === b.specifier && a3.imported === b.imported && a3.resolvedFile === b.resolvedFile;
+  }
+  return false;
 }
-function compoundExportName(root2, residual) {
-  return residual.length === 0 ? root2 : `${root2}.${residual.join(".")}`;
+function bindingValue(binding2) {
+  switch (binding2.kind) {
+    case "declaration": {
+      if (binding2.mainGap === "namespace-member")
+        return { kind: "Unknown" };
+      let value = binding2.decl.value;
+      for (const member of binding2.path)
+        value = { kind: "MemberOf", obj: value, member };
+      return value;
+    }
+    case "package-export":
+      return binding2.mainGap === "namespace-member" ? { kind: "Unknown" } : binding2.stub ?? { kind: "Unknown" };
+    default:
+      return { kind: "Unknown" };
+  }
 }
-function unparsedMemberDefinition(graph, resolvedAbs, imported) {
-  if (graph.workspaceMembership?.(resolvedAbs) !== true)
-    return null;
-  const def = graph.resolveLocalDefinition?.(resolvedAbs, imported) ?? null;
-  return { absFile: def?.absFile ?? resolvedAbs, exportName: def?.exportName ?? imported };
+function bindingIdentity(binding2) {
+  if (binding2.walkIdentity !== void 0)
+    return binding2.walkIdentity;
+  return naturalIdentity(binding2);
+}
+function naturalIdentity(binding2) {
+  switch (binding2.kind) {
+    case "declaration":
+      return {
+        kind: "local",
+        filePath: binding2.file,
+        export: compoundExportName(binding2.decl.symbol, binding2.path),
+        ...binding2.path.length === 0 ? { declaration: binding2.decl } : {}
+      };
+    case "unparsed":
+      return { kind: "local", filePath: binding2.file, export: compoundExportName(binding2.exportName, binding2.path) };
+    case "package-export":
+    case "import-failed":
+      return {
+        kind: "imported",
+        specifier: binding2.specifier,
+        imported: compoundExportName(binding2.exportName, binding2.path),
+        resolvedFile: null
+      };
+    default:
+      return null;
+  }
+}
+function pinUnparsed(graph, binding2) {
+  if (binding2.kind !== "unparsed" || binding2.mainGap !== void 0 || !isAbsolute8(binding2.file))
+    return binding2;
+  if (graph.workspaceMembership?.(binding2.file) !== true)
+    return binding2;
+  const def = graph.resolveLocalDefinition?.(binding2.file, binding2.exportName) ?? null;
+  return def === null ? binding2 : { ...binding2, file: def.absFile, exportName: def.exportName };
+}
+
+// ../reference-graph/dist/engine/resolve-reference.js
+function resolveReference(graph, fileGraph, ref, guard = createCycleGuard()) {
+  return bindingValue(resolveBinding(graph, fileGraph, ref, guard));
 }
 
 // ../reference-graph/dist/engine/assert-never.js
@@ -94663,7 +94980,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 +94991,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 +95029,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 +95135,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 +95175,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 +95226,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 +95239,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 +95258,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);
@@ -94926,13 +95329,13 @@ function foldToWrappedArg(inner, via) {
   }
   return [indeterminateTerminal()];
 }
-function argumentProvenance(type, arg, fileGraph) {
-  const importRecord = findImportForLastArg(arg, fileGraph);
+function argumentProvenance(graph, type, arg, fileGraph) {
+  const importRecord = findImportForLastArg(graph, arg, fileGraph);
   const resolved = importRecord ? { specifier: importRecord.specifier, import: importRecord.imported } : resolveAnonymousLastArg(arg, fileGraph);
   return { callee: deriveHocCallee(type.callee), specifier: resolved.specifier, import: resolved.import };
 }
-function buildHocVia(type, lastArg, fileGraph) {
-  const { callee, specifier, import: imported } = argumentProvenance(type, lastArg, fileGraph);
+function buildHocVia(graph, type, lastArg, fileGraph) {
+  const { callee, specifier, import: imported } = argumentProvenance(graph, type, lastArg, fileGraph);
   return { kind: "hoc-wrapper", hocCallee: callee, specifier, import: imported };
 }
 function foldedArgument(graph, fileGraph, call, jsx, argMap) {
@@ -94940,7 +95343,7 @@ function foldedArgument(graph, fileGraph, call, jsx, argMap) {
   const arg = call.args[index];
   if (arg === void 0 || jsx.length === 0)
     return null;
-  const via = buildHocVia(call, arg, fileGraph);
+  const via = buildHocVia(graph, call, arg, fileGraph);
   return jsx.every((t3) => t3.viaTrail[0] !== void 0 && sameHocVia(t3.viaTrail[0], via)) ? { arg, via } : null;
 }
 function sameHocVia(a3, b) {
@@ -94959,25 +95362,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":
@@ -95010,16 +95415,10 @@ function fileGraphForDynamicImport(graph, di, fallback) {
 }
 function dynamicImportIdentity(graph, fileGraph, di) {
   const origin = fileGraphForDynamicImport(graph, di, fileGraph);
-  const importedName = di.projection[0] ?? "default";
-  const resolvedFile = graph ? resolveImportedFile(graph, origin, di.specifier, importedName) : null;
-  return workspaceSiblingIdentity(graph, origin, di.specifier, importedName) ?? relativeChainLocalIdentity(graph, origin, di.specifier, importedName) ?? memberLocalIdentity(graph, origin, di.specifier, importedName) ?? {
-    kind: "imported",
-    specifier: di.specifier,
-    imported: importedName,
-    resolvedFile
-  };
+  const binding2 = resolveModuleExport(graph, origin.filePath, di.specifier, di.projection[0] ?? "default", []);
+  return bindingIdentity(pinUnparsed(graph, binding2));
 }
-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 +95429,17 @@ 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 stamp = self2 ?? deriveIdentity(fallback, fileGraph, graph);
+    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 stamp = derived ?? 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 walkStaticMember(graph, fileGraph, type, argMap, guard, fallback, position) {
   if (guard.pushNode(type) === "cycle") {
     return [indeterminateTerminal()];
   }
@@ -95051,7 +95450,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 +95461,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 = {
@@ -95106,8 +95493,8 @@ 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);
+      const target = resolveDynamicImportTarget(graph, fileGraph, syntheticDI);
+      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,15 +95517,15 @@ 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);
-      return foldToWrappedArg(inner2, buildHocVia(type, wrapped, fileGraph));
+      const inner2 = walkInner(graph, fileGraph, wrapped, argMap, guard, void 0, position);
+      return foldToWrappedArg(inner2, buildHocVia(graph, type, wrapped, fileGraph));
     }
   }
   const algResult = foldTerminals(graph, fileGraph, resolveType(graph, fileGraph, type, argMap, guard), type);
@@ -95146,9 +95533,9 @@ 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);
+        const via = buildHocVia(graph, type, lastArg2, fileGraph);
         return inner2.filter((t3) => !cameToNothing(t3)).map((t3) => ({ denotation: t3.denotation, viaTrail: [via, ...t3.viaTrail], identity: t3.identity }));
       }
     }
@@ -95158,15 +95545,17 @@ 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 }));
     }
     return [indeterminateTerminal()];
   }
-  return foldToWrappedArg(inner, buildHocVia(type, lastArg, fileGraph));
+  return foldToWrappedArg(inner, buildHocVia(graph, type, lastArg, fileGraph));
 }
 function passThroughParameterIndex(graph, fileGraph, type, argMap, guard) {
   const calleeFns = resolveToFunctions(graph, fileGraph, type.callee, argMap, guard);
@@ -95190,7 +95579,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 +95593,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 +95656,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 +95674,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))
@@ -95326,14 +95715,19 @@ function deriveHocCallee(callee) {
       return "unknown";
   }
 }
-function findImportForLastArg(lastArg, fileGraph) {
+function findImportForLastArg(graph, lastArg, fileGraph) {
   let cur = lastArg;
   while (cur.kind === "ReturnTypeOf")
     cur = cur.callee;
   if (cur.kind !== "TypeOf")
     return null;
   const imp = fileGraph.importsByLocal.get(cur.ref.symbol);
-  return imp ? { specifier: imp.specifier, imported: imp.imported } : null;
+  if (!imp)
+    return null;
+  const binding2 = resolveBinding(graph, fileGraph, cur.ref);
+  if (binding2.kind === "declaration" && binding2.inScope && binding2.file === fileGraph.filePath)
+    return null;
+  return { specifier: imp.specifier, imported: imp.imported };
 }
 function resolveAnonymousLastArg(lastArg, fileGraph) {
   let cur = lastArg;
@@ -95377,104 +95771,11 @@ function typeContainsRef(haystack, needle) {
       return false;
   }
 }
-function resolveImportedFile(graph, fileGraph, specifier, imported) {
-  const abs = graph.moduleResolver(fileGraph.filePath, specifier);
-  if (!abs)
-    return null;
-  const key = graph.resolveToGraphKey ? graph.resolveToGraphKey(abs) : abs;
-  if (!key || !imported)
-    return key;
-  return followReExportChain(graph, key, imported)?.file ?? key;
-}
-function relativeChainLocalIdentity(graph, fileGraph, specifier, imported) {
-  if (!graph)
-    return null;
-  if (packageNameFromSpecifier(specifier))
-    return null;
-  const abs = graph.moduleResolver(fileGraph.filePath, specifier);
-  if (!abs)
-    return null;
-  const key = graph.resolveToGraphKey ? graph.resolveToGraphKey(abs) : abs;
-  if (!key || !graph.files.has(key))
-    return null;
-  const chained = followReExportChain(graph, key, imported);
-  if (!chained)
-    return null;
-  return { kind: "local", filePath: chained.file, export: chained.localExport };
-}
-function workspaceSiblingIdentity(graph, fileGraph, specifier, imported) {
-  if (!graph)
-    return null;
-  if (!packageNameFromSpecifier(specifier))
-    return null;
-  const abs = graph.moduleResolver(fileGraph.filePath, specifier);
-  const key = abs && (graph.resolveToGraphKey ? graph.resolveToGraphKey(abs) : abs);
-  if (!key)
-    return null;
-  const chained = followReExportChain(graph, key, imported);
-  const file = chained?.file ?? key;
-  if (!graph.files.has(file))
-    return null;
-  return { kind: "local", filePath: file, export: chained?.localExport ?? imported };
-}
-function memberLocalIdentity(graph, fileGraph, specifier, imported) {
-  if (graph?.workspaceMembership === void 0)
-    return null;
-  const abs = graph.moduleResolver(fileGraph.filePath, specifier);
-  if (!abs)
-    return null;
-  const key = graph.resolveToGraphKey ? graph.resolveToGraphKey(abs) : abs;
-  if (key !== null && graph.files.has(key))
-    return null;
-  const member = unparsedMemberDefinition(graph, abs, imported);
-  if (member === null)
-    return null;
-  return { kind: "local", filePath: member.absFile, export: member.exportName };
-}
-function withResidual(identity, residual) {
-  if (identity === null || residual.length === 0)
-    return identity;
-  return identity.kind === "local" ? { ...identity, export: compoundExportName(identity.export, residual) } : { ...identity, imported: compoundExportName(identity.imported, residual) };
-}
 function deriveIdentity(type, fileGraph, graph) {
-  const cur = type;
-  if (cur.kind === "DynamicImport") {
-    return dynamicImportIdentity(graph, fileGraph, cur);
-  }
-  if (cur.kind === "TypeOf") {
-    const symbol2 = cur.ref.symbol;
-    const lookup2 = graph ? fileGraphForRef(graph, cur.ref, fileGraph) : fileGraph;
-    const imp = lookup2.importsByLocal.get(symbol2);
-    if (imp) {
-      const imported = effectiveExportName(imp.imported, cur.ref.memberChain);
-      const residual = residualMemberChain(imp.imported, cur.ref.memberChain);
-      const resolvedFile = graph ? resolveImportedFile(graph, lookup2, imp.specifier, imported) : null;
-      const workspaceLocal = workspaceSiblingIdentity(graph, lookup2, imp.specifier, imported);
-      if (workspaceLocal)
-        return withResidual(workspaceLocal, residual);
-      const relativeLocal = relativeChainLocalIdentity(graph, lookup2, imp.specifier, imported);
-      if (relativeLocal)
-        return withResidual(relativeLocal, residual);
-      const memberLocal = memberLocalIdentity(graph, lookup2, imp.specifier, imported);
-      if (memberLocal)
-        return withResidual(memberLocal, residual);
-      return withResidual({
-        kind: "imported",
-        specifier: imp.specifier,
-        imported,
-        resolvedFile
-      }, residual);
-    }
-    for (const [, decl] of lookup2.declarations) {
-      if (decl && decl.symbol === symbol2) {
-        return withResidual({
-          kind: "local",
-          filePath: lookup2.filePath,
-          export: decl.exportedAs ?? symbol2
-        }, cur.ref.memberChain);
-      }
-    }
-  }
+  if (type.kind === "DynamicImport")
+    return dynamicImportIdentity(graph, fileGraph, type);
+  if (type.kind === "TypeOf")
+    return bindingIdentity(pinUnparsed(graph, resolveBinding(graph, fileGraph, type.ref)));
   return null;
 }
 
@@ -95580,7 +95881,7 @@ function resolveTypeInner(graph, fileGraph, type, argMap, guard) {
     case "Array":
       return [{ type, source: null }];
     case "DynamicImport": {
-      const target = resolveDynamicImportTarget(graph, fileGraph, type, guard);
+      const target = resolveDynamicImportTarget(graph, fileGraph, type);
       if (!target)
         return [{ type, source: type }];
       return resolveType(graph, target.targetFileGraph, target.value, argMap, guard);
@@ -95589,29 +95890,17 @@ function resolveTypeInner(graph, fileGraph, type, argMap, guard) {
       return assertNever(type);
   }
 }
-function resolveDynamicImportTarget(graph, fileGraph, di, guard) {
+function resolveDynamicImportTarget(graph, fileGraph, di) {
   const origin = fileGraphForDynamicImport(graph, di, fileGraph);
-  const absPath = graph.moduleResolver(origin.filePath, di.specifier);
-  if (!absPath)
-    return null;
-  const key = graph.resolveToGraphKey ? graph.resolveToGraphKey(absPath) ?? absPath : absPath;
-  const chained = followReExportChain(graph, key, di.projection[0] ?? "default");
-  const targetFile = chained ? graph.files.get(chained.file) : void 0;
-  if (!chained || !targetFile)
-    return null;
-  const local = chained.localExport;
-  if (!targetFile.declarations.has(`${MODULE_SCOPE}::${local}`) && !targetFile.importsByLocal.has(local))
+  const b = resolveModuleExport(graph, origin.filePath, di.specifier, di.projection[0] ?? "default", []);
+  const targetFile = b.kind === "declaration" ? b.file : b.kind === "unparsed" && b.mainGap !== void 0 ? b.mainGap.barrel : null;
+  const targetFileGraph = targetFile === null ? void 0 : graph.files.get(targetFile);
+  if (!targetFileGraph)
     return null;
-  const localRef = {
-    symbol: local,
-    scope: MODULE_SCOPE,
-    memberChain: [],
-    loc: { line: 0, column: 0 }
-  };
-  let value = resolveReference(graph, targetFile, localRef, guard);
+  let value = bindingValue(b);
   for (const member of di.projection.slice(1))
     value = { kind: "MemberOf", obj: value, member };
-  return { targetFileGraph: targetFile, value };
+  return { targetFileGraph, value };
 }
 function resolveToFunctions(graph, fileGraph, type, argMap, guard) {
   if (guard.pushNode(type) === "cycle") {
@@ -95708,21 +95997,67 @@ 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;
+// ../reference-graph/dist/engine/re-export-chain.js
+function followReExportChain(graph, file, imported) {
+  return walk2(graph, file, imported, /* @__PURE__ */ new Set());
+}
+function walk2(graph, file, imported, seen2) {
+  const seenKey = `${file}::${imported}`;
+  if (seen2.has(seenKey))
+    return null;
+  seen2.add(seenKey);
+  const target = graph.files.get(file);
+  if (!target)
+    return null;
+  const exp = exportRecordFor(target, imported);
+  if (exp) {
+    if (exp.kind === "named" && "from" in exp) {
+      const nextAbs = graph.moduleResolver(file, exp.from);
+      if (!nextAbs)
+        return { file, localExport: imported };
+      const nextKey = graphKeyFor(graph, nextAbs);
+      if (!nextKey)
+        return { file, localExport: imported };
+      return walk2(graph, nextKey, exp.fromImported, seen2) ?? {
+        file: nextKey,
+        localExport: exp.fromImported
+      };
+    }
+    if ("local" in exp) {
+      const imp = target.importsByLocal.get(exp.local);
+      if (imp && imp.imported !== "*" && !packageNameFromSpecifier(imp.specifier)) {
+        const nextAbs = graph.moduleResolver(file, imp.specifier);
+        const nextKey = nextAbs ? graphKeyFor(graph, nextAbs) : null;
+        if (nextKey) {
+          const leaf = walk2(graph, nextKey, imp.imported, seen2);
+          if (leaf)
+            return leaf;
+          if (graph.lazyReExportResolution && !graph.files.has(nextKey)) {
+            return { file: nextKey, localExport: imp.imported };
+          }
+        }
+      }
+      return { file, localExport: exp.local };
+    }
+    return { file, localExport: imported };
+  }
+  for (const starExp of target.exports) {
+    if (starExp.kind !== "star")
+      continue;
+    const nextAbs = graph.moduleResolver(file, starExp.from);
+    if (!nextAbs)
+      continue;
+    const nextKey = graphKeyFor(graph, nextAbs);
+    if (!nextKey)
+      continue;
+    const result2 = walk2(graph, nextKey, imported, seen2);
+    if (result2)
+      return result2;
   }
+  return null;
 }
+
+// ../reference-graph/dist/engine/helper-callers.js
 function classifyDeclaration(decl, registry, fileGraph) {
   if (decl.value.kind !== "Function" && decl.value.kind !== "ReturnTypeOf")
     return "unknown";
@@ -95910,7 +96245,7 @@ function resolveRefToDecl(ref, callerFile, callerGraph, graph) {
   const resolvedAbs = graph.moduleResolver(callerFile, imp.specifier);
   if (!resolvedAbs)
     return null;
-  const targetFile = graph.resolveToGraphKey ? graph.resolveToGraphKey(resolvedAbs) ?? resolvedAbs : resolvedAbs;
+  const targetFile = graphKeyFor(graph, resolvedAbs) ?? resolvedAbs;
   const targetGraph = graph.files.get(targetFile);
   if (!targetGraph)
     return null;
@@ -95996,12 +96331,14 @@ 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: (declaration2) => registry.isTagged(declaration2),
     localEntries: () => entries
   };
 }
-function buildComponentRegistry(graph) {
+function buildComponentRegistry(graph, tagged = []) {
   const consumed = /* @__PURE__ */ new Set();
   for (const [file, fg] of graph.files) {
     for (const exp of fg.exports) {
@@ -96023,16 +96360,18 @@ function buildComponentRegistry(graph) {
         consumed.add(entryKey(target.file, target.symbol));
     }
   }
+  const renderedAsTag = new Set(tagged);
+  const isTagged = (declaration2) => declaration2 !== void 0 && renderedAsTag.has(declaration2);
   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 +96382,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 +96397,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 +96435,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 +96452,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 +96478,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 +96510,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, 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 +96522,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 +96554,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 +96633,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 +96657,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);
     }
   }
@@ -96505,32 +96754,6 @@ function relabelExternalLeaf(rawComponentId, filePath, specifier, resolveExterna
     source: externalSource(hit.leafPackage, `${hit.leafPackage}/${hit.modulePath}`)
   };
 }
-function workspaceSiblingFallback(graph, resolvedTarget, matchedImport, effectiveImported, consumerDialect) {
-  if (!resolvedTarget)
-    return void 0;
-  const chained = followReExportChain(graph, resolvedTarget, effectiveImported);
-  const canonicalFile = chained?.file ?? resolvedTarget;
-  let exportName = chained?.localExport ?? effectiveImported;
-  if (!chained) {
-    const target = graph.files.get(resolvedTarget);
-    if (!target)
-      return void 0;
-    if (effectiveImported === "default") {
-      const def = target.exports.find((e) => e.kind === "default");
-      if (def && "local" in def)
-        exportName = def.local;
-    } else {
-      const named = target.exports.find((e) => e.kind === "named" && "exportedAs" in e && e.exportedAs === effectiveImported && "local" in e);
-      if (named && "local" in named)
-        exportName = named.local;
-    }
-  }
-  return {
-    kind: componentKindFor(consumerDialect),
-    export: exportName,
-    source: { type: "local", filePath: canonicalFile }
-  };
-}
 function emitOccurrence(occurrences, site, rawComponentId, owners, chain, definition) {
   const provisionalId = serialiseComponentId(rawComponentId);
   for (const { rawOwnerComponentId, viaPrefix } of owners) {
@@ -96572,29 +96795,130 @@ 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, fileGraph, usage, argMap) {
+  if (fileGraph.dialect === "react" && isHostElementRoot(usage.ref))
+    return { kind: "host-element" };
+  const binding2 = resolveBinding(graph, fileGraph, usage.ref);
+  const imp = fileGraph.importsByLocal.get(usage.ref.symbol);
+  const walkTag = (value) => walkWithFolding(graph, fileGraph, value, argMap, createCycleGuard(), void 0, "tag");
+  const walked = () => {
+    const value = bindingValue(binding2);
+    return { kind: "evaluated", evaluation: walkTag(value), value, credits: [] };
   };
-  const rawComponentId = componentIdFromIdentity(ft.identity, fallback, fileGraph.dialect, {
-    filePath,
-    fallbackSpecifier: matchedImport.specifier,
-    resolveExternalLeaf: opts?.resolveExternalLeaf
-  });
-  const outerVia = viaOverride ?? {
-    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);
+  switch (binding2.kind) {
+    // Transitional: these two arms read `walkIdentity`, which only a name or
+    // import that fails inside a parsed file carries, to tell that failure
+    // from the usage's own. They change when those failures stop naming the
+    // parsed file in walks.
+    case "unbound":
+      return binding2.walkIdentity === void 0 ? { kind: "unbound" } : walked();
+    case "import-failed":
+      return binding2.walkIdentity === void 0 ? { kind: "import-failed", specifier: binding2.specifier } : walked();
+    case "no-export":
+      return walked();
+    case "declaration": {
+      const value = bindingValue(binding2);
+      const evaluation = walkTag(value);
+      const declared = makeLocalComponentId(binding2.file, compoundExportName(binding2.decl.symbol, binding2.path), fileGraph.dialect);
+      const fallback = buildComponentId(bindingIdentity(binding2), declared, fileGraph.dialect);
+      const holder = binding2.walkIdentity === void 0 ? binding2.decl : void 0;
+      const definition = holder !== void 0 && (binding2.inScope || binding2.path.length > 0) ? { line: holder.loc.line, column: holder.loc.column } : void 0;
+      const rendered = holder !== void 0 && binding2.path.length === 0 ? { declaration: holder } : {};
+      const namesMember = namesObjectMember(holder?.value, binding2.path);
+      const outerVia = binding2.inScope || imp === void 0 ? { kind: "local-component" } : { kind: "direct-import", specifier: imp.specifier, import: imp.imported };
+      const credits = creditedTerminals(evaluation).filter((terminal) => terminal.identity !== null || namesMember).map((terminal) => ({
+        terminal,
+        fallback,
+        outerVia,
+        ...terminal.identity === null ? { ...definition !== void 0 ? { definition } : {}, ...rendered } : {}
+      }));
+      return { kind: "evaluated", evaluation, value, credits };
+    }
+    case "package-export":
+    case "unparsed": {
+      if (binding2.mainGap !== void 0 || imp === void 0 || binding2.kind === "unparsed" && packageNameFromSpecifier(imp.specifier) === null) {
+        return walked();
+      }
+      const pinned = binding2.kind === "unparsed" ? pinUnparsed(graph, binding2) : binding2;
+      const sentinel = { denotation: { kind: "foreign" }, viaTrail: [], identity: null };
+      const fallback = {
+        kind: componentKindFor(fileGraph.dialect),
+        export: compoundExportName(pinned.exportName, pinned.path),
+        source: pinned.kind === "unparsed" ? { type: "local", filePath: pinned.file } : externalSource(packageNameFromSpecifier(pinned.specifier) ?? pinned.specifier, pinned.specifier)
+      };
+      return {
+        kind: "evaluated",
+        evaluation: [sentinel],
+        value: null,
+        credits: [
+          {
+            terminal: sentinel,
+            fallback,
+            fallbackSpecifier: pinned.kind === "package-export" ? pinned.specifier : imp.specifier,
+            outerVia: { kind: "direct-import", specifier: imp.specifier, import: imp.imported }
+          }
+        ]
+      };
+    }
+    default:
+      return assertNever(binding2);
+  }
+}
+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);
+          if (declaration2 !== void 0)
+            tagged.push(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 +96952,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 +96959,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 +96968,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 +96981,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,12 +96992,28 @@ 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(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))
       return;
-    const outerVia = { kind: "passed-as-argument", index, ...argumentProvenance(site, arg, fileGraph) };
+    const outerVia = { kind: "passed-as-argument", index, ...argumentProvenance(graph, site, arg, fileGraph) };
     const argDecl = findLocalDeclaration(fileGraph, arg.ref);
     const unusedFallback = makeLocalComponentId(filePath, arg.ref.symbol, fileGraph.dialect);
     for (const ft of creditedTerminals(walkWithFolding(graph, fileGraph, arg, argMap))) {
@@ -96707,6 +97023,8 @@ function pushCallArgumentOccurrences(occurrences, filePath, call, owners, graph,
         filePath,
         resolveExternalLeaf: opts?.resolveExternalLeaf
       });
+      if (!registryHolds(registry, graph, rawComponentId, ft.identity.kind === "local" ? ft.identity.declaration : void 0))
+        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,10 +102125,11 @@ var Logger = class {
 };
 
 // src/commands/scan.ts
+init_upload();
 import { errorMessage as errorMessage2 } from "@component-compass/ast-utils";
 
 // src/seeds.ts
-import { relative as relative4, isAbsolute as isAbsolute8 } from "node:path";
+import { relative as relative4, isAbsolute as isAbsolute9 } from "node:path";
 import { posixPath as posixPath6 } from "@component-compass/plugin-core";
 
 // src/composition-rollup.ts
@@ -102173,7 +102492,7 @@ function buildComponentSeeds(parseResults, localIndex, repoRoot, workspaceGraph,
   const seedsById = /* @__PURE__ */ new Map();
   for (const result2 of parseResults) {
     for (const occ of result2.occurrences) {
-      const componentId = repoRoot && occ.componentId.source.type === "local" && isAbsolute8(occ.componentId.source.filePath) ? {
+      const componentId = repoRoot && occ.componentId.source.type === "local" && isAbsolute9(occ.componentId.source.filePath) ? {
         ...occ.componentId,
         source: {
           type: "local",
@@ -102318,7 +102637,7 @@ function indexedToComponentId(c2) {
 }
 
 // src/occurrences.ts
-import { relative as relative5, isAbsolute as isAbsolute9 } from "node:path";
+import { relative as relative5, isAbsolute as isAbsolute10 } from "node:path";
 import { posixPath as posixPath7 } from "@component-compass/plugin-core";
 import {
   computeOccurrenceId as computeOccurrenceId2,
@@ -102327,14 +102646,14 @@ import {
 function normaliseLocalFilePath(c2, repoRoot) {
   if (c2.source.type !== "local") return c2;
   const fp = c2.source.filePath;
-  if (!isAbsolute9(fp)) return c2;
+  if (!isAbsolute10(fp)) return c2;
   return {
     ...c2,
     source: { type: "local", filePath: posixPath7(relative5(repoRoot, fp)) }
   };
 }
 function toRelativePath2(absPath, repoRoot) {
-  if (!repoRoot || !isAbsolute9(absPath)) return absPath;
+  if (!repoRoot || !isAbsolute10(absPath)) return absPath;
   return posixPath7(relative5(repoRoot, absPath));
 }
 function parseResultsToOccurrences(results, repoRoot = "") {
@@ -102534,7 +102853,7 @@ function createBoundedDefinitionResolver(opts) {
 
 // src/scan/global-components.ts
 import { existsSync as existsSync7, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname11, isAbsolute as isAbsolute10, join as join14, resolve as resolve10 } from "node:path";
+import { dirname as dirname11, isAbsolute as isAbsolute11, join as join14, resolve as resolve10 } from "node:path";
 var CANDIDATE_PATHS = [join14(".nuxt", "components.d.ts"), join14(".nuxt", "types", "components.d.ts")];
 var AUGMENTED_MODULE = /declare\s+module\s+["'](?:vue|@vue\/runtime-core)["']\s*\{/g;
 var INTERFACE_DECL = /(?:^|[\s;}])(?:export\s+)?(?:declare\s+)?interface\s+([A-Za-z_$][\w$]*)\s*(?:extends\s+([^{]*?))?\s*\{/g;
@@ -102628,7 +102947,7 @@ function loadGlobalComponents(scanRoot) {
   return null;
 }
 function isBareSpecifier(importPath) {
-  if (isAbsolute10(importPath)) return false;
+  if (isAbsolute11(importPath)) return false;
   return !/^[.#~\\/]/.test(importPath) && !importPath.startsWith("@/");
 }
 function parseMembers(baseDir, members) {
@@ -102644,7 +102963,7 @@ function parseMembers(baseDir, members) {
     if (isBareSpecifier(importPath)) {
       specifier = importPath;
     } else {
-      const abs = isAbsolute10(importPath) ? importPath : resolve10(baseDir, importPath);
+      const abs = isAbsolute11(importPath) ? importPath : resolve10(baseDir, importPath);
       const posixAbs = abs.replaceAll("\\", "/");
       const nmIdx = posixAbs.lastIndexOf("node_modules/");
       if (nmIdx >= 0) {
@@ -102710,7 +103029,7 @@ async function runScan(opts) {
   if (repoIdOverride !== void 0) metaOpts.repoIdOverride = repoIdOverride;
   const meta = await stampMeta(metaOpts);
   const gitToplevel = await readGitToplevel(cfg.configDir);
-  const outputRoot = opts.repoRoot ? isAbsolute11(opts.repoRoot) ? opts.repoRoot : resolve11(opts.cwd ?? process.cwd(), opts.repoRoot) : gitToplevel && !relative6(gitToplevel, cfg.configDir).startsWith("..") ? gitToplevel : cfg.configDir;
+  const outputRoot = opts.repoRoot ? isAbsolute12(opts.repoRoot) ? opts.repoRoot : resolve11(opts.cwd ?? process.cwd(), opts.repoRoot) : gitToplevel && !relative6(gitToplevel, cfg.configDir).startsWith("..") ? gitToplevel : cfg.configDir;
   const rebase = (scanRel) => outputRoot === cfg.configDir ? scanRel : posixPath8(relative6(outputRoot, resolve11(cfg.configDir, scanRel)));
   if (opts.outputOverride) cfg.output = opts.outputOverride;
   const writer = opts.quiet ? () => {
@@ -102977,7 +103296,7 @@ async function runScan(opts) {
     // `snapshotManifestRefs()` — otherwise an undeclared package's full CEM
     // catalog gets broadcast as zero-occurrence components.
     resolveExternalLeaf: (fromFile, specifier, exportName) => {
-      const absFrom = isAbsolute11(fromFile) ? fromFile : resolve11(cfg.configDir, fromFile);
+      const absFrom = isAbsolute12(fromFile) ? fromFile : resolve11(cfg.configDir, fromFile);
       const hit = warmedResolver.lookupExternalLeaf(absFrom, specifier, exportName);
       if (!hit) return null;
       return { leafPackage: hit.leafPackage, modulePath: hit.modulePath, exportName: hit.exportName };
@@ -102997,7 +103316,7 @@ async function runScan(opts) {
   }
   const diagnostics = rawDiagnostics.map((d2) => ({
     ...d2,
-    filePath: isAbsolute11(d2.filePath) ? posixPath8(relative6(outputRoot, d2.filePath)) : d2.filePath
+    filePath: isAbsolute12(d2.filePath) ? posixPath8(relative6(outputRoot, d2.filePath)) : d2.filePath
   }));
   const snapshot = warmedResolver.snapshotComponents().map((c2) => ({ component: c2 }));
   const manifests = warmedResolver.snapshotManifestRefs();
@@ -103101,7 +103420,7 @@ async function runScan(opts) {
   };
   await stampGitMTime(outputRoot, scanOutput.components);
   await stampVersion(outputRoot, scanOutput.components, scanOutput.occurrences);
-  const outputPath = isAbsolute11(cfg.output) ? cfg.output : resolve11(cfg.configDir, cfg.output);
+  const outputPath = isAbsolute12(cfg.output) ? cfg.output : resolve11(cfg.configDir, cfg.output);
   await writeJson(scanOutput, outputPath);
   if (!opts.quiet) {
     printSummary(scanOutput, outputPath);
@@ -103112,19 +103431,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 };
@@ -103137,14 +103468,14 @@ function countFilesWithUsage(occurrences) {
 function normaliseEngineLocalId(c2, configDir2, rebase) {
   if (c2.source.type !== "local") return c2;
   const fp = c2.source.filePath;
-  const scanRel = isAbsolute11(fp) ? posixPath8(relative6(configDir2, fp)) : fp;
+  const scanRel = isAbsolute12(fp) ? posixPath8(relative6(configDir2, fp)) : fp;
   return {
     ...c2,
     source: { type: "local", filePath: rebase(scanRel) }
   };
 }
 function normaliseVia(v, configDir2, rebase) {
-  if (!("specifier" in v) || v.specifier === void 0 || !isAbsolute11(v.specifier)) return v;
+  if (!("specifier" in v) || v.specifier === void 0 || !isAbsolute12(v.specifier)) return v;
   const scanRel = posixPath8(relative6(configDir2, v.specifier));
   return { ...v, specifier: rebase(scanRel) };
 }
@@ -103152,7 +103483,7 @@ function normaliseVia(v, configDir2, rebase) {
 // src/commands/init.ts
 init_adapter();
 import { writeFile as writeFile3, stat as stat2, readFile as readFile6 } from "node:fs/promises";
-import { basename as basename5, isAbsolute as isAbsolute12, resolve as resolve12 } from "node:path";
+import { basename as basename5, isAbsolute as isAbsolute13, resolve as resolve12 } from "node:path";
 var DEFAULT_INCLUDE = "src/**/*.{ts,tsx,jsx,js,vue,html}";
 var FRAMEWORK_EXTS = {
   react: ["ts", "tsx", "js", "jsx"],
@@ -103184,7 +103515,7 @@ function buildConfig(o2) {
   };
 }
 async function runInit(opts) {
-  const cwd2 = isAbsolute12(opts.cwd) ? opts.cwd : resolve12(opts.cwd);
+  const cwd2 = isAbsolute13(opts.cwd) ? opts.cwd : resolve12(opts.cwd);
   const out2 = opts.outputPath ?? resolve12(cwd2, "component-compass.config.json");
   await assertNoExistingConfig(out2);
   const repoId = opts.repoId ?? await deriveRepoId(cwd2);