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

package/dist/analyze/props-destructure.mjs

@@ -1 +1,205 @@
-function u(s,n){if(s)switch(s.type){case"Identifier":n.add(s.name);return;case"ObjectPattern":for(let e of s.properties)e.type==="RestElement"?u(e.argument,n):u(e.value,n);return;case"ArrayPattern":for(let e of s.elements)u(e,n);return;case"AssignmentPattern":u(s.left,n);return;case"RestElement":u(s.argument,n);return}}function p(s){switch(s.type){case"StringLiteral":case"NumericLiteral":case"BooleanLiteral":case"NullLiteral":case"BigIntLiteral":case"RegExpLiteral":case"Identifier":return!0;case"Literal":return!0;case"TemplateLiteral":return s.expressions.every(p);case"UnaryExpression":return p(s.argument);case"MemberExpression":return!1;default:return!1}}function f(s,n){if(!(!s||typeof s!="object")){n(s);for(let e of Object.keys(s)){if(e==="loc"||e==="range"||e==="leadingComments"||e==="trailingComments")continue;let t=s[e];if(Array.isArray(t))for(let a of t)a&&typeof a=="object"&&f(a,n);else t&&typeof t=="object"&&typeof t.type=="string"&&f(t,n)}}}function y(s){let n=new Set;return f(s,e=>{if(e.type==="AssignmentExpression")u(e.left,n);else if(e.type==="UpdateExpression"){let t=e.argument;t?.type==="Identifier"&&n.add(t.name)}}),n}function h(s,n){let e=new Set,t=a=>{let c=new Set;u(a,c);for(let i of c)n.has(i)&&e.add(i)};return f(s,a=>{switch(a.type){case"VariableDeclarator":t(a.id);return;case"FunctionDeclaration":case"FunctionExpression":case"ArrowFunctionExpression":t(a.id);for(let c of a.params??[])t(c);return;case"CatchClause":t(a.param);return;case"ClassDeclaration":case"ClassExpression":t(a.id);return}}),e}function g(s,n,e){for(let t of s.properties??[]){if(t.type==="RestElement"){let o=t.argument;if(o?.type!=="Identifier"||n.length>0){let l=new Set;u(o,l);for(let N of l)e.bails.push({name:N,reason:"rest"});continue}e.rest={name:o.name,keys:[]};continue}if(t.computed){let o=new Set;u(t.value,o);for(let l of o)e.bails.push({name:l,reason:"computed"});continue}let a=t.key,c=a.type==="Identifier"?a.name:a.value,i=t.value,r;i.type==="AssignmentPattern"&&(r=i.right,i=i.left);let d=[...n,c];if(i.type==="Identifier"){if(r&&!p(r)){e.bails.push({name:i.name,reason:"unsafe-default"});continue}e.reads.push({name:i.name,path:d,...r?{fallback:r}:{}});continue}if(i.type==="ObjectPattern"){if(r){let o=new Set;u(i,o);for(let l of o)e.bails.push({name:l,reason:"unsafe-default"});continue}g(i,d,e);continue}let m=new Set;u(i,m);for(let o of m)e.bails.push({name:o,reason:"computed"})}}function w(s,n){let e={reads:[],bails:[]};if(s?.type!=="ObjectPattern"||(g(s,[],e),e.rest&&(n?.type!=="BlockStatement"?(e.bails.push({name:e.rest.name,reason:"rest"}),delete e.rest):e.rest.keys=(s.properties??[]).filter(r=>r.type!=="RestElement"&&!r.computed).map(r=>{let d=r.key;return d.type==="Identifier"?d.name:d.value})),e.reads.length===0&&!e.rest))return e;let t=new Set(e.reads.map(r=>r.name));e.rest&&t.add(e.rest.name);let a=y(n),c=h(n,t),i=[];for(let r of e.reads)a.has(r.name)?e.bails.push({name:r.name,reason:"reassigned"}):c.has(r.name)?e.bails.push({name:r.name,reason:"shadowed"}):i.push(r);return e.reads=i,e.rest&&a.has(e.rest.name)?(e.bails.push({name:e.rest.name,reason:"reassigned"}),delete e.rest):e.rest&&c.has(e.rest.name)&&(e.bails.push({name:e.rest.name,reason:"shadowed"}),delete e.rest),e}function b(s){switch(s){case"rest":return"this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters";case"computed":return"the property is not known until it runs";case"reassigned":return"the binding is assigned to, and props are read-only";case"shadowed":return"an inner scope binds the same name";case"unsafe-default":return"the default would have to run again on every read"}}export{b as explainBail,w as planPropsDestructure};
+// src/analyze/props-destructure.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 isSafeDefault(node) {
+  switch (node.type) {
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+    case "NullLiteral":
+    case "BigIntLiteral":
+    case "RegExpLiteral":
+    case "Identifier":
+      return true;
+    // ESTree spells every literal as `Literal`; both shapes reach this analysis.
+    case "Literal":
+      return true;
+    case "TemplateLiteral":
+      return node.expressions.every(isSafeDefault);
+    case "UnaryExpression":
+      return isSafeDefault(node.argument);
+    case "MemberExpression":
+      return false;
+    default:
+      return false;
+  }
+}
+function walk(root, visit) {
+  if (!root || typeof root !== "object") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "range" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) {
+      for (const item of value) if (item && typeof item === "object") walk(item, visit);
+    } else if (value && typeof value === "object" && typeof value.type === "string") {
+      walk(value, visit);
+    }
+  }
+}
+function reassignedNames(body) {
+  const written = /* @__PURE__ */ new Set();
+  walk(body, (node) => {
+    if (node.type === "AssignmentExpression") patternNames(node.left, written);
+    else if (node.type === "UpdateExpression") {
+      const arg = node.argument;
+      if (arg?.type === "Identifier") written.add(arg.name);
+    }
+  });
+  return written;
+}
+function shadowedNames(body, candidates) {
+  const shadowed = /* @__PURE__ */ new Set();
+  const note = (node) => {
+    const names = /* @__PURE__ */ new Set();
+    patternNames(node, names);
+    for (const n of names) if (candidates.has(n)) shadowed.add(n);
+  };
+  walk(body, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        note(node.id);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        note(node.id);
+        for (const p of node.params ?? []) note(p);
+        return;
+      case "CatchClause":
+        note(node.param);
+        return;
+      case "ClassDeclaration":
+      case "ClassExpression":
+        note(node.id);
+        return;
+    }
+  });
+  return shadowed;
+}
+function collect(pattern, path, plan) {
+  for (const property of pattern.properties ?? []) {
+    if (property.type === "RestElement") {
+      const argument = property.argument;
+      if (argument?.type !== "Identifier" || path.length > 0) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames(argument, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "rest" });
+        continue;
+      }
+      plan.rest = { name: argument.name, keys: [] };
+      continue;
+    }
+    if (property.computed) {
+      const names2 = /* @__PURE__ */ new Set();
+      patternNames(property.value, names2);
+      for (const name of names2) plan.bails.push({ name, reason: "computed" });
+      continue;
+    }
+    const key = property.key;
+    const propertyName = key.type === "Identifier" ? key.name : key.value;
+    let value = property.value;
+    let fallback;
+    if (value.type === "AssignmentPattern") {
+      fallback = value.right;
+      value = value.left;
+    }
+    const here = [...path, propertyName];
+    if (value.type === "Identifier") {
+      if (fallback && !isSafeDefault(fallback)) {
+        plan.bails.push({ name: value.name, reason: "unsafe-default" });
+        continue;
+      }
+      plan.reads.push({ name: value.name, path: here, ...fallback ? { fallback } : {} });
+      continue;
+    }
+    if (value.type === "ObjectPattern") {
+      if (fallback) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames(value, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "unsafe-default" });
+        continue;
+      }
+      collect(value, here, plan);
+      continue;
+    }
+    const names = /* @__PURE__ */ new Set();
+    patternNames(value, names);
+    for (const name of names) plan.bails.push({ name, reason: "computed" });
+  }
+}
+function planPropsDestructure(pattern, body) {
+  const plan = { reads: [], bails: [] };
+  if (pattern?.type !== "ObjectPattern") return plan;
+  collect(pattern, [], plan);
+  if (plan.rest) {
+    if (body?.type !== "BlockStatement") {
+      plan.bails.push({ name: plan.rest.name, reason: "rest" });
+      delete plan.rest;
+    } else {
+      plan.rest.keys = (pattern.properties ?? []).filter((p) => p.type !== "RestElement" && !p.computed).map((p) => {
+        const key = p.key;
+        return key.type === "Identifier" ? key.name : key.value;
+      });
+    }
+  }
+  if (plan.reads.length === 0 && !plan.rest) return plan;
+  const candidates = new Set(plan.reads.map((r) => r.name));
+  if (plan.rest) candidates.add(plan.rest.name);
+  const written = reassignedNames(body);
+  const shadowed = shadowedNames(body, candidates);
+  const kept = [];
+  for (const read of plan.reads) {
+    if (written.has(read.name)) plan.bails.push({ name: read.name, reason: "reassigned" });
+    else if (shadowed.has(read.name)) plan.bails.push({ name: read.name, reason: "shadowed" });
+    else kept.push(read);
+  }
+  plan.reads = kept;
+  if (plan.rest && written.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "reassigned" });
+    delete plan.rest;
+  } else if (plan.rest && shadowed.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "shadowed" });
+    delete plan.rest;
+  }
+  return plan;
+}
+function explainBail(reason) {
+  switch (reason) {
+    case "rest":
+      return "this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters";
+    case "computed":
+      return "the property is not known until it runs";
+    case "reassigned":
+      return "the binding is assigned to, and props are read-only";
+    case "shadowed":
+      return "an inner scope binds the same name";
+    case "unsafe-default":
+      return "the default would have to run again on every read";
+  }
+}
+export {
+  explainBail,
+  planPropsDestructure
+};

package/dist/analyze/reactive-bindings.cjs

@@ -1 +1,190 @@
-"use strict";var f=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var N=Object.prototype.hasOwnProperty;var I=(r,e)=>{for(var n in e)f(r,n,{get:e[n],enumerable:!0})},v=(r,e,n,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of y(e))!N.call(r,i)&&i!==n&&f(r,i,{get:()=>e[i],enumerable:!(t=g(e,i))||t.enumerable});return r};var x=r=>v(f({},"__esModule",{value:!0}),r);var b={};I(b,{declaredNames:()=>E,resolveReactiveBindings:()=>w});module.exports=x(b);var o="@fluixi/reactive/signal",l={$signal:{export:"signal",module:o,returns:"signal-handle"},$memo:{export:"memo",module:o,returns:"memo-handle"},$effect:{export:"effect",module:o,returns:"effect"},$store:{export:"store",module:"@fluixi/reactive/store",returns:"store-handle"},$resource:{export:"resource",module:o,returns:"resource-handle"},$selector:{export:"createSelector",module:o,returns:"memo-accessor"},$deferred:{export:"createDeferred",module:o,returns:"memo-accessor"},$untrack:{export:"untrack",module:o,returns:"plain"},$untrackStore:{export:"untrackStore",module:"@fluixi/reactive/store",returns:"plain"}},p={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"},R=["@fluixi/reactive","@fluixi/reactive/signal","@fluixi/reactive/store","@fluixi/core"],D=new RegExp(`\\$(?:${Object.keys(l).map(r=>r.slice(1)).join("|")})\\s*\\(`);function d(r){return R.includes(r)}function s(r,e){if(r)switch(r.type){case"Identifier":e.add(r.name);return;case"ObjectPattern":for(let n of r.properties??[])n.type==="RestElement"?s(n.argument,e):s(n.value,e);return;case"ArrayPattern":for(let n of r.elements??[])s(n,e);return;case"AssignmentPattern":s(r.left,e);return;case"RestElement":s(r.argument,e);return}}function c(r,e){if(!(!r||typeof r!="object"||typeof r.type!="string")){e(r);for(let n of Object.keys(r)){if(n==="loc"||n==="leadingComments"||n==="trailingComments")continue;let t=r[n];if(Array.isArray(t))for(let i of t)c(i,e);else t&&typeof t=="object"&&c(t,e)}}}function S(r,e){if(r.type!=="CallExpression")return;let n=r.callee;if(n?.type!=="Identifier")return;let t=n.name,i=e.primitives.get(t);if(i)return i;let a=l[t];if(a&&!e.shadowed.has(t))return a.returns}function h(r,e,n){if(Array.isArray(e)){r.type==="ArrayPattern"&&r.elements.forEach((t,i)=>{let a=e[i];t?.type==="Identifier"&&a&&n.set(t.name,a)});return}r.type==="Identifier"&&n.set(r.name,e)}function E(r){let e=new Set;return c(r,n=>{switch(n.type){case"VariableDeclarator":s(n.id,e);return;case"FunctionDeclaration":case"FunctionExpression":case"ArrowFunctionExpression":s(n.id,e);for(let t of n.params??[])s(t,e);return;case"ClassDeclaration":case"ClassExpression":s(n.id,e);return;case"ImportSpecifier":case"ImportDefaultSpecifier":case"ImportNamespaceSpecifier":s(n.local,e);return;case"CatchClause":s(n.param,e);return}}),e}function w(r){let e={kinds:new Map,primitives:new Map,shadowed:new Set},n=r;c(n,t=>{let i=new Set;if(t.type==="VariableDeclarator")s(t.id,i);else if(t.type==="FunctionDeclaration"||t.type==="ClassDeclaration")s(t.id,i);else if(t.type==="ImportDefaultSpecifier"||t.type==="ImportNamespaceSpecifier")s(t.local,i);else if(t.type==="ImportSpecifier")s(t.local,i);else if(t.type==="FunctionExpression"||t.type==="ArrowFunctionExpression"||t.type==="FunctionDeclaration")for(let a of t.params??[])s(a,i);for(let a of i)l[a]&&e.shadowed.add(a)});for(let t of n.body??[])if(t.type==="ImportDeclaration"&&d(t.source?.value))for(let i of t.specifiers??[]){if(i.type!=="ImportSpecifier")continue;let a=i.imported,m=a.type==="Identifier"?a.name:a.value,u=p[m];u&&e.primitives.set(i.local.name,u)}return c(n,t=>{if(t.type!=="VariableDeclarator"||!t.init)return;let i=S(t.init,e);i&&h(t.id,i,e.kinds)}),e}
+"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/reactive-bindings.ts
+var reactive_bindings_exports = {};
+__export(reactive_bindings_exports, {
+  declaredNames: () => declaredNames,
+  resolveReactiveBindings: () => resolveReactiveBindings
+});
+module.exports = __toCommonJS(reactive_bindings_exports);
+
+// 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 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 declaredNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  walk(program, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        patternNames(node.id, names);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        patternNames(node.id, names);
+        for (const p of node.params ?? []) patternNames(p, names);
+        return;
+      case "ClassDeclaration":
+      case "ClassExpression":
+        patternNames(node.id, names);
+        return;
+      case "ImportSpecifier":
+      case "ImportDefaultSpecifier":
+      case "ImportNamespaceSpecifier":
+        patternNames(node.local, names);
+        return;
+      case "CatchClause":
+        patternNames(node.param, names);
+        return;
+    }
+  });
+  return names;
+}
+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;
+}

package/dist/analyze/reactive-bindings.d.cts

@@ -0,0 +1,42 @@
+/**
+ * Which names in a module hold reactive values, and what kind.
+ *
+ * Resolved from where a name came from, never from how it reads. This has to hold:
+ *
+ *   import { createSignal as useState } from '@fluixi/reactive/signal';
+ *   const count = useState(0);          // a signal
+ *
+ *   function createSignal() { return 42; }
+ *   const value = createSignal();       // not a signal
+ *
+ * A name tells you nothing; the binding it resolves to tells you everything. So this
+ * walks the imports first, then the declarations that call them, and a local
+ * declaration always wins over anything the compiler would otherwise assume.
+ *
+ * Babel-free by the rule in no-babel-in-core: nodes are read structurally.
+ */
+import { type Intrinsic, type ReactiveKind } from './intrinsics.cjs';
+export interface ReactiveBindings {
+    /** Local name → what it holds. */
+    kinds: Map<string, ReactiveKind>;
+    /** Local name → the primitive it calls, for names imported from the runtime. */
+    primitives: Map<string, Intrinsic['returns']>;
+    /** `$name`s the module shadows with its own binding, so the intrinsic must not fire. */
+    shadowed: Set<string>;
+}
+/**
+ * Every name the module binds, in any scope.
+ *
+ * Deliberately scope-blind: it answers "does this file declare this name anywhere", which
+ * is the question a diagnostic needs. A component declared inside a function
+ * (`const Row = () => …`) is bound just as much as an import, and warning about it would
+ * be noise. Over-permissive on purpose — missing a warning beats inventing one.
+ */
+export declare function declaredNames(program: unknown): Set<string>;
+/**
+ * Read a module's reactive bindings.
+ *
+ * Two passes, because a call can only be classified once its callee is known: imports
+ * and local declarations first, then the declarations that call them.
+ */
+export declare function resolveReactiveBindings(program: unknown): ReactiveBindings;

package/dist/analyze/reactive-bindings.mjs

@@ -1 +1,167 @@
-var o="@fluixi/reactive/signal",l={$signal:{export:"signal",module:o,returns:"signal-handle"},$memo:{export:"memo",module:o,returns:"memo-handle"},$effect:{export:"effect",module:o,returns:"effect"},$store:{export:"store",module:"@fluixi/reactive/store",returns:"store-handle"},$resource:{export:"resource",module:o,returns:"resource-handle"},$selector:{export:"createSelector",module:o,returns:"memo-accessor"},$deferred:{export:"createDeferred",module:o,returns:"memo-accessor"},$untrack:{export:"untrack",module:o,returns:"plain"},$untrackStore:{export:"untrackStore",module:"@fluixi/reactive/store",returns:"plain"}},u={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"},m=["@fluixi/reactive","@fluixi/reactive/signal","@fluixi/reactive/store","@fluixi/core"],N=new RegExp(`\\$(?:${Object.keys(l).map(r=>r.slice(1)).join("|")})\\s*\\(`);function p(r){return m.includes(r)}function s(r,t){if(r)switch(r.type){case"Identifier":t.add(r.name);return;case"ObjectPattern":for(let n of r.properties??[])n.type==="RestElement"?s(n.argument,t):s(n.value,t);return;case"ArrayPattern":for(let n of r.elements??[])s(n,t);return;case"AssignmentPattern":s(r.left,t);return;case"RestElement":s(r.argument,t);return}}function c(r,t){if(!(!r||typeof r!="object"||typeof r.type!="string")){t(r);for(let n of Object.keys(r)){if(n==="loc"||n==="leadingComments"||n==="trailingComments")continue;let e=r[n];if(Array.isArray(e))for(let i of e)c(i,t);else e&&typeof e=="object"&&c(e,t)}}}function g(r,t){if(r.type!=="CallExpression")return;let n=r.callee;if(n?.type!=="Identifier")return;let e=n.name,i=t.primitives.get(e);if(i)return i;let a=l[e];if(a&&!t.shadowed.has(e))return a.returns}function y(r,t,n){if(Array.isArray(t)){r.type==="ArrayPattern"&&r.elements.forEach((e,i)=>{let a=t[i];e?.type==="Identifier"&&a&&n.set(e.name,a)});return}r.type==="Identifier"&&n.set(r.name,t)}function x(r){let t=new Set;return c(r,n=>{switch(n.type){case"VariableDeclarator":s(n.id,t);return;case"FunctionDeclaration":case"FunctionExpression":case"ArrowFunctionExpression":s(n.id,t);for(let e of n.params??[])s(e,t);return;case"ClassDeclaration":case"ClassExpression":s(n.id,t);return;case"ImportSpecifier":case"ImportDefaultSpecifier":case"ImportNamespaceSpecifier":s(n.local,t);return;case"CatchClause":s(n.param,t);return}}),t}function R(r){let t={kinds:new Map,primitives:new Map,shadowed:new Set},n=r;c(n,e=>{let i=new Set;if(e.type==="VariableDeclarator")s(e.id,i);else if(e.type==="FunctionDeclaration"||e.type==="ClassDeclaration")s(e.id,i);else if(e.type==="ImportDefaultSpecifier"||e.type==="ImportNamespaceSpecifier")s(e.local,i);else if(e.type==="ImportSpecifier")s(e.local,i);else if(e.type==="FunctionExpression"||e.type==="ArrowFunctionExpression"||e.type==="FunctionDeclaration")for(let a of e.params??[])s(a,i);for(let a of i)l[a]&&t.shadowed.add(a)});for(let e of n.body??[])if(e.type==="ImportDeclaration"&&p(e.source?.value))for(let i of e.specifiers??[]){if(i.type!=="ImportSpecifier")continue;let a=i.imported,d=a.type==="Identifier"?a.name:a.value,f=u[d];f&&t.primitives.set(i.local.name,f)}return c(n,e=>{if(e.type!=="VariableDeclarator"||!e.init)return;let i=g(e.init,t);i&&y(e.id,i,t.kinds)}),t}export{x as declaredNames,R as resolveReactiveBindings};
+// 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 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 declaredNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  walk(program, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        patternNames(node.id, names);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        patternNames(node.id, names);
+        for (const p of node.params ?? []) patternNames(p, names);
+        return;
+      case "ClassDeclaration":
+      case "ClassExpression":
+        patternNames(node.id, names);
+        return;
+      case "ImportSpecifier":
+      case "ImportDefaultSpecifier":
+      case "ImportNamespaceSpecifier":
+        patternNames(node.local, names);
+        return;
+      case "CatchClause":
+        patternNames(node.param, names);
+        return;
+    }
+  });
+  return names;
+}
+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;
+}
+export {
+  declaredNames,
+  resolveReactiveBindings
+};

package/dist/analyze/reactive-expr.cjs

@@ -1 +1,38 @@
-"use strict";var t=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var i=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var s=(e,r)=>{for(var p in r)t(e,p,{get:r[p],enumerable:!0})},l=(e,r,p,a)=>{if(r&&typeof r=="object"||typeof r=="function")for(let n of i(r))!u.call(e,n)&&n!==p&&t(e,n,{get:()=>r[n],enumerable:!(a=c(r,n))||a.enumerable});return e};var d=e=>l(t({},"__esModule",{value:!0}),e);var E={};s(E,{isReactiveShape:()=>o});module.exports=d(E);var m="children";function o(e){switch(e.kind){case"call":return!0;case"member":return e.property!==m;case"compound":return e.parts.some(o);case"opaque":return!1}}
+"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/reactive-expr.ts
+var reactive_expr_exports = {};
+__export(reactive_expr_exports, {
+  isReactiveShape: () => isReactiveShape
+});
+module.exports = __toCommonJS(reactive_expr_exports);
+var STABLE_MEMBER = "children";
+function isReactiveShape(shape) {
+  switch (shape.kind) {
+    case "call":
+      return true;
+    case "member":
+      return shape.property !== STABLE_MEMBER;
+    case "compound":
+      return shape.parts.some(isReactiveShape);
+    case "opaque":
+      return false;
+  }
+}