@fluixi/compiler 1.0.0-alpha.91 → 1.0.0-alpha.93

package/dist/integrations.cjs

@@ -1,4 +1,4 @@
-/*! @fluixi/compiler v1.0.0-alpha.91 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+/*! @fluixi/compiler v1.0.0-alpha.93 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -156,6 +156,7 @@ var init_intrinsics = __esm({
       $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" },
+      $cachedResource: { export: "cachedResource", module: "@fluixi/reactive/cached-resource", 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.
@@ -165,7 +166,22 @@ var init_intrinsics = __esm({
       // 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" }
+      $untrackStore: { export: "untrackStore", module: "@fluixi/reactive/store", returns: "plain" },
+      // Scopes, scheduling and lifecycle: no value to classify, but the same authoring promise,
+      // no import to write. `$cleanup` registers a callback on the current owner (`onCleanup`).
+      $batch: { export: "batch", module: REACTIVE_MODULE, returns: "plain" },
+      $cleanup: { export: "onCleanup", module: REACTIVE_MODULE, returns: "plain" },
+      $root: { export: "root", module: REACTIVE_MODULE, returns: "plain" },
+      $context: { export: "context", module: REACTIVE_MODULE, returns: "plain" },
+      $renderEffect: { export: "renderEffect", module: REACTIVE_MODULE, returns: "effect" },
+      $computed: { export: "computed", module: REACTIVE_MODULE, returns: "effect" },
+      // Storage for where the code runs, and a signal kept in it. `$persisted` is a signal
+      // handle as far as reads go: the same accessor with `set` on it.
+      $storage: { export: "useStorage", module: "@fluixi/core/storage", returns: "plain" },
+      $asyncStorage: { export: "useAsyncStorage", module: "@fluixi/core/storage", returns: "plain" },
+      $persisted: { export: "persisted", module: "@fluixi/core/storage", returns: "signal-handle" },
+      // An environment variable, public or server-only; the browser build refuses a secret.
+      $env: { export: "env", module: "@fluixi/start/env", returns: "plain" }
     };
     RUNTIME_PRIMITIVES = {
       signal: "signal-handle",
@@ -176,8 +192,11 @@ var init_intrinsics = __esm({
       createMemo: "memo-accessor",
       createEffect: "effect",
       createRenderEffect: "effect",
+      renderEffect: "effect",
+      computed: "effect",
       createStore: "reactive-object",
       resource: "resource-handle",
+      cachedResource: "resource-handle",
       createResource: "reactive-object",
       createSelector: "memo-accessor",
       createDeferred: "memo-accessor"
@@ -186,6 +205,7 @@ var init_intrinsics = __esm({
       "@fluixi/reactive",
       "@fluixi/reactive/signal",
       "@fluixi/reactive/store",
+      "@fluixi/reactive/cached-resource",
       "@fluixi/core"
     ];
     INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join("|")})\\s*\\(`);
@@ -684,11 +704,12 @@ var init_reactive_bindings = __esm({
 });
 
 // src/transform/source-locations.ts
-function mayHaveReactiveCall(code) {
+function mayHaveSourceMarks(code) {
   for (const name of RUNTIME_PRIMITIVES2) {
     if (code.includes(name)) return true;
   }
-  return code.includes("$signal") || code.includes("$memo") || code.includes("$effect") || code.includes("$store");
+  if (code.includes("$signal") || code.includes("$memo") || code.includes("$effect") || code.includes("$store")) return true;
+  return /\bclass\b[^{;]*\bextends\b/.test(code);
 }
 function isLoneBranch(statement, parent) {
   if (!parent || statement.type === "BlockStatement") return false;
@@ -717,6 +738,14 @@ function walk3(node, visit, stack = []) {
 }
 function nameFor(stack) {
   const declarator = stack[stack.length - 1];
+  if (declarator && CLASS_FIELDS.has(declarator.type)) {
+    const key = declarator.key;
+    if (key?.type === "Identifier" || key?.type === "PrivateIdentifier" || key?.type === "PrivateName") {
+      const name = key.name ?? key.id?.name;
+      return name;
+    }
+    return void 0;
+  }
   if (declarator?.type !== "VariableDeclarator") return void 0;
   const id = declarator.id;
   if (id?.type === "Identifier") return id.name;
@@ -765,6 +794,17 @@ function collectSourceEdits(program, filename) {
         });
       }
     }
+    if ((node.type === "ClassDeclaration" || node.type === "ClassExpression") && node.superClass && !node.declare) {
+      const at = node.loc?.start;
+      const body = node.body;
+      if (at && body) {
+        edits.push({
+          start: body.start + 1,
+          end: body.start + 1,
+          code: `static{globalThis.${CLASS_MARKER}?.(this,${JSON.stringify(filename)},${at.line},${at.column});}`
+        });
+      }
+    }
     if (node.type !== "CallExpression") return;
     const callee = node.callee;
     if (callee?.type !== "Identifier") return;
@@ -774,6 +814,26 @@ function collectSourceEdits(program, filename) {
     if (!intrinsic && !imported) return;
     const position = node.loc?.start;
     if (!position) return;
+    for (let i = stack.length - 1; i >= 0; i--) {
+      const up = stack[i];
+      if (isStatement(up)) break;
+      if (CLASS_FIELDS.has(up.type)) {
+        if (claimed.has(node.start)) return;
+        claimed.add(node.start);
+        const label2 = nameFor(stack);
+        const own = !up.static;
+        const args2 = [
+          JSON.stringify(filename),
+          String(position.line),
+          String(position.column),
+          label2 ? JSON.stringify(label2) : own ? "undefined" : void 0,
+          own ? "this" : void 0
+        ].filter((a) => a !== void 0).join(",");
+        edits.push({ start: node.start, end: node.start, code: `(globalThis.${SOURCE_MARKER}?.(${args2}),` });
+        edits.push({ start: node.end, end: node.end, code: ")" });
+        return;
+      }
+    }
     let statement;
     let parent;
     let index = -1;
@@ -813,7 +873,7 @@ function collectSourceEdits(program, filename) {
   });
   return { edits, marked: edits.length };
 }
-var SOURCE_MARKER, COMPONENT_MARKER, HOLE_MARKER, markHole, PROPS_MARKER, markProps, RUNTIME_PRIMITIVES2, SINGLE_STATEMENT_PARENTS;
+var SOURCE_MARKER, COMPONENT_MARKER, CLASS_MARKER, HOLE_MARKER, markHole, PROPS_MARKER, markProps, RUNTIME_PRIMITIVES2, SINGLE_STATEMENT_PARENTS, CLASS_FIELDS;
 var init_source_locations = __esm({
   "src/transform/source-locations.ts"() {
     "use strict";
@@ -821,6 +881,7 @@ var init_source_locations = __esm({
     init_reactive_bindings();
     SOURCE_MARKER = "__fx_source";
     COMPONENT_MARKER = "__fx_component";
+    CLASS_MARKER = "__fx_class";
     HOLE_MARKER = "__fx_hole";
     markHole = (accessor, line, column, name) => `(globalThis.${HOLE_MARKER} ?? ((f) => f))(${accessor},${line},${column}${name === void 0 ? "" : `,${JSON.stringify(name)}`})`;
     PROPS_MARKER = "__fx_props";
@@ -848,6 +909,7 @@ var init_source_locations = __esm({
       "LabeledStatement",
       "WithStatement"
     ]);
+    CLASS_FIELDS = /* @__PURE__ */ new Set(["PropertyDefinition", "ClassProperty", "ClassPrivateProperty", "AccessorProperty"]);
   }
 });
 
@@ -1011,13 +1073,16 @@ function emitComponent(name, props, children, used, templates, at) {
   used.add("createComponent");
   const spreads = props.filter((p) => p.kind === "spread");
   const normal = props.filter((p) => p.kind !== "spread");
-  const entries = normal.map(
-    (p) => `get ${propKey(p.name)}() { return ${componentPropValue(p)}; }`
-  );
+  const bodies = normal.map((p) => [p.name, componentPropValue(p)]);
   if (children.length > 0) {
-    entries.push(`get children() { return ${emitChildren(children, used, templates)}; }`);
+    bodies.push(["children", emitChildren(children, used, templates)]);
+  }
+  let obj = `{ ${bodies.map(([name2, body]) => `get ${propKey(name2)}() { return ${body}; }`).join(", ")} }`;
+  if (bodies.some(([, body]) => /\bthis\b/.test(body))) {
+    const thunks = bodies.map(([name2, body]) => `${JSON.stringify(name2)}: () => ${body}`);
+    const getters = bodies.map(([name2]) => `get ${propKey(name2)}() { return _$t[${JSON.stringify(name2)}](); }`);
+    obj = `((_$t) => ({ ${getters.join(", ")} }))({ ${thunks.join(", ")} })`;
   }
-  let obj = `{ ${entries.join(", ")} }`;
   if (spreads.length > 0) {
     used.add("mergeProps");
     obj = `mergeProps(${spreads.map((s) => s.expr).join(", ")}, ${obj})`;
@@ -1098,7 +1163,8 @@ function emitNode(node, used, templates) {
         } else {
           used.add("spread");
           const svgFlag = node.svg ? ", isSVG: true" : "";
-          const customFlag = node.tag.includes("-") ? ", isCustomElement: true" : "";
+          const accessors = node.props.filter((p) => p.kind !== "spread" && p.expr !== void 0 && p.reactive && p.name !== "ref").map((p) => p.name);
+          const customFlag = node.tag.includes("-") ? `, isCustomElement: true, accessors: ${JSON.stringify(accessors)}` : "";
           parts.push(
             `spread({ element: ${el}, props: ${emitProps(node.props, null, used)}${svgFlag}${customFlag} });`
           );
@@ -1189,7 +1255,7 @@ function lowerTemplate(pieces, holes, used, opts = {}) {
   const { root } = (0, import_template_parser.parseTemplate)(pieces, { svg: opts.svg });
   return new Lowerer(holes, used, opts.sourceFile, opts.positionAt).lowerRoot(root.children);
 }
-var import_template_parser, DELEGATED, Lowerer;
+var import_template_parser, DELEGATED, CONTAINER, Lowerer;
 var init_template = __esm({
   "src/lower/template.ts"() {
     "use strict";
@@ -1212,6 +1278,7 @@ var init_template = __esm({
       "mousedown",
       "mouseup"
     ]);
+    CONTAINER = "container";
     Lowerer = class {
       constructor(holes, used, sourceFile, positionAt) {
         this.holes = holes;
@@ -1263,10 +1330,6 @@ var init_template = __esm({
               if (hasElse) i = elseIdx;
               continue;
             }
-            if (child.attributes.some((a) => a.kind === "EachDirective")) {
-              out.push(this.lowerEach(child));
-              continue;
-            }
           }
           const node = this.lowerNode(child);
           if (node) out.push(node);
@@ -1308,13 +1371,16 @@ var init_template = __esm({
           node.props.unshift({ name: "component", kind: "attr", expr: `() => ${paren(this.hole(isAttr.value.hole).code, "arrowBody")}` });
           return node;
         }
+        const each = this.lowerEach(el);
+        const children = each ? [each] : this.lowerChildren(el.children);
+        if (el.tag === CONTAINER) return children.length === 1 ? children[0] : { kind: "fragment", children };
         const at = this.tagAt(el);
         return {
           kind: "element",
           tag: el.tag,
           svg: el.namespace === "svg",
           props: this.lowerAttributes(el.attributes),
-          children: this.lowerChildren(el.children),
+          children,
           static: false,
           ...at ? { at } : {}
         };
@@ -1386,10 +1452,14 @@ var init_template = __esm({
         const at = this.tagAt(el);
         return { kind: "component", name: "Show", props, children: [child], ...at ? { at } : {}, ...cond.at ? { bindAt: cond.at } : {} };
       }
-      /** `<el each=${items} key?>${item => …}</el>` → `<For each>{item => <el>…</el>}</For>`. */
+      /**
+       * `<el each=${items} key?>${item => …}</el>` → `<el><For each>{item => …}</For></el>`: the
+       * content is repeated per item. Content that is not a `${item => …}` arrow is repeated as
+       * it is. Null when the element has no `each`.
+       */
       lowerEach(el) {
         const eachDir = el.attributes.find((a) => a.kind === "EachDirective");
-        if (!eachDir || eachDir.kind !== "EachDirective") return this.lowerNode(el);
+        if (!eachDir || eachDir.kind !== "EachDirective") return null;
         const each = this.hole(eachDir.hole);
         const props = [{ name: "each", kind: "attr", expr: each.code, reactive: each.reactive, ...each.at ? { at: each.at } : {} }];
         if (eachDir.key) {
@@ -1399,12 +1469,12 @@ var init_template = __esm({
         const arrow = this.itemArrow(el);
         let childrenCode;
         if (arrow) {
-          const bodyIR = { kind: "expr", code: arrow.body, reactive: arrow.bodyReactive };
-          const repeated = this.rebuildWithChildren(el, [bodyIR]);
-          childrenCode = `(${arrow.params.join(", ")}) => ${paren(this.emit(repeated), "arrowBody")}`;
+          const body = arrow.bodyReactive ? `() => ${paren(arrow.body, "arrowBody")}` : paren(arrow.body, "arrowBody");
+          childrenCode = `(${arrow.params.join(", ")}) => ${body}`;
         } else {
-          const repeated = this.stripAndLower(el, (a) => a.kind === "EachDirective");
-          childrenCode = `() => ${paren(this.emit(repeated), "arrowBody")}`;
+          const content = this.lowerChildren(el.children);
+          const ir = content.length === 1 ? content[0] : { kind: "fragment", children: content };
+          childrenCode = `() => ${paren(this.emit(ir), "arrowBody")}`;
         }
         const children = [{ kind: "expr", code: childrenCode, reactive: false }];
         const at = this.tagAt(el);
@@ -1421,25 +1491,6 @@ var init_template = __esm({
         const clone = { ...el, attributes: el.attributes.filter((a) => !drop(a)) };
         return clone.kind === "Element" ? this.lowerElement(clone) : this.lowerComponent(clone);
       }
-      /** Same element (minus each/key) but with explicit IR children. */
-      rebuildWithChildren(el, children) {
-        const props = this.lowerAttributes(
-          el.attributes.filter((a) => a.kind !== "EachDirective")
-        );
-        if (el.kind === "Element") {
-          const at = this.tagAt(el);
-          return {
-            kind: "element",
-            tag: el.tag,
-            svg: el.namespace === "svg",
-            props,
-            children,
-            static: false,
-            ...at ? { at } : {}
-          };
-        }
-        return { kind: "component", name: el.tag, props, children };
-      }
       // --- attributes ---------------------------------------------------------
       lowerAttributes(attrs) {
         const props = [];
@@ -1853,6 +1904,21 @@ var init_expr_shape = __esm({
 });
 
 // src/lower/jsx.ts
+function directive(node, name) {
+  if (node.type !== "JSXElement") return void 0;
+  const opening = node.openingElement;
+  if (opening.name.type !== "JSXIdentifier" || opening.name.name[0] !== opening.name.name[0].toLowerCase()) return void 0;
+  return opening.attributes.find((a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === name);
+}
+function directiveExpr(attr) {
+  const v = attr.value;
+  return v?.type === "JSXExpressionContainer" && v.expression?.type !== "JSXEmptyExpression" ? v.expression : void 0;
+}
+function emitIR(ir, ctx) {
+  const { code, imports, templates } = imperativeBackend.emit(ir, {});
+  for (const s of imports) ctx.used.add(s);
+  return inlineTemplates(code, templates);
+}
 function literalOf(node) {
   if (node.type === "StringLiteral" || node.type === "NumericLiteral" || node.type === "BooleanLiteral") {
     return node.value;
@@ -1955,7 +2021,16 @@ function buildProps(attrs, ctx) {
 }
 function buildChildren(children, ctx) {
   const out = [];
-  for (const child of children) {
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (directive(child, "if")) {
+      let next = i + 1;
+      while (next < children.length && children[next].type === "JSXText" && !cleanTemplateText(children[next].value)) next++;
+      const fallback = directive(children[next], "else") ? children[next] : null;
+      out.push(buildIf(child, fallback, ctx));
+      if (fallback) i = next;
+      continue;
+    }
     if (child.type === "JSXText") {
       const text = cleanTemplateText(child.value);
       if (text) out.push({ kind: "text", value: text });
@@ -1992,26 +2067,75 @@ function readLoad(attrs) {
   }
   return void 0;
 }
+function buildIf(node, fallback, ctx) {
+  const cond = directiveExpr(directive(node, "if"));
+  const props = [
+    cond ? { name: "when", kind: "attr", expr: ctx.code(cond), reactive: isReactive(cond), at: posOf(cond, ctx) } : { name: "when", kind: "attr", literal: true }
+  ];
+  if (fallback) {
+    props.push({ name: "fallback", kind: "attr", expr: emitIR(buildElement(fallback, ctx, ["else"]), ctx), jsxElement: true });
+  }
+  return { kind: "component", name: "Show", props, children: [buildElement(node, ctx, ["if"])] };
+}
+function buildEach(node, ctx) {
+  const attr = directive(node, "each");
+  if (!attr) return null;
+  const list = directiveExpr(attr);
+  const props = [
+    list ? { name: "each", kind: "attr", expr: ctx.code(list), reactive: isReactive(list), at: posOf(list, ctx) } : { name: "each", kind: "attr", expr: "[]" }
+  ];
+  const key = directive(node, "key");
+  if (key) {
+    const keyExpr = directiveExpr(key);
+    const by = isString(key.value) ? `(item) => item[${JSON.stringify(literalOf(key.value))}]` : keyExpr ? ctx.code(keyExpr) : void 0;
+    if (by) props.push({ name: "by", kind: "attr", expr: by });
+  }
+  const content = node.children.filter((c) => !(c.type === "JSXText" && !cleanTemplateText(c.value)));
+  const only = content.length === 1 && content[0].type === "JSXExpressionContainer" ? content[0].expression : null;
+  let render;
+  if (only && (only.type === "ArrowFunctionExpression" || only.type === "FunctionExpression")) {
+    const fn = ctx.code(only);
+    const live = only.type === "ArrowFunctionExpression" && only.body.type !== "BlockStatement" && isReactive(only.body);
+    render = live ? `(...args) => () => (${fn})(...args)` : fn;
+  } else {
+    const built = buildChildren(node.children, ctx);
+    const ir = built.length === 1 ? built[0] : { kind: "fragment", children: built };
+    render = `() => ${paren(emitIR(ir, ctx), "arrowBody")}`;
+  }
+  return { kind: "component", name: "For", props, children: [{ kind: "expr", code: render, reactive: false }] };
+}
+function buildElement(node, ctx, handled) {
+  const skip = new Set(handled);
+  const directives = /* @__PURE__ */ new Set(["if", "else", "each", ...directive(node, "each") ? ["key"] : []]);
+  const attributes = node.openingElement.attributes.filter(
+    (a) => !(a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && (skip.has(a.name.name) || directives.has(a.name.name)))
+  );
+  const { tag } = tagInfo(node.openingElement.name, ctx);
+  const each = buildEach(node, ctx);
+  const children = each ? [each] : buildChildren(node.children, ctx);
+  if (tag === CONTAINER2) return children.length === 1 ? children[0] : { kind: "fragment", children };
+  const at = ctx.sourceFile && node.loc?.start ? { file: ctx.sourceFile, line: node.loc.start.line, column: node.loc.start.column } : void 0;
+  return { kind: "element", tag, svg: SVG_TAGS.has(tag), props: buildProps(attributes, ctx), children, static: false, ...at ? { at } : {} };
+}
 function buildNode(node, ctx) {
   if (node.type === "JSXFragment") {
     return { kind: "fragment", children: buildChildren(node.children, ctx) };
   }
+  if (directive(node, "if")) return buildIf(node, null, ctx);
   const { tag, component } = tagInfo(node.openingElement.name, ctx);
+  if (!component) return buildElement(node, ctx, []);
   const props = buildProps(node.openingElement.attributes, ctx);
   const children = buildChildren(node.children, ctx);
   const at = ctx.sourceFile && node.loc?.start ? { file: ctx.sourceFile, line: node.loc.start.line, column: node.loc.start.column } : void 0;
-  if (component) {
-    const load = readLoad(node.openingElement.attributes);
-    return { kind: "component", name: tag, props, children, ...load ? { load } : {}, ...at ? { at } : {} };
-  }
-  return { kind: "element", tag, svg: SVG_TAGS.has(tag), props, children, static: false, ...at ? { at } : {} };
+  const load = readLoad(node.openingElement.attributes);
+  return { kind: "component", name: tag, props, children, ...load ? { load } : {}, ...at ? { at } : {} };
 }
 function buildJsxIR(node, ctx) {
   const ir = buildNode(node, ctx);
   analyzeStatic(ir);
   return ir;
 }
-var SVG_TAGS, EVENT_RE, DELEGATED2, isReactive, posOf, isString;
+var SVG_TAGS, EVENT_RE, DELEGATED2, isReactive, CONTAINER2, posOf, isString;
 var init_jsx = __esm({
   "src/lower/jsx.ts"() {
     "use strict";
@@ -2021,6 +2145,7 @@ var init_jsx = __esm({
     init_analyze_static();
     init_text();
     init_paren();
+    init_imperative();
     SVG_TAGS = /* @__PURE__ */ new Set([
       "svg",
       "path",
@@ -2051,6 +2176,7 @@ var init_jsx = __esm({
       "mouseup"
     ]);
     isReactive = (node) => isReactiveShape(shapeOf(node));
+    CONTAINER2 = "container";
     posOf = (node, ctx) => {
       if (!ctx.sourceFile) return void 0;
       const at = node.loc?.start;
@@ -3171,10 +3297,34 @@ function collectIntrinsicEdits(program) {
   });
   return { edits, diagnostics, imports };
 }
+function avoidBindingClashes(program, result, bound) {
+  const importedAsIs = /* @__PURE__ */ new Set();
+  for (const stmt of program.body ?? []) {
+    if (stmt.type !== "ImportDeclaration") continue;
+    const module2 = stmt.source.value;
+    for (const spec of stmt.specifiers ?? []) {
+      if (spec.type !== "ImportSpecifier") continue;
+      const imported = spec.imported.name ?? spec.imported.value;
+      if (imported === spec.local.name && result.imports.get(module2)?.has(imported)) {
+        importedAsIs.add(imported);
+      }
+    }
+  }
+  const aliases = /* @__PURE__ */ new Map();
+  for (const names of result.imports.values()) {
+    for (const name of names) if (bound.has(name) && !importedAsIs.has(name)) aliases.set(name, `__fx_${name}`);
+  }
+  if (!aliases.size) return;
+  for (const edit of result.edits) {
+    const alias = aliases.get(edit.code);
+    if (alias) edit.code = alias;
+  }
+  result.aliases = aliases;
+}
 function intrinsicImports(result, bound) {
   const lines = [];
   for (const [module2, names] of [...result.imports].sort(([a], [b]) => a.localeCompare(b))) {
-    const wanted = [...names].filter((name) => !bound.has(name)).sort();
+    const wanted = [...names].filter((name) => result.aliases?.has(name) || !bound.has(name)).sort().map((name) => result.aliases?.has(name) ? `${name} as ${result.aliases.get(name)}` : name);
     if (wanted.length) lines.push(`import { ${wanted.join(", ")} } from ${JSON.stringify(module2)};`);
   }
   return lines.length ? `${lines.join("\n")}
@@ -3352,7 +3502,7 @@ function transformTemplates(code, id, options = {}) {
   const wantsJsx = format !== "lit";
   const mayHaveTemplate = wantsLit && (code.includes(`${litTag}\``) || code.includes("svg`"));
   const wantsIntrinsics = options.intrinsics !== false && mayHaveIntrinsic(code);
-  const wantsSources = options.sourceLocations === true && mayHaveReactiveCall(code);
+  const wantsSources = options.sourceLocations === true && mayHaveSourceMarks(code);
   const sourceName = relativeToRoot(id, options.sourceRoot);
   if (!mayHaveTemplate && !(wantsJsx && code.includes("<")) && !wantsIntrinsics && !wantsSources) return null;
   const ast = (0, import_parser2.parse)(code, {
@@ -3367,6 +3517,7 @@ function transformTemplates(code, id, options = {}) {
   });
   const props = options.propsDestructure === false ? { edits: [], diagnostics: [], used: /* @__PURE__ */ new Set() } : collectPropsEdits(ast.program, code, { runtimeModule: options.runtimeModule });
   const intrinsics = options.intrinsics === false ? { edits: [], diagnostics: [], imports: /* @__PURE__ */ new Map() } : collectIntrinsicEdits(ast.program);
+  if (intrinsics.edits.length) avoidBindingClashes(ast.program, intrinsics, moduleBindings(ast.program));
   const sources = options.sourceLocations === true ? collectSourceEdits(ast.program, sourceName) : { edits: [], marked: 0 };
   const silent = found.length === 0 && props.edits.length === 0 && sources.edits.length === 0 && intrinsics.edits.length === 0 && intrinsics.diagnostics.length === 0 && props.diagnostics.length === 0;
   if (silent) return null;
@@ -3706,7 +3857,7 @@ var server_fns_exports = {};
 __export(server_fns_exports, {
   transformServerFns: () => transformServerFns
 });
-function directive(node) {
+function directive2(node) {
   if (!FUNCTION_TYPES.has(node.type)) return null;
   const body = node.body;
   if (!body || body.type !== "BlockStatement") return null;
@@ -3722,7 +3873,7 @@ function findServerFns(node, out) {
     return;
   }
   if (typeof node.type === "string") {
-    const found = directive(node);
+    const found = directive2(node);
     if (found) {
       out.push({ fn: node, directive: found });
       return;
@@ -3839,7 +3990,8 @@ function componentGlobals(rules, options = {}) {
     builtins = true,
     intrinsics = true,
     generator = "@fluixi/compiler",
-    specifier = (module2) => module2
+    specifier = (module2) => module2,
+    candidates = []
   } = options;
   const all = [...rules];
   if (builtins) {
@@ -3851,7 +4003,8 @@ function componentGlobals(rules, options = {}) {
   const shadowedByDom = [];
   const unavailable = [];
   const resolved = /* @__PURE__ */ new Map();
-  for (const name of [...resolver.names()].sort()) {
+  const names = /* @__PURE__ */ new Set([...resolver.names(), ...[...candidates].filter((n) => /^[A-Za-z_$][\w$]*$/.test(n))]);
+  for (const name of [...names].sort()) {
     const target = resolver.resolve(name);
     if (!target) continue;
     const pkg = packageOf(target.module);
@@ -3862,7 +4015,11 @@ function componentGlobals(rules, options = {}) {
       resolved.set(name, target);
     }
   }
-  const intrinsicModules = intrinsics ? [...new Set(Object.values(INTRINSICS).map((i) => i.module))] : [];
+  const usableIntrinsics = intrinsics ? Object.entries(INTRINSICS).filter(([, i]) => {
+    const pkg = packageOf(i.module);
+    return !available || !pkg || available.has(pkg);
+  }) : [];
+  const intrinsicModules = [...new Set(usableIntrinsics.map(([, i]) => i.module))];
   const modules = [
     .../* @__PURE__ */ new Set([...declared2.map((name) => resolved.get(name).module), ...intrinsicModules])
   ].sort();
@@ -3882,15 +4039,18 @@ function componentGlobals(rules, options = {}) {
     return `//   import { ${n} } from '${module2 ? specifier(module2) : ""}';
 `;
   }).join("") : "";
-  const intrinsicLines = intrinsics ? Object.entries(INTRINSICS).map(
+  const intrinsicLines = usableIntrinsics.map(
     ([name, intrinsic]) => `  const ${name}: typeof ${namespaceAlias(intrinsic.module)}.${intrinsic.export};`
-  ) : [];
+  );
   const patternRules = rules.filter((rule) => "match" in rule).length;
-  const patternNote = patternRules > 0 ? `//
+  const patternNote = patternRules === 0 ? "" : options.candidates ? `//
+// ${patternRules} pattern rule${patternRules === 1 ? "" : "s"}: declared for the files the module path
+// points at. A name with no such file still resolves at build time; declare it by hand.
+` : `//
 // ${patternRules} pattern rule${patternRules === 1 ? "" : "s"} cannot be declared:
 // a pattern matches unboundedly many names, so there is no list to emit. Those
 // tags still resolve at build time; declare them by hand if the editor needs them.
-` : "";
+`;
   const source = `// GENERATED by ${generator}, do not edit.
 //
 // The components \`resolve\` supplies without an import. This describes what the
@@ -3947,6 +4107,30 @@ function projectDependencies(root) {
     return void 0;
   }
 }
+function patternCandidates(rules, root) {
+  const out = [];
+  for (const rule of rules) {
+    if (!("match" in rule) || !rule.module.startsWith("/")) continue;
+    const dir = (0, import_node_path.dirname)(rule.module);
+    const file = (0, import_node_path.basename)(rule.module);
+    const group = file.match(/\$\d+/);
+    if (dir.includes("$") || !group || file.indexOf("$", group.index + 1) !== -1) continue;
+    const before = file.slice(0, group.index);
+    const after = file.slice(group.index + group[0].length);
+    let entries;
+    try {
+      entries = (0, import_node_fs.readdirSync)((0, import_node_path.resolve)(root, dir.slice(1)));
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.length > before.length + after.length && entry.startsWith(before) && entry.endsWith(after)) {
+        out.push(entry.slice(before.length, entry.length - after.length));
+      }
+    }
+  }
+  return out;
+}
 function writeComponentGlobals(options, root) {
   if (options.globals === false) return { status: "skipped", reason: "disabled" };
   const rules = options.resolve ?? [];
@@ -3962,6 +4146,7 @@ function writeComponentGlobals(options, root) {
   }
   const { source, declared: declared2 } = componentGlobals(rules, {
     available: projectDependencies(root),
+    candidates: patternCandidates(rules, root),
     specifier: (module2) => forTypeScript(module2, (0, import_node_path.dirname)(target), root)
   });
   if (existing === source) {