@fluixi/compiler 1.0.0-alpha.82 → 1.0.0-alpha.84

package/dist/analyze/static-graph.cjs

@@ -0,0 +1,811 @@
+/*! @fluixi/compiler v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/analyze/static-graph.ts
+var static_graph_exports = {};
+__export(static_graph_exports, {
+  analyzeReactiveGraph: () => analyzeReactiveGraph
+});
+module.exports = __toCommonJS(static_graph_exports);
+var import_parser = require("@babel/parser");
+var import_template_parser = require("@fluixi/template-parser");
+
+// src/analyze/intrinsics.ts
+var REACTIVE_MODULE = "@fluixi/reactive/signal";
+var INTRINSICS = {
+  $signal: { export: "signal", module: REACTIVE_MODULE, returns: "signal-handle" },
+  $memo: { export: "memo", module: REACTIVE_MODULE, returns: "memo-handle" },
+  $effect: { export: "effect", module: REACTIVE_MODULE, returns: "effect" },
+  $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
+  $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
+  // No short runtime form for these yet, so the intrinsic stands for the `create*`
+  // name. Still worth having — no import to write — and when a shorter form is
+  // designed, the change is this line rather than a compiler pass.
+  $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  // Not value constructors, but the compiler has to know them: they change what a read
+  // does. `untrack` suppresses dependency collection, which is exactly the kind of thing
+  // dependency analysis must not guess at.
+  $untrack: { export: "untrack", module: REACTIVE_MODULE, returns: "plain" },
+  $untrackStore: { export: "untrackStore", module: "@fluixi/reactive/store", returns: "plain" }
+};
+var RUNTIME_PRIMITIVES = {
+  signal: "signal-handle",
+  memo: "memo-handle",
+  effect: "effect",
+  store: "store-handle",
+  createSignal: ["signal-accessor", "signal-setter"],
+  createMemo: "memo-accessor",
+  createEffect: "effect",
+  createRenderEffect: "effect",
+  createStore: "reactive-object",
+  resource: "resource-handle",
+  createResource: "reactive-object",
+  createSelector: "memo-accessor",
+  createDeferred: "memo-accessor"
+};
+var PRIMITIVE_MODULES = [
+  "@fluixi/reactive",
+  "@fluixi/reactive/signal",
+  "@fluixi/reactive/store",
+  "@fluixi/core"
+];
+var INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join("|")})\\s*\\(`);
+function isIntrinsicName(name) {
+  return Object.prototype.hasOwnProperty.call(INTRINSICS, name);
+}
+function isPrimitiveModule(source) {
+  return PRIMITIVE_MODULES.includes(source);
+}
+
+// src/analyze/reactive-bindings.ts
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties ?? []) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements ?? []) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function walk(root, visit) {
+  if (!root || typeof root !== "object" || typeof root.type !== "string") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) for (const item of value) walk(item, visit);
+    else if (value && typeof value === "object") walk(value, visit);
+  }
+}
+function calledPrimitive(node, bindings) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee?.type !== "Identifier") return void 0;
+  const name = callee.name;
+  const imported = bindings.primitives.get(name);
+  if (imported) return imported;
+  const intrinsic = INTRINSICS[name];
+  if (intrinsic && !bindings.shadowed.has(name)) return intrinsic.returns;
+  return void 0;
+}
+function classify(id, returns, kinds) {
+  if (Array.isArray(returns)) {
+    if (id.type === "ArrayPattern") {
+      id.elements.forEach((element, index) => {
+        const kind = returns[index];
+        if (element?.type === "Identifier" && kind) kinds.set(element.name, kind);
+      });
+    }
+    return;
+  }
+  if (id.type === "Identifier") kinds.set(id.name, returns);
+}
+function resolveReactiveBindings(program) {
+  const bindings = { kinds: /* @__PURE__ */ new Map(), primitives: /* @__PURE__ */ new Map(), shadowed: /* @__PURE__ */ new Set() };
+  const root = program;
+  walk(root, (node) => {
+    const names = /* @__PURE__ */ new Set();
+    if (node.type === "VariableDeclarator") patternNames(node.id, names);
+    else if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") patternNames(node.id, names);
+    else if (node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") patternNames(node.local, names);
+    else if (node.type === "ImportSpecifier") patternNames(node.local, names);
+    else if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration") {
+      for (const p of node.params ?? []) patternNames(p, names);
+    }
+    for (const name of names) if (INTRINSICS[name]) bindings.shadowed.add(name);
+  });
+  for (const statement of root.body ?? []) {
+    if (statement.type !== "ImportDeclaration") continue;
+    if (!isPrimitiveModule(statement.source?.value)) continue;
+    for (const specifier of statement.specifiers ?? []) {
+      if (specifier.type !== "ImportSpecifier") continue;
+      const importedNode = specifier.imported;
+      const imported = importedNode.type === "Identifier" ? importedNode.name : importedNode.value;
+      const returns = RUNTIME_PRIMITIVES[imported];
+      if (returns) bindings.primitives.set(specifier.local.name, returns);
+    }
+  }
+  walk(root, (node) => {
+    if (node.type !== "VariableDeclarator" || !node.init) return;
+    const returns = calledPrimitive(node.init, bindings);
+    if (returns) classify(node.id, returns, bindings.kinds);
+  });
+  return bindings;
+}
+
+// src/resolve/builtins.ts
+var DOM_CONTROL_FLOW = [
+  "Show",
+  "For",
+  "Index",
+  "Switch",
+  "Match",
+  "Portal",
+  "Dynamic",
+  "ErrorBoundary"
+];
+var CORE_CONTROL_FLOW = ["Suspense", "SuspenseList", "Await"];
+var ROUTER_COMPONENTS = ["Router", "Outlet", "Redirect", "Link"];
+var BUILTIN_COMPONENTS = [
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW,
+  ...ROUTER_COMPONENTS
+];
+var RESERVED_COMPONENTS = /* @__PURE__ */ new Set([
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW
+]);
+
+// src/analyze/static-graph.ts
+var PRIMITIVE_KIND = {
+  signal: "state",
+  createSignal: "state",
+  memo: "memo",
+  createMemo: "memo",
+  effect: "effect",
+  createEffect: "effect",
+  store: "store",
+  createStore: "store",
+  resource: "resource",
+  createResource: "resource"
+};
+var READS = /* @__PURE__ */ new Set(["memo", "effect", "resource"]);
+var DIRECTIVES = /* @__PURE__ */ new Set([
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW,
+  // The router is supplied without an import too. Without these, an app whose root renders
+  // `<Router>` has a root component connected to nothing at all.
+  ...ROUTER_COMPONENTS
+]);
+var TRACKED_PROP = {
+  Router: "routes",
+  Link: "href",
+  Redirect: "to",
+  Show: "when",
+  Match: "when",
+  For: "each",
+  Index: "each",
+  Dynamic: "component",
+  Portal: "mount",
+  Await: "value"
+};
+var ROUTER = new Set(ROUTER_COMPONENTS);
+var directiveKind = (tag) => ROUTER.has(tag) ? "router" : "control";
+var HTTP_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+]);
+function normalizePath(path) {
+  return path.replace(/\\/g, "/").replace(/^\.?\/+/, "");
+}
+function walk2(node, visit, stack = []) {
+  if (!node || typeof node.type !== "string") return;
+  visit(node, stack);
+  stack.push(node);
+  for (const key of Object.keys(node)) {
+    if (key === "loc" || key === "parent") continue;
+    const value = node[key];
+    if (Array.isArray(value)) for (const child of value) walk2(child, visit, stack);
+    else if (value && typeof value.type === "string") walk2(value, visit, stack);
+  }
+  stack.pop();
+}
+function declaredName(stack) {
+  const declarator = [...stack].reverse().find((n) => n.type === "VariableDeclarator");
+  const id = declarator?.id;
+  if (id?.type === "Identifier") return id.name;
+  if (id?.type === "ArrayPattern") {
+    const first = id.elements?.[0];
+    if (first?.type === "Identifier") return first.name;
+  }
+  return void 0;
+}
+function componentName(node) {
+  if (node.type === "FunctionDeclaration") {
+    const name = node.id?.name;
+    return name && name[0] === name[0]?.toUpperCase() ? name : void 0;
+  }
+  if (node.type === "VariableDeclarator") {
+    const id = node.id;
+    const init = node.init;
+    if (id?.type !== "Identifier" || !init) return void 0;
+    if (init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression") return void 0;
+    const name = id.name;
+    return name[0] === name[0]?.toUpperCase() ? name : void 0;
+  }
+  return void 0;
+}
+function mentions(node) {
+  const names = /* @__PURE__ */ new Set();
+  walk2(node, (n, stack) => {
+    if (n.type !== "Identifier") return;
+    const parent = stack[stack.length - 1];
+    if (parent?.type === "MemberExpression" && parent.property === n && !parent.computed) return;
+    if (parent?.type === "ObjectProperty" && parent.key === n && !parent.computed) return;
+    names.add(n.name);
+  });
+  return names;
+}
+function templatePieces(quasi) {
+  const pieces = [];
+  const quasis = quasi.quasis ?? [];
+  const expressions = quasi.expressions ?? [];
+  quasis.forEach((q, i) => {
+    const value = q.value;
+    pieces.push({ kind: "static", text: value?.cooked ?? value?.raw ?? "", start: q.start ?? 0 });
+    if (i < expressions.length) {
+      const e = expressions[i];
+      pieces.push({ kind: "hole", index: i, start: e.start ?? 0, end: e.end ?? 0 });
+    }
+  });
+  return pieces;
+}
+function positionsIn(code) {
+  const starts = [0];
+  for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) starts.push(i + 1);
+  return (offset) => {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+      const mid = low + high + 1 >> 1;
+      if (starts[mid] <= offset) low = mid;
+      else high = mid - 1;
+    }
+    return { line: low + 1, column: offset - starts[low] };
+  };
+}
+function describeTemplateElement(el) {
+  let id = "";
+  const classes = [];
+  for (const attr of el.attributes) {
+    if (attr.kind !== "Attribute" || attr.value?.kind !== "static") continue;
+    if (attr.name === "id") id = `#${attr.value.value}`;
+    else if (attr.name === "class") {
+      classes.push(...String(attr.value.value).split(/\s+/).filter(Boolean).slice(0, 2));
+    }
+  }
+  return `${el.tag}${id}${classes.map((c) => `.${c}`).join("")}`;
+}
+function valueHoles(value) {
+  if (!value) return [];
+  if (value.kind === "hole") return [value.hole];
+  if (value.kind === "mixed") return value.parts.flatMap((p) => "hole" in p ? [p.hole] : []);
+  return [];
+}
+function describeJsx(opening) {
+  const tag = opening.name?.name ?? "element";
+  let id = "";
+  const classes = [];
+  for (const attr of opening.attributes ?? []) {
+    if (attr.type !== "JSXAttribute") continue;
+    const name = attr.name?.name;
+    const value = attr.value;
+    if (value?.type !== "StringLiteral") continue;
+    if (name === "id") id = `#${value.value}`;
+    else if (name === "class" || name === "className") {
+      classes.push(...String(value.value).split(/\s+/).filter(Boolean).slice(0, 2));
+    }
+  }
+  return `${tag}${id}${classes.map((c) => `.${c}`).join("")}`;
+}
+function trackedExpression(opening, prop) {
+  for (const attr of opening.attributes ?? []) {
+    if (attr.type !== "JSXAttribute" || attr.name?.name !== prop) continue;
+    const value = attr.value;
+    return value?.type === "JSXExpressionContainer" ? value.expression : void 0;
+  }
+  return void 0;
+}
+function analyzeReactiveGraph(files, options = {}) {
+  const routesDir = (options.routesDir ?? "src/routes").replace(/^\.?\/+|\/+$/g, "");
+  const apiDir = (options.apiDir ?? "src/api").replace(/^\.?\/+|\/+$/g, "");
+  const fileRoutes = [];
+  const pending = [];
+  const exported = /* @__PURE__ */ new Map();
+  const locals = /* @__PURE__ */ new Map();
+  const imports = /* @__PURE__ */ new Map();
+  const usages = [];
+  const routeRefs = [];
+  const holes = [];
+  const domFor = /* @__PURE__ */ new Map();
+  const unresolved = [];
+  const componentMentions = /* @__PURE__ */ new Map();
+  let seq = 0;
+  for (const file of files) {
+    if (!/\.(tsx?|jsx?)$/.test(file.path)) continue;
+    let program;
+    try {
+      program = (0, import_parser.parse)(file.code, {
+        sourceType: "module",
+        plugins: ["jsx", "typescript"],
+        errorRecovery: true
+      }).program;
+    } catch {
+      continue;
+    }
+    const { primitives, shadowed } = resolveReactiveBindings(program);
+    const here = /* @__PURE__ */ new Map();
+    const sold = /* @__PURE__ */ new Map();
+    const from = /* @__PURE__ */ new Map();
+    locals.set(file.path, here);
+    exported.set(file.path, sold);
+    imports.set(file.path, from);
+    const inRoutesDir = normalizePath(file.path).startsWith(`${routesDir}/`);
+    const components = /* @__PURE__ */ new Map();
+    let positionAt = null;
+    const positionOf = () => positionAt ??= positionsIn(file.code);
+    walk2(program, (node, stack) => {
+      const name = componentName(node);
+      const at = node.loc?.start;
+      if (!name || !at) return;
+      const id = seq++;
+      components.set(node, id);
+      here.set(name, id);
+      componentMentions.set(id, mentions(node));
+      if (inRoutesDir) fileRoutes.push(id);
+      pending.push({
+        node: {
+          id,
+          label: name,
+          kind: HTTP_METHODS.has(name) ? "handler" : "component",
+          deps: [],
+          writes: [],
+          runs: 0,
+          lastPulse: 0,
+          source: { file: file.path, line: at.line, column: at.column }
+        },
+        reads: /* @__PURE__ */ new Set(),
+        file: file.path
+      });
+    });
+    walk2(program, (node, stack) => {
+      if (node.type === "ImportDeclaration") {
+        const source = node.source?.value;
+        for (const spec of node.specifiers ?? []) {
+          const local = spec.local?.name;
+          if (local && source?.startsWith(".")) from.set(local, source);
+        }
+        return;
+      }
+      if (node.type !== "CallExpression") return;
+      const callee = node.callee;
+      if (callee?.type !== "Identifier") return;
+      const name = callee.name;
+      const intrinsic = name.startsWith("$") && isIntrinsicName(name) && !shadowed.has(name);
+      if (!intrinsic && !primitives.has(name)) return;
+      const kind = PRIMITIVE_KIND[intrinsic ? name.slice(1) : name];
+      const at = node.loc?.start;
+      if (!kind || !at) return;
+      const id = seq++;
+      const label = declaredName(stack) ?? `${kind}${id}`;
+      here.set(label, id);
+      let owner;
+      for (let i = stack.length - 1; i >= 0; i--) {
+        const found = components.get(stack[i]);
+        if (found !== void 0) {
+          owner = found;
+          break;
+        }
+      }
+      pending.push({
+        node: {
+          id,
+          label,
+          kind,
+          deps: [],
+          writes: [],
+          runs: 0,
+          lastPulse: 0,
+          source: { file: file.path, line: at.line, column: at.column },
+          ...owner !== void 0 ? { createdIn: owner } : {}
+        },
+        // Only what reads can read: a signal's initial value is not a dependency.
+        reads: READS.has(kind) ? mentions(node.arguments?.[0]) : /* @__PURE__ */ new Set(),
+        file: file.path
+      });
+    });
+    walk2(program, (node, stack) => {
+      if (node.type !== "JSXOpeningElement") return;
+      const tag = node.name?.name;
+      if (!tag || tag[0] !== tag[0]?.toUpperCase()) return;
+      let owner;
+      for (let i = stack.length - 1; i >= 0; i--) {
+        const found = components.get(stack[i]);
+        if (found !== void 0) {
+          owner = found;
+          break;
+        }
+      }
+      const own = here.has(tag) || from.has(tag);
+      if (!own && DIRECTIVES.has(tag)) {
+        const at = node.loc?.start;
+        if (!at) return;
+        const id = seq++;
+        const prop = TRACKED_PROP[tag];
+        const tracked = prop ? trackedExpression(node, prop) : void 0;
+        const element = stack[stack.length - 1];
+        if (element?.type === "JSXElement") components.set(element, id);
+        pending.push({
+          node: {
+            id,
+            label: tag,
+            kind: directiveKind(tag),
+            deps: [],
+            writes: [],
+            runs: 0,
+            lastPulse: 0,
+            source: { file: file.path, line: at.line, column: at.column },
+            ...owner !== void 0 ? { createdIn: owner } : {}
+          },
+          reads: tracked ? mentions(tracked) : /* @__PURE__ */ new Set(),
+          file: file.path
+        });
+        return;
+      }
+      if (owner !== void 0) usages.push({ tag, file: file.path, owner });
+    });
+    walk2(program, (node, stack) => {
+      if (node.type !== "JSXExpressionContainer") return;
+      const expr = node.expression;
+      if (!expr || expr.type === "JSXEmptyExpression") return;
+      const at = expr.loc?.start;
+      if (!at) return;
+      const parent = stack[stack.length - 1];
+      const attribute = parent?.type === "JSXAttribute" ? parent.name?.name : void 0;
+      const holder = [...stack].reverse().find((n) => n.type === "JSXElement" || n.type === "JSXOpeningElement");
+      const opening = holder?.type === "JSXOpeningElement" ? holder : holder?.openingElement;
+      if (!opening) return;
+      const target = {
+        kind: attribute ? "attribute" : "content",
+        ...attribute ? { name: attribute } : {},
+        element: describeJsx(opening),
+        source: { file: file.path, line: at.line, column: at.column }
+      };
+      for (const name of mentions(expr)) holes.push({ file: file.path, name, target });
+    });
+    const describeTree = (el) => {
+      const opening = el.openingElement ?? void 0;
+      const tag = opening?.name?.name;
+      if (!opening || !tag) return void 0;
+      const at = el.loc?.start;
+      const where = at ? { file: file.path, line: at.line, column: at.column } : void 0;
+      const children = [];
+      for (const child of el.children ?? []) {
+        if (child?.type !== "JSXElement") continue;
+        const sub = describeTree(child);
+        if (sub) children.push(sub);
+      }
+      if (tag[0] === tag[0]?.toUpperCase()) {
+        const node = { label: tag, children, ...where ? { at: where } : {} };
+        const id = components.get(el) ?? here.get(tag);
+        if (id !== void 0) node.owner = id;
+        else unresolved.push({ node, tag, file: file.path });
+        return node;
+      }
+      return { label: describeJsx(opening), children, ...where ? { at: where } : {} };
+    };
+    walk2(program, (node, stack) => {
+      if (node.type !== "JSXElement") return;
+      let owner;
+      for (let i = stack.length - 1; i >= 0; i--) {
+        const found = stack[i];
+        if (found.type === "JSXElement") return;
+        const id = components.get(found);
+        if (id !== void 0) {
+          owner = id;
+          break;
+        }
+      }
+      if (owner === void 0) return;
+      const tree = describeTree(node);
+      if (!tree) return;
+      const held = domFor.get(owner);
+      if (held) held.push(tree);
+      else domFor.set(owner, [tree]);
+    });
+    walk2(program, (node, stack) => {
+      if (node.type !== "TaggedTemplateExpression") return;
+      const tagName = node.tag?.name;
+      if (tagName !== "html" && tagName !== "svg") return;
+      const quasi = node.quasi;
+      const expressions = quasi?.expressions ?? [];
+      const positionAt2 = positionOf();
+      let children;
+      try {
+        children = (0, import_template_parser.parseTemplate)(templatePieces(quasi), { svg: tagName === "svg" }).root.children;
+      } catch {
+        return;
+      }
+      const holeExpr = (index) => index == null ? void 0 : expressions[index];
+      const readsOf = (index) => {
+        const expr = holeExpr(index);
+        return expr ? mentions(expr) : /* @__PURE__ */ new Set();
+      };
+      const addControl = (tag, offset, hole, owner2) => {
+        const at = offset !== void 0 ? positionAt2(offset) : holeExpr(hole)?.loc?.start ?? node.loc?.start;
+        if (!at) return void 0;
+        const id = seq++;
+        pending.push({
+          node: {
+            id,
+            label: tag,
+            kind: directiveKind(tag),
+            deps: [],
+            writes: [],
+            runs: 0,
+            lastPulse: 0,
+            source: { file: file.path, line: at.line, column: at.column },
+            ...owner2 !== void 0 ? { createdIn: owner2 } : {}
+          },
+          reads: readsOf(hole),
+          file: file.path
+        });
+        return id;
+      };
+      const addTarget = (index, element, attribute) => {
+        const expr = holeExpr(index);
+        const at = expr?.loc?.start;
+        if (!expr || !at) return;
+        const target = {
+          kind: attribute ? "attribute" : "content",
+          ...attribute ? { name: attribute } : {},
+          element,
+          source: { file: file.path, line: at.line, column: at.column }
+        };
+        for (const name of mentions(expr)) holes.push({ file: file.path, name, target });
+      };
+      const elementTargets = (el) => {
+        const element = describeTemplateElement(el);
+        for (const attr of el.attributes) {
+          switch (attr.kind) {
+            case "Attribute":
+              for (const hole of valueHoles(attr.value)) addTarget(hole, element, attr.name);
+              break;
+            case "PropertyBinding":
+            case "BindDirective":
+              addTarget(attr.hole, element, attr.name);
+              break;
+            case "ClassDirective":
+              addTarget(attr.hole, element, "class");
+              break;
+            case "StyleDirective":
+              addTarget(attr.hole, element, "style");
+              break;
+            // A handler is not a read, and neither is a ref, a spread or a use.
+            default:
+              break;
+          }
+        }
+      };
+      const visit = (nodes, owner2, holder) => {
+        for (const child of nodes) {
+          switch (child.kind) {
+            case "Element": {
+              const ifDir = child.attributes.find((a) => a.kind === "IfDirective");
+              const eachDir = child.attributes.find((a) => a.kind === "EachDirective");
+              let inner = owner2;
+              if (ifDir?.kind === "IfDirective") inner = addControl("Show", child.loc?.start, ifDir.hole, owner2) ?? owner2;
+              else if (eachDir?.kind === "EachDirective") inner = addControl("For", child.loc?.start, eachDir.hole, owner2) ?? owner2;
+              elementTargets(child);
+              visit(child.children, inner, describeTemplateElement(child));
+              break;
+            }
+            case "Component": {
+              const tag = child.tag;
+              const own = here.has(tag) || from.has(tag);
+              if (tag && !own && DIRECTIVES.has(tag)) {
+                const prop = TRACKED_PROP[tag];
+                const tracked = prop ? child.attributes.find(
+                  (a) => "name" in a && a.name === prop
+                ) : void 0;
+                const hole = tracked && "hole" in tracked ? tracked.hole : tracked && "value" in tracked ? valueHoles(tracked.value)[0] : void 0;
+                const id = addControl(tag, child.loc?.start, hole, owner2);
+                visit(child.children, id ?? owner2, holder);
+                break;
+              }
+              if (tag && owner2 !== void 0) usages.push({ tag, file: file.path, owner: owner2 });
+              visit(child.children, owner2, holder);
+              break;
+            }
+            case "Fragment":
+              visit(child.children, owner2, holder);
+              break;
+            case "Expression":
+              addTarget(child.hole, holder, void 0);
+              break;
+            default:
+              break;
+          }
+        }
+      };
+      let owner;
+      for (let i = stack.length - 1; i >= 0; i--) {
+        const found = components.get(stack[i]);
+        if (found !== void 0) {
+          owner = found;
+          break;
+        }
+      }
+      visit(children, owner, "template");
+    });
+    walk2(program, (node, stack) => {
+      if (node.type !== "ObjectProperty" || node.computed) return;
+      const key = node.key?.name ?? node.key?.value;
+      if (key !== "component" && key !== "Component") return;
+      const value = node.value;
+      if (value?.type !== "Identifier") return;
+      const holder = [...stack].reverse().find((n) => n.type === "VariableDeclarator");
+      const via = holder?.id?.name;
+      if (via) routeRefs.push({ via, tag: value.name, file: file.path });
+    });
+    walk2(program, (node) => {
+      if (node.type !== "ExportNamedDeclaration" && node.type !== "ExportDefaultDeclaration") return;
+      for (const name of here.keys()) sold.set(name, here.get(name));
+    });
+  }
+  const resolve = (file, name) => {
+    const local = locals.get(file)?.get(name);
+    if (local !== void 0) return local;
+    const source = imports.get(file)?.get(name);
+    if (!source) return void 0;
+    for (const [path, names] of exported) {
+      if (!sameModule(file, source, path)) continue;
+      const id = names.get(name);
+      if (id !== void 0) return id;
+    }
+    return void 0;
+  };
+  for (const entry of pending) {
+    const deps = /* @__PURE__ */ new Set();
+    for (const name of entry.reads) {
+      const id = resolve(entry.file, name);
+      if (id !== void 0 && id !== entry.node.id) deps.add(id);
+    }
+    entry.node.deps = [...deps];
+  }
+  const unique = /* @__PURE__ */ new Map();
+  for (const names of exported.values()) {
+    for (const [name, id] of names) unique.set(name, unique.has(name) ? null : id);
+  }
+  const byId = new Map(pending.map((p) => [p.node.id, p.node]));
+  for (const entry of unresolved) {
+    const id = resolve(entry.file, entry.tag) ?? unique.get(entry.tag) ?? void 0;
+    if (id !== void 0 && byId.get(id)?.kind === "component") entry.node.owner = id;
+  }
+  for (const [id, dom] of domFor) {
+    const node = byId.get(id);
+    if (node && dom.length) node.dom = dom;
+  }
+  for (const hole of holes) {
+    const id = resolve(hole.file, hole.name);
+    const node = id !== void 0 ? byId.get(id) : void 0;
+    if (!node || node.kind === "component") continue;
+    (node.targets ??= []).push(hole.target);
+  }
+  for (const ref of routeRefs) {
+    const named = resolve(ref.file, ref.tag) ?? unique.get(ref.tag) ?? void 0;
+    if (named === void 0) continue;
+    const router = pending.find(
+      (p) => p.file === ref.file && p.node.kind === "router" && p.node.id !== named && p.reads.has(ref.via)
+    )?.node.id;
+    const mentions2 = pending.find(
+      (p) => p.file === ref.file && (p.node.kind === "component" || p.node.kind === "handler") && p.node.id !== named && componentMentions.get(p.node.id)?.has(ref.via)
+    )?.node.id;
+    const holder = router ?? mentions2;
+    const node = byId.get(named);
+    if (node && node.createdIn === void 0 && holder !== void 0) node.createdIn = holder;
+  }
+  for (const use of usages) {
+    const id = resolve(use.file, use.tag) ?? unique.get(use.tag) ?? void 0;
+    if (id === void 0 || id === use.owner) continue;
+    const node = byId.get(id);
+    if (node && node.kind === "component" && node.createdIn === void 0) node.createdIn = use.owner;
+  }
+  const only = (kind, label) => {
+    const found = pending.filter((p) => p.node.kind === kind && p.node.label === label);
+    return found.length === 1 ? found[0].node.id : void 0;
+  };
+  const routeOwner = only("router", "Outlet") ?? only("router", "Router");
+  if (routeOwner !== void 0) {
+    for (const id of fileRoutes) {
+      const node = byId.get(id);
+      if (node && node.kind === "component" && node.createdIn === void 0 && id !== routeOwner) {
+        node.createdIn = routeOwner;
+      }
+    }
+  }
+  const loose = pending.filter(
+    (p) => p.node.kind === "handler" && p.node.createdIn === void 0
+  );
+  if (loose.length > 0) {
+    const id = seq++;
+    pending.push({
+      node: {
+        id,
+        label: "api",
+        kind: "handler",
+        deps: [],
+        writes: [],
+        runs: 0,
+        lastPulse: 0,
+        // The directory, since there is no line of anyone's source to point at.
+        source: { file: apiDir, line: 1, column: 0 }
+      },
+      reads: /* @__PURE__ */ new Set(),
+      file: apiDir
+    });
+    for (const p of loose) p.node.createdIn = id;
+  }
+  return { t: Date.now(), nodes: pending.map((p) => p.node), static: true };
+}
+var withoutExtension = (path) => path.replace(/\.(tsx?|jsx?|mts|cts|mjs|cjs)$/, "");
+function sameModule(importer, specifier, candidate) {
+  const base = importer.includes("/") ? importer.slice(0, importer.lastIndexOf("/")) : "";
+  const parts = (base ? base.split("/") : []).concat(specifier.split("/"));
+  const stack = [];
+  for (const part of parts) {
+    if (part === "." || part === "") continue;
+    if (part === "..") stack.pop();
+    else stack.push(part);
+  }
+  const resolved = withoutExtension(stack.join("/"));
+  const target = withoutExtension(candidate);
+  return target === resolved || target === `${resolved}/index`;
+}