sinwan-compiler 0.2.2 → 0.2.3

package/dist/auto-cc.d.ts

@@ -0,0 +1,34 @@
+/**
+ * SinwanJS Compiler — Auto `cc` wrapping
+ *
+ * Detects top-level exported functions that look like components (uppercase
+ * name, 0–1 params, return JSX) and wraps them with `cc(...)` so the reactive
+ * analyzer treats them as components and the runtime gives them a component
+ * instance + displayName.
+ *
+ * This lets plain `export function App()` / `export const App = () => <div/>`
+ * work as Sinwan components without an explicit `cc(...)` call, matching the
+ * ergonomics of React function components while preserving Sinwan's explicit
+ * reactivity model (the compiler still only auto-wraps JSX expressions that
+ * read tracked reactive sources).
+ *
+ * Detection is conservative on purpose:
+ *   - Only exported bindings are considered (named or default export).
+ *   - The binding name must start with an uppercase letter (component naming
+ *     convention). Anonymous default-exported function declarations are also
+ *     accepted since they are conventionally components.
+ *   - The function must have 0 or 1 parameters and must lexically return JSX
+ *     (a JSXElement/JSXFragment in a return statement or arrow body).
+ *   - Functions already wrapped in `cc(...)` (or an alias) are skipped to keep
+ *     the transform idempotent.
+ *
+ * If any wrapping is performed and `cc` is not already imported from
+ * `sinwan` / `sinwan/component`, an `import { cc } from "sinwan/component"` is
+ * prepended so the subsequent reactive-wrap pass detects the components.
+ */
+import * as t from "@babel/types";
+/**
+ * Mutates the AST, wrapping exported component-like functions with `cc(...)`.
+ * Returns `true` if any wrapping was performed.
+ */
+export declare function autoWrapComponents(ast: t.Node, filename?: string): boolean;

package/dist/{chunk-3bqqn28f.js → chunk-w580fdrf.js}

@@ -4,8 +4,8 @@ import * as path3 from "path";
 
 // src/analyze.ts
 import { parse } from "@babel/parser";
-import * as t2 from "@babel/types";
-import _traverse2 from "@babel/traverse";
+import * as t3 from "@babel/types";
+import _traverse3 from "@babel/traverse";
 import * as fs from "fs";
 import * as path2 from "path";
 
@@ -17,7 +17,8 @@ var traverse = typeof _traverse === "function" ? _traverse : _traverse.default ?
 var REACTIVE_SOURCE_MODULES = {
   "sinwan/store": new Set(["createMutable", "createStore"]),
   "sinwan/reactivity": new Set(["signal", "computed"]),
-  "sinwan/react": new Set(["useState"])
+  "sinwan/react": new Set(["useState"]),
+  "sinwan/hook": new Set(["useFetch"])
 };
 var COMPONENT_FACTORY_MODULES = {
   sinwan: new Set(["cc"]),
@@ -42,6 +43,9 @@ function isBuiltinReactiveProp(componentName, attrName) {
     return false;
   return entry.reactiveProps.has(attrName);
 }
+function isBuiltinControlFlowComponent(componentName) {
+  return !!componentName && BUILTIN_REACTIVE_PROPS.has(componentName);
+}
 function trackReactiveImports(ast) {
   const names = {
     createMutable: new Set,
@@ -49,6 +53,7 @@ function trackReactiveImports(ast) {
     signal: new Set,
     computed: new Set,
     useState: new Set,
+    useFetch: new Set,
     cc: new Set
   };
   traverse(ast, {
@@ -96,6 +101,32 @@ function isReactiveSourceCall(expr, names) {
   }
   return null;
 }
+var USEFETCH_CHAIN_METHODS = new Set([
+  "json",
+  "text",
+  "blob",
+  "arrayBuffer",
+  "formData",
+  "get",
+  "put",
+  "post",
+  "delete",
+  "patch",
+  "head",
+  "options"
+]);
+function isUseFetchCall(expr, names) {
+  if (!t.isCallExpression(expr))
+    return false;
+  const callee = expr.callee;
+  if (t.isIdentifier(callee)) {
+    return names.useFetch.has(callee.name);
+  }
+  if (t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.property) && USEFETCH_CHAIN_METHODS.has(callee.property.name)) {
+    return isUseFetchCall(callee.object, names);
+  }
+  return false;
+}
 function trackLocalScopeBindings(path2, names, scope) {
   path2.traverse({
     VariableDeclarator(p) {
@@ -104,27 +135,42 @@ function trackLocalScopeBindings(path2, names, scope) {
       if (!init)
         return;
       const source = isReactiveSourceCall(init, names);
-      if (!source)
-        return;
-      if (source.isArray) {
-        if (t.isArrayPattern(id) && id.elements[0]) {
-          const first = id.elements[0];
-          if (t.isIdentifier(first)) {
-            scope.bindings.set(first.name, { kind: source.kind });
+      if (source) {
+        if (source.isArray) {
+          if (t.isArrayPattern(id) && id.elements[0]) {
+            const first = id.elements[0];
+            if (t.isIdentifier(first)) {
+              scope.bindings.set(first.name, { kind: source.kind });
+            }
+          }
+          return;
+        }
+        if (t.isIdentifier(id)) {
+          if (source.kind === "mutable") {
+            scope.bindings.set(id.name, {
+              kind: "mutable",
+              root: id.name,
+              path: []
+            });
+          } else {
+            scope.bindings.set(id.name, { kind: source.kind });
           }
         }
         return;
       }
-      if (t.isIdentifier(id)) {
-        if (source.kind === "mutable") {
-          scope.bindings.set(id.name, {
-            kind: "mutable",
-            root: id.name,
-            path: []
-          });
-        } else {
-          scope.bindings.set(id.name, { kind: source.kind });
+      if (isUseFetchCall(init, names)) {
+        if (t.isObjectPattern(id)) {
+          for (const prop of id.properties) {
+            if (t.isObjectProperty(prop) && !prop.computed && t.isIdentifier(prop.value)) {
+              scope.bindings.set(prop.value.name, {
+                kind: "signal"
+              });
+            }
+          }
+        } else if (t.isIdentifier(id)) {
+          scope.bindings.set(id.name, { kind: "signalObject" });
         }
+        return;
       }
     }
   });
@@ -241,16 +287,27 @@ function analyzeObjectLiteralSpread(spread, fullScope, calleeReactive) {
     }
   }
 }
+function isMemberLike(node) {
+  return t.isMemberExpression(node) || t.isOptionalMemberExpression(node);
+}
 function getMemberExpressionRootAndPath(node) {
   const path2 = [];
   let current = node;
-  while (t.isMemberExpression(current)) {
-    if (current.computed)
-      return null;
-    if (!t.isIdentifier(current.property))
-      return null;
-    path2.push(current.property.name);
-    current = current.object;
+  while (true) {
+    if (t.isTSNonNullExpression(current)) {
+      current = current.expression;
+      continue;
+    }
+    if (isMemberLike(current)) {
+      if (current.computed)
+        return null;
+      if (!t.isIdentifier(current.property))
+        return null;
+      path2.push(current.property.name);
+      current = current.object;
+      continue;
+    }
+    break;
   }
   if (t.isIdentifier(current)) {
     return { root: current.name, path: path2.reverse() };
@@ -258,6 +315,9 @@ function getMemberExpressionRootAndPath(node) {
   return null;
 }
 function isReactiveRead(node, scope) {
+  if (t.isTSNonNullExpression(node)) {
+    return isReactiveRead(node.expression, scope);
+  }
   if (t.isIdentifier(node)) {
     const binding2 = scope.bindings.get(node.name);
     if (!binding2)
@@ -270,6 +330,8 @@ function isReactiveRead(node, scope) {
     }
     return false;
   }
+  if (!isMemberLike(node))
+    return false;
   const rootPath = getMemberExpressionRootAndPath(node);
   if (!rootPath)
     return false;
@@ -285,6 +347,9 @@ function isReactiveRead(node, scope) {
   if (binding.kind === "signal" || binding.kind === "computed") {
     return rootPath.path[0] === "value";
   }
+  if (binding.kind === "signalObject") {
+    return rootPath.path.length >= 2 && rootPath.path[1] === "value";
+  }
   return false;
 }
 function isGetterCall(node, scope) {
@@ -295,12 +360,17 @@ function isGetterCall(node, scope) {
   return binding?.kind === "getter";
 }
 function isReactiveValue(node, scope) {
+  if (t.isTSNonNullExpression(node)) {
+    return isReactiveValue(node.expression, scope);
+  }
   if (t.isIdentifier(node)) {
     const binding2 = scope.bindings.get(node.name);
     if (!binding2)
       return false;
     return binding2.kind === "prop" || binding2.kind === "signal" || binding2.kind === "computed" || binding2.kind === "mutable";
   }
+  if (!isMemberLike(node))
+    return false;
   const rootPath = getMemberExpressionRootAndPath(node);
   if (!rootPath)
     return false;
@@ -313,6 +383,9 @@ function isReactiveValue(node, scope) {
   if (binding.kind === "signal" || binding.kind === "computed") {
     return rootPath.path[0] === "value";
   }
+  if (binding.kind === "signalObject") {
+    return rootPath.path.length >= 2 && rootPath.path[1] === "value";
+  }
   return false;
 }
 function containsReactiveValue(expr, scope) {
@@ -322,7 +395,7 @@ function containsReactiveValue(expr, scope) {
       return;
     if (!node || typeof node !== "object")
       return;
-    if (t.isMemberExpression(node) || t.isIdentifier(node)) {
+    if (isMemberLike(node) || t.isTSNonNullExpression(node) || t.isIdentifier(node)) {
       if (isReactiveValue(node, scope)) {
         found = true;
         return;
@@ -359,7 +432,7 @@ function containsReactiveRead(expr, scope) {
       return;
     if (!node || typeof node !== "object")
       return;
-    if (t.isMemberExpression(node) || t.isIdentifier(node)) {
+    if (isMemberLike(node) || t.isTSNonNullExpression(node) || t.isIdentifier(node)) {
       if (isReactiveRead(node, scope)) {
         found = true;
         return;
@@ -430,7 +503,7 @@ function getComponentExpressionInfo(exprPath) {
   }
   return { isComponent: true, componentName, attributeName };
 }
-function isReactiveComponentProp(info, componentNames, reactiveProps) {
+function isReactiveComponentProp(info, componentNames, reactiveProps, importedReactiveProps) {
   if (!info.isComponent || !info.componentName || !info.attributeName) {
     return false;
   }
@@ -438,12 +511,16 @@ function isReactiveComponentProp(info, componentNames, reactiveProps) {
     return true;
   }
   const componentFn = componentNames.get(info.componentName);
-  if (!componentFn)
-    return false;
-  const props = reactiveProps.get(componentFn);
-  if (!props)
+  if (componentFn) {
+    const props = reactiveProps.get(componentFn);
+    if (!props)
+      return false;
+    return props.has(info.attributeName);
+  }
+  const importedProps = importedReactiveProps.get(info.componentName);
+  if (!importedProps)
     return false;
-  return props.has(info.attributeName);
+  return importedProps.has(info.attributeName);
 }
 function shouldWrap(expr, scope) {
   if (t.isArrowFunctionExpression(expr) || t.isFunctionExpression(expr))
@@ -452,6 +529,65 @@ function shouldWrap(expr, scope) {
     return false;
   return containsReactiveRead(expr, scope);
 }
+var RESOLVE_HELPER = "_$unwrap";
+function transformPropMemberAccess(expr, scope) {
+  let changed = false;
+  function resolveRoot(rootName) {
+    return t.callExpression(t.identifier(RESOLVE_HELPER), [
+      t.identifier(rootName)
+    ]);
+  }
+  function replaceMemberRoot(node, rootName) {
+    let current = node;
+    let parent = null;
+    while (true) {
+      if (t.isTSNonNullExpression(current)) {
+        current = current.expression;
+        continue;
+      }
+      if (!isMemberLike(current))
+        break;
+      parent = current;
+      current = current.object;
+    }
+    if (parent && t.isIdentifier(current) && current.name === rootName) {
+      parent.object = resolveRoot(rootName);
+    }
+  }
+  function visit(node) {
+    if (!node || typeof node !== "object")
+      return;
+    if (t.isArrowFunctionExpression(node) || t.isFunctionExpression(node))
+      return;
+    if (isMemberLike(node)) {
+      const rootPath = getMemberExpressionRootAndPath(node);
+      if (rootPath) {
+        const binding = scope.bindings.get(rootPath.root);
+        if (binding && binding.kind === "prop") {
+          replaceMemberRoot(node, rootPath.root);
+          changed = true;
+          return;
+        }
+      }
+      return;
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments")
+        continue;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item && typeof item === "object")
+            visit(item);
+        }
+      } else if (value && typeof value === "object") {
+        visit(value);
+      }
+    }
+  }
+  visit(expr);
+  return changed;
+}
 function wrapExpression(expr) {
   return t.arrowFunctionExpression([], expr);
 }
@@ -681,53 +817,219 @@ function propagateReactiveProps(localScopes, callGraph, componentFunctions) {
   return reactiveProps;
 }
 function wrapReactiveExpressions(ast, options = {}) {
-  const names = trackReactiveImports(ast);
-  const hasAnyImport = Object.values(names).some((s) => s.size > 0);
-  if (!hasAnyImport)
-    return;
-  const {
-    functions: componentFunctions,
-    names: componentNames,
-    exported
-  } = collectComponentFunctions(ast, names.cc);
-  const localScopes = computeLocalScopes(ast, names);
-  const callGraph = collectComponentCallGraph(ast, componentNames);
-  const reactiveProps = propagateReactiveProps(localScopes, callGraph, componentFunctions);
-  const exportNameByFn = new Map;
-  for (const [localName, fn] of componentNames) {
-    if (exported.has(fn)) {
-      exportNameByFn.set(fn, localName);
+  let metadata = null;
+  if (options.analyzeMetadata) {
+    metadata = options.analyzeMetadata;
+  } else if (options.analyze && options.filename) {
+    try {
+      metadata = loadMetadata(options.analyze);
+    } catch {
+      metadata = null;
     }
   }
+  const absoluteFilename = options.filename ? path.resolve(options.filename) : null;
+  const resolveImport = options.resolveImport;
+  const names = {
+    createMutable: new Set,
+    createStore: new Set,
+    signal: new Set,
+    computed: new Set,
+    useState: new Set,
+    useFetch: new Set,
+    cc: new Set
+  };
+  const componentFunctions = new Set;
+  const componentNames = new Map;
+  const exported = new Set;
+  const localScopes = new Map;
+  const callGraph = new Map;
+  const rawCallGraph = new Map;
+  const importedReactiveProps = new Map;
+  const exportNameByFn = new Map;
+  let hasUnwrapImport = false;
   traverse(ast, {
-    ExportDefaultDeclaration(path2) {
-      const decl = path2.node.declaration;
+    ImportDeclaration(p) {
+      const source = p.node.source.value;
+      const reactiveAllowed = REACTIVE_SOURCE_MODULES[source];
+      const componentAllowed = COMPONENT_FACTORY_MODULES[source];
+      if (reactiveAllowed || componentAllowed) {
+        for (const spec of p.node.specifiers) {
+          if (!t.isImportSpecifier(spec))
+            continue;
+          const imported = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+          if (reactiveAllowed?.has(imported)) {
+            names[imported].add(spec.local.name);
+          } else if (componentAllowed?.has(imported)) {
+            names.cc.add(spec.local.name);
+          }
+        }
+      }
+      if (source === "sinwan/reactivity") {
+        for (const spec of p.node.specifiers) {
+          if (t.isImportSpecifier(spec) && t.isIdentifier(spec.imported) && spec.imported.name === "unwrap") {
+            hasUnwrapImport = true;
+          }
+        }
+      }
+      if (metadata && absoluteFilename && resolveImport && source.startsWith(".")) {
+        const resolved = resolveImport(source, absoluteFilename);
+        if (resolved) {
+          const fileProps = metadata.get(resolved);
+          if (fileProps) {
+            for (const spec of p.node.specifiers) {
+              if (!t.isImportSpecifier(spec))
+                continue;
+              const imported = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+              if (!imported || !/^[A-Z]/.test(imported))
+                continue;
+              const props = fileProps.get(imported);
+              if (props && props.size > 0) {
+                importedReactiveProps.set(spec.local.name, new Set(props));
+              }
+            }
+          }
+        }
+      }
+    },
+    CallExpression(p) {
+      const callee = p.node.callee;
+      if (!t.isIdentifier(callee) || !names.cc.has(callee.name))
+        return;
+      const firstArg = p.node.arguments[0];
+      if (!firstArg || !t.isFunction(firstArg))
+        return;
+      const componentFn = firstArg;
+      componentFunctions.add(componentFn);
+      const parent = p.parentPath;
+      if (parent && parent.isVariableDeclarator && parent.isVariableDeclarator()) {
+        const id = parent.node.id;
+        if (t.isIdentifier(id)) {
+          componentNames.set(id.name, componentFn);
+        }
+      } else if (parent && parent.isExportNamedDeclaration && parent.isExportNamedDeclaration()) {
+        const declaration = parent.node.declaration;
+        if (t.isVariableDeclaration(declaration)) {
+          for (const decl of declaration.declarations) {
+            if (t.isIdentifier(decl.id)) {
+              componentNames.set(decl.id.name, componentFn);
+            }
+          }
+        }
+      }
+    },
+    ExportNamedDeclaration(p) {
+      const declaration = p.node.declaration;
+      if (!t.isVariableDeclaration(declaration))
+        return;
+      for (const decl of declaration.declarations) {
+        const init = decl.init;
+        if (!init || !t.isCallExpression(init))
+          continue;
+        const callee = init.callee;
+        if (!t.isIdentifier(callee) || !names.cc.has(callee.name))
+          continue;
+        const firstArg = init.arguments[0];
+        if (!firstArg || !t.isFunction(firstArg))
+          continue;
+        exported.add(firstArg);
+      }
+    },
+    ExportDefaultDeclaration(p) {
+      const decl = p.node.declaration;
       if (t.isIdentifier(decl)) {
         const fn = componentNames.get(decl.name);
-        if (fn)
+        if (fn) {
+          exported.add(fn);
           exportNameByFn.set(fn, "default");
+        }
       } else if (t.isCallExpression(decl)) {
         const callee = decl.callee;
         if (t.isIdentifier(callee) && names.cc.has(callee.name)) {
           const firstArg = decl.arguments[0];
           if (firstArg && t.isFunction(firstArg)) {
+            exported.add(firstArg);
             exportNameByFn.set(firstArg, "default");
           }
         }
       }
+    },
+    Function(p) {
+      const scope = { bindings: new Map };
+      trackLocalScopeBindings(p, names, scope);
+      localScopes.set(p.node, scope);
+    },
+    JSXElement(p) {
+      const name = p.node.openingElement.name;
+      if (!t.isJSXIdentifier(name))
+        return;
+      const callerPath = p.findParent((pp) => pp.isFunction());
+      const callerFn = callerPath ? callerPath.node : null;
+      if (!callerFn)
+        return;
+      const props = [];
+      const spreads = [];
+      for (const attr of p.node.openingElement.attributes) {
+        if (t.isJSXSpreadAttribute(attr)) {
+          if (attr.argument) {
+            spreads.push(attr.argument);
+          }
+          continue;
+        }
+        if (t.isJSXAttribute(attr)) {
+          const attrName = attr.name.name;
+          if (!attrName)
+            continue;
+          if (t.isJSXExpressionContainer(attr.value)) {
+            const expr = attr.value.expression;
+            if (!expr || t.isJSXEmptyExpression(expr))
+              continue;
+            props.push({ name: attrName, value: expr });
+          }
+        }
+      }
+      const childExprs = [];
+      for (const child of p.node.children) {
+        if (t.isJSXExpressionContainer(child)) {
+          const expr = child.expression;
+          if (!expr || t.isJSXEmptyExpression(expr))
+            continue;
+          childExprs.push(expr);
+        }
+      }
+      if (childExprs.length === 1) {
+        props.push({ name: "children", value: childExprs[0] });
+      } else if (childExprs.length > 1) {
+        props.push({ name: "children", value: t.arrayExpression(childExprs) });
+      }
+      const sites = rawCallGraph.get(callerFn) ?? [];
+      sites.push({ calleeName: name.name, props, spreads });
+      rawCallGraph.set(callerFn, sites);
     }
   });
-  let metadata = null;
-  if (options.analyzeMetadata) {
-    metadata = options.analyzeMetadata;
-  } else if (options.analyze && options.filename) {
-    try {
-      metadata = loadMetadata(options.analyze);
-    } catch {
-      metadata = null;
+  for (const [callerFn, sites] of rawCallGraph) {
+    const resolved = [];
+    for (const site of sites) {
+      const callee = componentNames.get(site.calleeName);
+      if (callee) {
+        resolved.push({ callee, props: site.props, spreads: site.spreads });
+      }
+    }
+    if (resolved.length > 0) {
+      callGraph.set(callerFn, resolved);
     }
   }
-  const absoluteFilename = options.filename ? path.resolve(options.filename) : null;
+  for (const [localName, fn] of componentNames) {
+    if (exported.has(fn)) {
+      if (!exportNameByFn.has(fn)) {
+        exportNameByFn.set(fn, localName);
+      }
+    }
+  }
+  const hasAnyImport = Object.values(names).some((s) => s.size > 0);
+  if (!hasAnyImport)
+    return;
+  const reactiveProps = propagateReactiveProps(localScopes, callGraph, componentFunctions);
+  let needsResolve = false;
   traverse(ast, {
     Function(path2) {
       const scope = localScopes.get(path2.node);
@@ -766,21 +1068,232 @@ function wrapReactiveExpressions(ast, options = {}) {
           const expr = exprPath.node.expression;
           const compInfo = getComponentExpressionInfo(exprPath);
           if (compInfo.isComponent) {
-            if (!isReactiveComponentProp(compInfo, componentNames, reactiveProps)) {
-              return;
+            if (compInfo.attributeName !== null) {
+              if (!isReactiveComponentProp(compInfo, componentNames, reactiveProps, importedReactiveProps)) {
+                return;
+              }
+            } else {
+              if (!isBuiltinControlFlowComponent(compInfo.componentName)) {
+                return;
+              }
             }
           }
           if (shouldWrap(expr, scope)) {
+            if (transformPropMemberAccess(expr, scope)) {
+              needsResolve = true;
+            }
             exprPath.replaceWith(t.jsxExpressionContainer(createBindingDescriptor(expr, exprPath, options)));
           }
         }
       });
     }
   });
+  if (needsResolve && !hasUnwrapImport) {
+    ast.program.body.unshift(t.importDeclaration([
+      t.importSpecifier(t.identifier(RESOLVE_HELPER), t.identifier("unwrap"))
+    ], t.stringLiteral("sinwan/reactivity")));
+  }
 }
 
-// src/analyze.ts
+// src/auto-cc.ts
+import * as t2 from "@babel/types";
+import _traverse2 from "@babel/traverse";
 var traverse2 = typeof _traverse2 === "function" ? _traverse2 : _traverse2.default ?? _traverse2;
+var CC_SOURCE_MODULES = new Set(["sinwan", "sinwan/component"]);
+var EXCLUDE_KEYS = new Set([
+  "loc",
+  "start",
+  "end",
+  "type",
+  "leadingComments",
+  "trailingComments",
+  "innerComments",
+  "extra"
+]);
+function isComponentName(name) {
+  return !!name && /^[A-Z]/.test(name);
+}
+function containsJsx(node, enterFunctions) {
+  if (!node || typeof node !== "object")
+    return false;
+  if (t2.isJSXElement(node) || t2.isJSXFragment(node))
+    return true;
+  if (!enterFunctions && (t2.isFunctionExpression(node) || t2.isArrowFunctionExpression(node) || t2.isFunctionDeclaration(node))) {
+    return false;
+  }
+  for (const key of Object.keys(node)) {
+    if (EXCLUDE_KEYS.has(key))
+      continue;
+    const val = node[key];
+    if (Array.isArray(val)) {
+      for (const item of val) {
+        if (item && typeof item === "object" && containsJsx(item, enterFunctions)) {
+          return true;
+        }
+      }
+    } else if (val && typeof val === "object" && containsJsx(val, enterFunctions)) {
+      return true;
+    }
+  }
+  return false;
+}
+function functionReturnsJsx(fnPath) {
+  const fn = fnPath.node;
+  if (t2.isArrowFunctionExpression(fn) && !t2.isBlockStatement(fn.body)) {
+    return containsJsx(fn.body, false);
+  }
+  let found = false;
+  fnPath.traverse({
+    ReturnStatement(p) {
+      if (p.node.argument && containsJsx(p.node.argument, false)) {
+        found = true;
+        p.stop();
+      }
+    },
+    Function(p) {
+      p.skip();
+    }
+  });
+  return found;
+}
+function isComponentArity(fn) {
+  if (t2.isFunctionDeclaration(fn) && fn.generator)
+    return false;
+  if ((t2.isFunctionExpression(fn) || t2.isArrowFunctionExpression(fn)) && fn.generator) {
+    return false;
+  }
+  return fn.params.length <= 1;
+}
+function collectCcAliases(ast) {
+  const aliases = new Set;
+  traverse2(ast, {
+    ImportDeclaration(path2) {
+      const source = path2.node.source.value;
+      if (!CC_SOURCE_MODULES.has(source))
+        return;
+      for (const spec of path2.node.specifiers) {
+        if (!t2.isImportSpecifier(spec))
+          continue;
+        const imported = t2.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+        if (imported === "cc") {
+          aliases.add(spec.local.name);
+        }
+      }
+    }
+  });
+  return { aliases, alreadyImported: aliases.size > 0 };
+}
+function ccCall(arg, ccName) {
+  return t2.callExpression(t2.identifier(ccName), [arg]);
+}
+function autoWrapComponents(ast, filename) {
+  const { aliases, alreadyImported } = collectCcAliases(ast);
+  const ccName = aliases.values().next().value;
+  let changed = false;
+  const wrapIfCandidate = (fnPath, name) => {
+    if (name !== null && !isComponentName(name))
+      return "not-candidate";
+    const fn = fnPath.node;
+    if (!isComponentArity(fn))
+      return "not-candidate";
+    if (!functionReturnsJsx(fnPath))
+      return "not-candidate";
+    return "wrapped";
+  };
+  traverse2(ast, {
+    ExportNamedDeclaration(path2) {
+      const decl = path2.node.declaration;
+      if (!decl)
+        return;
+      if (t2.isFunctionDeclaration(decl) && decl.id) {
+        const name = decl.id.name;
+        if (!isComponentName(name))
+          return;
+        const fnPath = path2.get("declaration");
+        if (!isComponentArity(decl))
+          return;
+        if (!functionReturnsJsx(fnPath))
+          return;
+        const fnExpr = t2.functionExpression(decl.id, decl.params, decl.body, decl.generator, decl.async);
+        const varDecl = t2.variableDeclaration("const", [
+          t2.variableDeclarator(t2.identifier(name), ccCall(fnExpr, ccName ?? "cc"))
+        ]);
+        path2.replaceWith(t2.exportNamedDeclaration(varDecl, []));
+        changed = true;
+        return;
+      }
+      if (t2.isVariableDeclaration(decl)) {
+        for (const dPath of path2.get("declaration.declarations")) {
+          const id = dPath.node.id;
+          if (!t2.isIdentifier(id) || !isComponentName(id.name))
+            continue;
+          const init = dPath.node.init;
+          if (!init)
+            continue;
+          if (t2.isCallExpression(init) && t2.isIdentifier(init.callee) && aliases.has(init.callee.name)) {
+            continue;
+          }
+          if (!t2.isFunction(init))
+            continue;
+          const initPath = dPath.get("init");
+          if (!isComponentArity(init))
+            continue;
+          if (!functionReturnsJsx(initPath))
+            continue;
+          dPath.node.init = ccCall(init, ccName ?? "cc");
+          changed = true;
+        }
+        return;
+      }
+    },
+    ExportDefaultDeclaration(path2) {
+      const decl = path2.node.declaration;
+      if (t2.isFunctionDeclaration(decl) && decl.id) {
+        const name = decl.id.name;
+        if (!isComponentName(name))
+          return;
+        const fnPath = path2.get("declaration");
+        if (!isComponentArity(decl))
+          return;
+        if (!functionReturnsJsx(fnPath))
+          return;
+        const fnDecl = t2.functionDeclaration(decl.id, decl.params, decl.body, decl.generator, decl.async);
+        const exportDefault = t2.exportDefaultDeclaration(ccCall(t2.identifier(name), ccName ?? "cc"));
+        path2.replaceWithMultiple([fnDecl, exportDefault]);
+        changed = true;
+        return;
+      }
+      if (t2.isFunctionDeclaration(decl) && !decl.id) {
+        const fnPath = path2.get("declaration");
+        if (!isComponentArity(decl))
+          return;
+        if (!functionReturnsJsx(fnPath))
+          return;
+        const fnExpr = t2.functionExpression(null, decl.params, decl.body, decl.generator, decl.async);
+        path2.node.declaration = ccCall(fnExpr, ccName ?? "cc");
+        changed = true;
+        return;
+      }
+      if (t2.isArrowFunctionExpression(decl) || t2.isFunctionExpression(decl)) {
+        const declPath = path2.get("declaration");
+        if (!isComponentArity(decl))
+          return;
+        if (!functionReturnsJsx(declPath))
+          return;
+        path2.node.declaration = ccCall(decl, ccName ?? "cc");
+        changed = true;
+        return;
+      }
+    }
+  });
+  if (changed && !alreadyImported) {
+    ast.program.body.unshift(t2.importDeclaration([t2.importSpecifier(t2.identifier("cc"), t2.identifier("cc"))], t2.stringLiteral("sinwan/component")));
+  }
+  return changed;
+}
+
+// src/analyze.ts
+var traverse3 = typeof _traverse3 === "function" ? _traverse3 : _traverse3.default ?? _traverse3;
 function functionRef(fn) {
   return { start: fn.start ?? -1, end: fn.end ?? -1 };
 }
@@ -789,7 +1302,7 @@ function refKey(ref) {
 }
 function findFunctionByRef(ast, ref) {
   let found = null;
-  traverse2(ast, {
+  traverse3(ast, {
     Function(path3) {
       const node = path3.node;
       if (node.start === ref.start && node.end === ref.end) {
@@ -945,15 +1458,15 @@ function parseRefKey(key) {
 }
 function collectImports(ast) {
   const imports = new Map;
-  traverse2(ast, {
+  traverse3(ast, {
     ImportDeclaration(path3) {
       const source = path3.node.source.value;
       for (const spec of path3.node.specifiers) {
-        if (t2.isImportSpecifier(spec)) {
+        if (t3.isImportSpecifier(spec)) {
           const localName = spec.local.name;
-          const importedName = t2.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+          const importedName = t3.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
           imports.set(localName, { source, importedName });
-        } else if (t2.isImportDefaultSpecifier(spec)) {
+        } else if (t3.isImportDefaultSpecifier(spec)) {
           imports.set(spec.local.name, { source, importedName: "default" });
         }
       }
@@ -963,10 +1476,10 @@ function collectImports(ast) {
 }
 function collectImportedCallSites(ast, componentNames, imports) {
   const sites = [];
-  traverse2(ast, {
+  traverse3(ast, {
     JSXElement(path3) {
       const name = path3.node.openingElement.name;
-      if (!t2.isJSXIdentifier(name))
+      if (!t3.isJSXIdentifier(name))
         return;
       const tagName = name.name;
       if (!/^[A-Z]/.test(tagName))
@@ -983,19 +1496,19 @@ function collectImportedCallSites(ast, componentNames, imports) {
       const props = [];
       const spreads = [];
       for (const attr of path3.node.openingElement.attributes) {
-        if (t2.isJSXSpreadAttribute(attr)) {
+        if (t3.isJSXSpreadAttribute(attr)) {
           if (attr.argument) {
             spreads.push(attr.argument);
           }
           continue;
         }
-        if (t2.isJSXAttribute(attr)) {
+        if (t3.isJSXAttribute(attr)) {
           const attrName = attr.name.name;
           if (!attrName)
             continue;
-          if (t2.isJSXExpressionContainer(attr.value)) {
+          if (t3.isJSXExpressionContainer(attr.value)) {
             const expr = attr.value.expression;
-            if (!expr || t2.isJSXEmptyExpression(expr))
+            if (!expr || t3.isJSXEmptyExpression(expr))
               continue;
             props.push({ name: attrName, value: expr });
           }
@@ -1003,9 +1516,9 @@ function collectImportedCallSites(ast, componentNames, imports) {
       }
       const childExprs = [];
       for (const child of path3.node.children) {
-        if (t2.isJSXExpressionContainer(child)) {
+        if (t3.isJSXExpressionContainer(child)) {
           const expr = child.expression;
-          if (!expr || t2.isJSXEmptyExpression(expr))
+          if (!expr || t3.isJSXEmptyExpression(expr))
             continue;
           childExprs.push(expr);
         }
@@ -1013,7 +1526,7 @@ function collectImportedCallSites(ast, componentNames, imports) {
       if (childExprs.length === 1) {
         props.push({ name: "children", value: childExprs[0] });
       } else if (childExprs.length > 1) {
-        props.push({ name: "children", value: t2.arrayExpression(childExprs) });
+        props.push({ name: "children", value: t3.arrayExpression(childExprs) });
       }
       sites.push({
         caller: callerFn,
@@ -1031,6 +1544,7 @@ function analyzeModule(code, filePath) {
     sourceType: "module",
     plugins: ["jsx", "typescript"]
   });
+  autoWrapComponents(ast, filePath);
   const names = trackReactiveImports(ast);
   const {
     functions,
@@ -1048,18 +1562,18 @@ function analyzeModule(code, filePath) {
       exports.set(localName, fn);
     }
   }
-  traverse2(ast, {
+  traverse3(ast, {
     ExportDefaultDeclaration(path3) {
       const decl = path3.node.declaration;
-      if (t2.isIdentifier(decl)) {
+      if (t3.isIdentifier(decl)) {
         const fn = componentNames.get(decl.name);
         if (fn)
           defaultExport = fn;
-      } else if (t2.isCallExpression(decl)) {
+      } else if (t3.isCallExpression(decl)) {
         const callee = decl.callee;
-        if (t2.isIdentifier(callee) && names.cc.has(callee.name)) {
+        if (t3.isIdentifier(callee) && names.cc.has(callee.name)) {
           const firstArg = decl.arguments[0];
-          if (firstArg && t2.isFunction(firstArg)) {
+          if (firstArg && t3.isFunction(firstArg)) {
             defaultExport = firstArg;
           }
         }
@@ -1845,4 +2359,4 @@ if (import.meta.main) {
   runAnalyzeCli();
 }
 
-export { analyzeModule, analyzeProject, AnalyzerCache, analyze, loadMetadata, trackReactiveImports, getAllPropNames, isReactiveValue, containsReactiveValue, collectComponentFunctions, computeLocalScopes, collectComponentCallGraph, buildFullScope, propagateReactiveProps, wrapReactiveExpressions, runAnalyzeCli };
+export { autoWrapComponents, analyzeModule, analyzeProject, AnalyzerCache, analyze, loadMetadata, trackReactiveImports, getAllPropNames, isReactiveValue, containsReactiveValue, collectComponentFunctions, computeLocalScopes, collectComponentCallGraph, buildFullScope, propagateReactiveProps, wrapReactiveExpressions, runAnalyzeCli };

package/dist/cli.js

@@ -2,7 +2,7 @@
 // @bun
 import {
   runAnalyzeCli
-} from "./chunk-3bqqn28f.js";
+} from "./chunk-w580fdrf.js";
 export {
   runAnalyzeCli
 };

package/dist/exports.d.ts

@@ -0,0 +1,27 @@
+/**
+ * SinwanJS Compiler — Exported component detection.
+ *
+ * Shared utility for detecting top-level exported component bindings in a
+ * module. Used by the Vite and Bun plugins for HMR boundary injection.
+ *
+ * Detection is intentionally conservative: only top-level exports whose name
+ * starts with an uppercase letter (the component naming convention) are
+ * returned. The runtime safely ignores anything that is not used as a
+ * component, so over-matching is harmless.
+ */
+export interface ExportedComponent {
+    /** Local binding name in the module (referenced in the accept callback). */
+    local: string;
+    /** Export key on the module namespace ("default" for the default export). */
+    key: string;
+}
+/**
+ * Collect top-level exported component bindings from a module source string.
+ *
+ * Parses the source with Babel, then walks top-level export declarations to
+ * find functions and variables whose name starts with an uppercase letter.
+ *
+ * Returns an array of `{ local, key }` pairs. Returns an empty array if the
+ * source cannot be parsed.
+ */
+export declare function collectExportedComponents(code: string, filename: string): ExportedComponent[];

package/dist/index.d.ts

@@ -5,6 +5,9 @@
  * used by the Bun and Vite plugins.
  */
 export { transformJSX, type TransformOptions } from "./transform";
+export { COMPILER_TEMPLATE_SLOT_PROTOCOL } from "./transform";
+export { autoWrapComponents } from "./auto-cc";
 export { analyze, analyzeProject, analyzeModule, loadMetadata, AnalyzerCache, type AnalyzeOptions, type ModuleAnalysis, type ProjectAnalysis, type ImportedCallSite, type ImportInfo, type WorkspacesConfig, } from "./analyze";
+export { collectExportedComponents, type ExportedComponent } from "./exports";
 export { runAnalyzeCli } from "./cli";
 export { wrapReactiveExpressions, trackReactiveImports, collectComponentFunctions, computeLocalScopes, collectComponentCallGraph, propagateReactiveProps, buildFullScope, containsReactiveValue, getAllPropNames, isReactiveValue, type ReactiveScope, type Binding, type CallSite, type ImportNames, type ComponentExpressionInfo, } from "./reactive-wrap";

package/dist/index.js

@@ -4,6 +4,7 @@ import {
   analyze,
   analyzeModule,
   analyzeProject,
+  autoWrapComponents,
   buildFullScope,
   collectComponentCallGraph,
   collectComponentFunctions,
@@ -16,7 +17,7 @@ import {
   runAnalyzeCli,
   trackReactiveImports,
   wrapReactiveExpressions
-} from "./chunk-3bqqn28f.js";
+} from "./chunk-w580fdrf.js";
 
 // src/transform.ts
 import { parse } from "@babel/parser";
@@ -25,10 +26,21 @@ import * as t from "@babel/types";
 import _traverse from "@babel/traverse";
 var generate = typeof _generate === "function" ? _generate : _generate.default ?? _generate;
 var traverse = typeof _traverse === "function" ? _traverse : _traverse.default ?? _traverse;
-var SLOT_PREFIX = "s";
-var slotId = 0;
-function nextSlotId() {
-  return `<!--${SLOT_PREFIX}:${slotId++}-->`;
+var COMPILER_TEMPLATE_SLOT_PROTOCOL = {
+  slotPrefix: "s",
+  encodeSlot(index) {
+    return `s:${index}`;
+  },
+  decodeSlot(data) {
+    if (data.startsWith("s:")) {
+      const idx = parseInt(data.slice(2), 10);
+      return Number.isNaN(idx) ? null : idx;
+    }
+    return null;
+  }
+};
+function nextSlotId(counter) {
+  return `<!--${COMPILER_TEMPLATE_SLOT_PROTOCOL.encodeSlot(counter.value++)}-->`;
 }
 var VOID_ELEMENTS = new Set([
   "area",
@@ -81,9 +93,9 @@ function cleanJSXText(value) {
   return str;
 }
 function extractTemplate(node, filename) {
-  slotId = 0;
+  const counter = { value: 0 };
   const slots = [];
-  const html = elementToHtml(node, slots, [], filename);
+  const html = elementToHtml(node, slots, [], filename, counter);
   return { html, slots };
 }
 function warnSuspectedStyleInterpolation(attrValue, filename, line) {
@@ -153,7 +165,7 @@ function serializeStyleValue(expr) {
   }
   return parts.join(";");
 }
-function elementToHtml(node, slots, path, filename) {
+function elementToHtml(node, slots, path, filename, counter) {
   const tagName = jsxNameToString(node.openingElement.name);
   if (tagName === "")
     return "";
@@ -204,8 +216,15 @@ function elementToHtml(node, slots, path, filename) {
   html += isVoid ? " />" : ">";
   if (isVoid)
     return html;
-  let childIndex = 0;
-  for (const child of node.children) {
+  const childResult = childrenToHtml(node.children, slots, path, filename, 0, counter);
+  html += childResult.html;
+  html += `</${tagName}>`;
+  return html;
+}
+function childrenToHtml(children, slots, path, filename, startIndex, counter) {
+  let html = "";
+  let childIndex = startIndex;
+  for (const child of children) {
     if (child.type === "JSXText") {
       const text = cleanJSXText(child.value ?? "");
       if (text) {
@@ -215,7 +234,7 @@ function elementToHtml(node, slots, path, filename) {
     } else if (child.type === "JSXExpressionContainer") {
       if (child.expression.type === "JSXEmptyExpression")
         continue;
-      const slot = nextSlotId();
+      const slot = nextSlotId(counter);
       slots.push({
         path: [...path, childIndex],
         type: "child",
@@ -224,12 +243,29 @@ function elementToHtml(node, slots, path, filename) {
       html += slot;
       childIndex++;
     } else if (child.type === "JSXElement") {
-      html += elementToHtml(child, slots, [...path, childIndex], filename);
-      childIndex++;
+      const childName = child.openingElement.name;
+      const childTag = childName.type === "JSXIdentifier" ? childName.name : "";
+      const isFirstCharUpper = childTag && childTag.charAt(0) === childTag.charAt(0).toUpperCase();
+      if (isFirstCharUpper) {
+        const slot = nextSlotId(counter);
+        slots.push({
+          path: [...path, childIndex],
+          type: "child",
+          expr: child
+        });
+        html += slot;
+        childIndex++;
+      } else {
+        html += elementToHtml(child, slots, [...path, childIndex], filename, counter);
+        childIndex++;
+      }
+    } else if (child.type === "JSXFragment") {
+      const fragResult = childrenToHtml(child.children, slots, path, filename, childIndex, counter);
+      html += fragResult.html;
+      childIndex = fragResult.childIndex;
     }
   }
-  html += `</${tagName}>`;
-  return html;
+  return { html, childIndex };
 }
 function jsxNameToString(name) {
   if (name.type === "JSXIdentifier")
@@ -245,10 +281,12 @@ function transformJSX(code, filename, options = {}) {
     plugins: ["jsx", "typescript"],
     sourceFilename: filename
   });
+  autoWrapComponents(ast, filename);
   wrapReactiveExpressions(ast, {
     explicitBindings: options.explicitBindings,
     analyze: options.analyze,
     analyzeMetadata: options.analyzeMetadata,
+    resolveImport: options.resolveImport,
     filename
   });
   const hoist = options.hoist !== false;
@@ -275,10 +313,23 @@ function transformJSX(code, filename, options = {}) {
         const templateExpr = t.callExpression(t.identifier("_$createTemplate"), [t.identifier(tmplId), t.arrayExpression(dynamicExprs)]);
         const parentIsJSX = path.parentPath?.isJSXElement() || path.parentPath?.isJSXFragment();
         path.replaceWith(parentIsJSX ? t.jsxExpressionContainer(templateExpr) : templateExpr);
-      } catch {}
+      } catch (err) {
+        if (options.dev) {
+          console.warn(`[Sinwan] template hoisting skipped in ${filename}: ${err.message}`);
+        }
+      }
     }
   });
   if (templates.length === 0) {
+    if (options.explicitBindings) {
+      const bindingImport = t.importDeclaration([
+        t.importSpecifier(t.identifier("_$bindText"), t.identifier("_$bindText")),
+        t.importSpecifier(t.identifier("_$bindAttr"), t.identifier("_$bindAttr")),
+        t.importSpecifier(t.identifier("_$bindStyle"), t.identifier("_$bindStyle")),
+        t.importSpecifier(t.identifier("_$bindClass"), t.identifier("_$bindClass"))
+      ], t.stringLiteral("sinwan/renderer"));
+      ast.program.body.unshift(bindingImport);
+    }
     const result2 = generate(ast, {
       sourceMaps: true,
       sourceFileName: filename
@@ -308,22 +359,81 @@ function transformJSX(code, filename, options = {}) {
   const result = generate(ast, { sourceMaps: true, sourceFileName: filename });
   return { code: result.code, map: result.map };
 }
+// src/exports.ts
+import { parse as parse2 } from "@babel/parser";
+function isComponentName(name) {
+  return !!name && name[0] === name[0].toUpperCase() && /^[A-Z]/.test(name);
+}
+function collectExportedComponents(code, filename) {
+  let ast;
+  try {
+    ast = parse2(code, {
+      sourceType: "module",
+      plugins: ["jsx", "typescript"],
+      sourceFilename: filename
+    });
+  } catch {
+    return [];
+  }
+  const found = [];
+  const seen = new Set;
+  const add = (local, key) => {
+    const sig = `${local}::${key}`;
+    if (seen.has(sig))
+      return;
+    seen.add(sig);
+    found.push({ local, key });
+  };
+  for (const node of ast.program.body) {
+    if (node.type === "ExportNamedDeclaration") {
+      if (node.declaration) {
+        const decl = node.declaration;
+        if (decl.type === "FunctionDeclaration" && decl.id && isComponentName(decl.id.name)) {
+          add(decl.id.name, decl.id.name);
+        } else if (decl.type === "VariableDeclaration") {
+          for (const d of decl.declarations) {
+            if (d.id?.type === "Identifier" && isComponentName(d.id.name)) {
+              add(d.id.name, d.id.name);
+            }
+          }
+        }
+      } else if (node.specifiers && !node.source) {
+        for (const spec of node.specifiers) {
+          if (spec.type === "ExportSpecifier" && spec.local?.type === "Identifier" && spec.exported?.type === "Identifier" && isComponentName(spec.exported.name)) {
+            add(spec.local.name, spec.exported.name);
+          }
+        }
+      }
+    } else if (node.type === "ExportDefaultDeclaration") {
+      const decl = node.declaration;
+      if (decl.type === "Identifier") {
+        add(decl.name, "default");
+      } else if (decl.type === "FunctionDeclaration" && decl.id) {
+        add(decl.id.name, "default");
+      }
+    }
+  }
+  return found;
+}
 export {
-  wrapReactiveExpressions,
-  transformJSX,
-  trackReactiveImports,
-  runAnalyzeCli,
-  propagateReactiveProps,
-  loadMetadata,
-  isReactiveValue,
-  getAllPropNames,
-  containsReactiveValue,
-  computeLocalScopes,
-  collectComponentFunctions,
-  collectComponentCallGraph,
-  buildFullScope,
-  analyzeProject,
-  analyzeModule,
+  AnalyzerCache,
+  COMPILER_TEMPLATE_SLOT_PROTOCOL,
   analyze,
-  AnalyzerCache
+  analyzeModule,
+  analyzeProject,
+  autoWrapComponents,
+  buildFullScope,
+  collectComponentCallGraph,
+  collectComponentFunctions,
+  collectExportedComponents,
+  computeLocalScopes,
+  containsReactiveValue,
+  getAllPropNames,
+  isReactiveValue,
+  loadMetadata,
+  propagateReactiveProps,
+  runAnalyzeCli,
+  trackReactiveImports,
+  transformJSX,
+  wrapReactiveExpressions
 };

package/dist/reactive-wrap.d.ts

@@ -8,7 +8,7 @@
  * Supported reactive sources:
  *   - `createMutable` / `createStore` from `sinwan/store`
  *   - `signal` / `computed` from `sinwan/reactivity`
- *   - `useState` from `sinwan/react-client`
+ *   - `useState` from `sinwan/react`
  *
  * Example:
  *   <p>{state.name}</p>        → <p>{() => state.name}</p>
@@ -22,6 +22,7 @@ export interface ImportNames {
     signal: Set<string>;
     computed: Set<string>;
     useState: Set<string>;
+    useFetch: Set<string>;
     cc: Set<string>;
 }
 export declare function trackReactiveImports(ast: t.Node): ImportNames;
@@ -39,15 +40,26 @@ export interface ComputedBinding {
 export interface GetterBinding {
     kind: "getter";
 }
+/**
+ * Binding for a variable holding the object returned by `useFetch()` /
+ * `createFetch()(...)`. Every property on that object is a `Signal` or
+ * `Computed`, so a read like `f.data.value` (path `["data", "value"]`) is
+ * reactive. The shell object itself (`f`) and a bare property (`f.data`, the
+ * signal object) are NOT reactive reads — the runtime `resolve()` unwraps them
+ * inside effects when forwarded to control-flow props such as `<Show when>`.
+ */
+export interface SignalObjectBinding {
+    kind: "signalObject";
+}
 export interface PropBinding {
     kind: "prop";
 }
-export type Binding = MutableBinding | SignalBinding | ComputedBinding | GetterBinding | PropBinding;
+export type Binding = MutableBinding | SignalBinding | ComputedBinding | GetterBinding | SignalObjectBinding | PropBinding;
 export interface ReactiveScope {
     bindings: Map<string, Binding>;
 }
 export declare function getAllPropNames(params: t.Node | undefined): Set<string>;
-export declare function isReactiveValue(node: t.Identifier | t.MemberExpression, scope: ReactiveScope): boolean;
+export declare function isReactiveValue(node: t.Node, scope: ReactiveScope): boolean;
 export declare function containsReactiveValue(expr: t.Expression, scope: ReactiveScope): boolean;
 export interface ComponentExpressionInfo {
     isComponent: boolean;
@@ -76,5 +88,6 @@ export declare function wrapReactiveExpressions(ast: t.Node, options?: {
     explicitBindings?: boolean;
     analyze?: string;
     analyzeMetadata?: Map<string, Map<string, Set<string>>>;
+    resolveImport?: (source: string, fromFile: string) => string | null;
     filename?: string;
 }): void;

package/dist/transform.d.ts

@@ -16,7 +16,29 @@ export interface TransformOptions {
     analyze?: string;
     /** In-memory reactive-props metadata (used by plugin-level caches). */
     analyzeMetadata?: Map<string, Map<string, Set<string>>>;
+    /**
+     * Resolves an import source (e.g. "./Child") to an absolute file path,
+     * relative to the file being transformed. Used to look up reactive-prop
+     * metadata for components imported from other modules so reactive values
+     * passed to them are wrapped at the call site. When omitted, cross-module
+     * component call sites fall back to the conservative (non-wrapping) behavior.
+     */
+    resolveImport?: (source: string, fromFile: string) => string | null;
 }
+/**
+ * Template slot marker encoding.
+ *
+ * This mirrors the runtime's `DEFAULT_TEMPLATE_SLOT_PROTOCOL` in
+ * `sinwan/src/renderer/template-protocol.ts`. The compiler cannot import the
+ * runtime (separate packages), so the format is duplicated here. A drift test
+ * (`sinwan/__tests__/compiler-protocol-drift.test.ts`) asserts the two stay
+ * in sync.
+ */
+export declare const COMPILER_TEMPLATE_SLOT_PROTOCOL: {
+    readonly slotPrefix: "s";
+    readonly encodeSlot: (index: number) => string;
+    readonly decodeSlot: (data: string) => number | null;
+};
 export declare function transformJSX(code: string, filename: string, options?: TransformOptions): {
     code: string;
     map?: any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sinwan-compiler",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Shared compiler core for Sinwan plugins",
   "type": "module",
   "main": "./dist/index.js",