@fictjs/compiler 0.14.0 → 0.15.0

package/README.md

@@ -56,6 +56,9 @@ createFictPlugin({
   - `'auto'` (default): writes metadata to cache directory (not source tree) only when no external metadata store/resolver is provided.
 - `moduleMetadataCacheDir` (default: `<cwd>/.fict-cache/metadata`): cache directory used by `emitModuleMetadata: 'auto'`.
 - `moduleMetadata` / `resolveModuleMetadata`: external metadata integration hooks. When provided, `'auto'` does not write metadata files.
+  - Built-in metadata resolution only covers local filesystem modules (relative/absolute paths + configured alias/ts resolution from the caller).
+  - Bare package imports are treated as opaque unless your `resolveModuleMetadata` hook provides metadata.
+  - Cross-module metadata lookup does not perform cycle detection; cyclical hook metadata chains should be handled by a custom resolver if needed.
 - `reactiveScopes`: function names whose **first callback argument** is treated as a component-like reactive scope.
   - Only **direct calls** are recognized (e.g., `renderHook(() => ...)` or `utils.renderHook(() => ...)`).
   - **Aliases/indirect calls** are not recognized (e.g., `const rh = renderHook; rh(() => ...)`).

package/dist/index.cjs

@@ -14174,6 +14174,7 @@ var RUNTIME_HELPERS = {
   bindEvent: "bindEvent",
   callEventHandler: "callEventHandler",
   bindRef: "bindRef",
+  spread: "spread",
   nonReactive: "nonReactive",
   toNodeArray: "toNodeArray",
   template: "template",
@@ -14231,6 +14232,7 @@ var RUNTIME_ALIASES = {
   bindEvent: "bindEvent",
   callEventHandler: "callEventHandler",
   bindRef: "bindRef",
+  spread: "spread",
   nonReactive: "nonReactive",
   toNodeArray: "toNodeArray",
   template: "template",
@@ -22616,138 +22618,212 @@ function emitConditionalChild(startMarkerId, endMarkerId, expr, statements, ctx,
   );
 }
 
-// src/ir/codegen-expression-deps.ts
-function getMemberDependencyPath(expr) {
-  if (expr.kind === "MemberExpression") {
-    const prop = expr.property;
-    let propName;
-    if (!expr.computed && prop.kind === "Identifier") {
-      propName = prop.name;
-    } else if (prop.kind === "Literal" && typeof prop.value === "string") {
-      propName = prop.value;
-    }
-    if (!propName) return void 0;
-    const object = expr.object;
-    if (object.kind === "Identifier") {
-      return `${deSSAVarName(object.name)}.${propName}`;
-    }
-    if (object.kind === "MemberExpression") {
-      const parent = getMemberDependencyPath(object);
-      return parent ? `${parent}.${propName}` : void 0;
-    }
+// src/ir/walk-expression.ts
+function assertNever(value) {
+  throw new Error(`Unhandled node in walkExpression: ${JSON.stringify(value)}`);
+}
+function walkTerminator(term, visitNode, inFunctionBody) {
+  switch (term.kind) {
+    case "Return":
+      if (term.argument) visitNode(term.argument, null, inFunctionBody);
+      return;
+    case "Throw":
+      visitNode(term.argument, null, inFunctionBody);
+      return;
+    case "Branch":
+      visitNode(term.test, null, inFunctionBody);
+      return;
+    case "Switch":
+      visitNode(term.discriminant, null, inFunctionBody);
+      term.cases.forEach((c) => {
+        if (c.test) visitNode(c.test, null, inFunctionBody);
+      });
+      return;
+    case "ForOf":
+      visitNode(term.iterable, null, inFunctionBody);
+      return;
+    case "ForIn":
+      visitNode(term.object, null, inFunctionBody);
+      return;
+    case "Jump":
+    case "Unreachable":
+    case "Break":
+    case "Continue":
+    case "Try":
+      return;
+    default:
+      assertNever(term);
   }
-  return void 0;
 }
-function collectBlockDependencies(blocks, deps) {
+function walkInstruction(instr, visitNode, inFunctionBody) {
+  switch (instr.kind) {
+    case "Assign":
+    case "Expression":
+      visitNode(instr.value, null, inFunctionBody);
+      return;
+    case "Phi":
+      instr.sources.forEach((source) => visitNode(source.id, null, inFunctionBody));
+      return;
+    default:
+      assertNever(instr);
+  }
+}
+function walkBlocks(blocks, visitNode, inFunctionBody) {
   for (const block of blocks) {
-    for (const instr of block.instructions) {
-      switch (instr.kind) {
-        case "Assign":
-        case "Expression":
-          collectExpressionDependencies(instr.value, deps);
-          break;
-        case "Phi":
-          for (const source of instr.sources) {
-            deps.add(deSSAVarName(source.id.name));
+    block.instructions.forEach((instr) => walkInstruction(instr, visitNode, inFunctionBody));
+    walkTerminator(block.terminator, visitNode, inFunctionBody);
+  }
+}
+function walkExpression(expr, visit, options = {}) {
+  const includeFunctionBodies = options.includeFunctionBodies ?? true;
+  const visitNode = (node, parent, inFunctionBody) => {
+    visit(node, { parent, inFunctionBody });
+    switch (node.kind) {
+      case "Identifier":
+      case "Literal":
+      case "MetaProperty":
+      case "ThisExpression":
+      case "SuperExpression":
+        return;
+      case "ImportExpression":
+        visitNode(node.source, node, inFunctionBody);
+        return;
+      case "CallExpression":
+      case "OptionalCallExpression":
+        visitNode(node.callee, node, inFunctionBody);
+        node.arguments.forEach((arg) => visitNode(arg, node, inFunctionBody));
+        return;
+      case "MemberExpression":
+      case "OptionalMemberExpression":
+        visitNode(node.object, node, inFunctionBody);
+        if (node.computed) {
+          visitNode(node.property, node, inFunctionBody);
+        }
+        return;
+      case "BinaryExpression":
+      case "LogicalExpression":
+        visitNode(node.left, node, inFunctionBody);
+        visitNode(node.right, node, inFunctionBody);
+        return;
+      case "UnaryExpression":
+      case "AwaitExpression":
+        visitNode(node.argument, node, inFunctionBody);
+        return;
+      case "ConditionalExpression":
+        visitNode(node.test, node, inFunctionBody);
+        visitNode(node.consequent, node, inFunctionBody);
+        visitNode(node.alternate, node, inFunctionBody);
+        return;
+      case "ArrayExpression":
+        node.elements.forEach((el) => visitNode(el, node, inFunctionBody));
+        return;
+      case "ObjectExpression":
+        node.properties.forEach((prop) => {
+          if (prop.kind === "SpreadElement") {
+            visitNode(prop.argument, node, inFunctionBody);
+          } else {
+            if (prop.computed) {
+              visitNode(prop.key, node, inFunctionBody);
+            }
+            visitNode(prop.value, node, inFunctionBody);
           }
-          break;
-        default:
-          break;
-      }
-    }
-    const term = block.terminator;
-    switch (term.kind) {
-      case "Return":
-        if (term.argument) collectExpressionDependencies(term.argument, deps);
-        break;
-      case "Throw":
-        collectExpressionDependencies(term.argument, deps);
-        break;
-      case "Branch":
-        collectExpressionDependencies(term.test, deps);
-        break;
-      case "Switch":
-        collectExpressionDependencies(term.discriminant, deps);
-        for (const c of term.cases) {
-          if (c.test) collectExpressionDependencies(c.test, deps);
+        });
+        return;
+      case "JSXElement":
+        if (typeof node.tagName !== "string") {
+          visitNode(node.tagName, node, inFunctionBody);
         }
-        break;
-      case "ForOf":
-        collectExpressionDependencies(term.iterable, deps);
-        break;
-      case "ForIn":
-        collectExpressionDependencies(term.object, deps);
-        break;
+        node.attributes.forEach((attr) => {
+          if (attr.isSpread && attr.spreadExpr) {
+            visitNode(attr.spreadExpr, node, inFunctionBody);
+          } else if (attr.value) {
+            visitNode(attr.value, node, inFunctionBody);
+          }
+        });
+        node.children.forEach((child) => {
+          if (child.kind === "expression") {
+            visitNode(child.value, node, inFunctionBody);
+          } else if (child.kind === "element") {
+            visitNode(child.value, node, inFunctionBody);
+          }
+        });
+        return;
+      case "ArrowFunction":
+        if (!includeFunctionBodies) return;
+        if (node.isExpression && !Array.isArray(node.body)) {
+          visitNode(node.body, node, true);
+        } else if (Array.isArray(node.body)) {
+          walkBlocks(node.body, visitNode, true);
+        }
+        return;
+      case "FunctionExpression":
+        if (!includeFunctionBodies) return;
+        walkBlocks(node.body, visitNode, true);
+        return;
+      case "AssignmentExpression":
+        visitNode(node.left, node, inFunctionBody);
+        visitNode(node.right, node, inFunctionBody);
+        return;
+      case "UpdateExpression":
+        visitNode(node.argument, node, inFunctionBody);
+        return;
+      case "TemplateLiteral":
+        node.expressions.forEach((item) => visitNode(item, node, inFunctionBody));
+        return;
+      case "SpreadElement":
+        visitNode(node.argument, node, inFunctionBody);
+        return;
+      case "NewExpression":
+        visitNode(node.callee, node, inFunctionBody);
+        node.arguments.forEach((arg) => visitNode(arg, node, inFunctionBody));
+        return;
+      case "SequenceExpression":
+        node.expressions.forEach((item) => visitNode(item, node, inFunctionBody));
+        return;
+      case "YieldExpression":
+        if (node.argument) {
+          visitNode(node.argument, node, inFunctionBody);
+        }
+        return;
+      case "TaggedTemplateExpression":
+        visitNode(node.tag, node, inFunctionBody);
+        node.quasi.expressions.forEach((item) => visitNode(item, node, inFunctionBody));
+        return;
+      case "ClassExpression":
+        if (node.superClass) {
+          visitNode(node.superClass, node, inFunctionBody);
+        }
+        return;
       default:
-        break;
+        assertNever(node);
     }
+  };
+  visitNode(expr, null, false);
+}
+
+// src/ir/codegen-expression-deps.ts
+function getMemberDependencyPath(expr) {
+  if (expr.kind !== "MemberExpression" && expr.kind !== "OptionalMemberExpression") return void 0;
+  const depPath = extractDependencyPath(expr);
+  if (!depPath || depPath.segments.length === 0) return void 0;
+  const base = deSSAVarName(depPath.base);
+  if (depPath.segments.some((segment) => segment.computed)) {
+    return base;
   }
+  const tail = depPath.segments.map((segment) => segment.property).join(".");
+  return tail ? `${base}.${tail}` : void 0;
 }
 function collectExpressionDependencies(expr, deps) {
-  if (expr.kind === "Identifier") {
-    deps.add(deSSAVarName(expr.name));
-    return;
-  }
-  if (expr.kind === "ArrowFunction") {
-    if (expr.isExpression && !Array.isArray(expr.body)) {
-      collectExpressionDependencies(expr.body, deps);
-    } else if (Array.isArray(expr.body)) {
-      collectBlockDependencies(expr.body, deps);
+  walkExpression(expr, (node) => {
+    if (node.kind === "Identifier") {
+      deps.add(deSSAVarName(node.name));
+      return;
     }
-    return;
-  }
-  if (expr.kind === "FunctionExpression") {
-    collectBlockDependencies(expr.body, deps);
-    return;
-  }
-  if (expr.kind === "MemberExpression") {
-    const path2 = getMemberDependencyPath(expr);
-    if (path2) deps.add(path2);
-    collectExpressionDependencies(expr.object, deps);
-    if (expr.computed && expr.property.kind !== "Literal") {
-      collectExpressionDependencies(expr.property, deps);
+    const path2 = getMemberDependencyPath(node);
+    if (path2) {
+      deps.add(path2);
     }
-    return;
-  }
-  if (expr.kind === "CallExpression") {
-    collectExpressionDependencies(expr.callee, deps);
-    expr.arguments.forEach((a) => collectExpressionDependencies(a, deps));
-    return;
-  }
-  if (expr.kind === "BinaryExpression" || expr.kind === "LogicalExpression") {
-    collectExpressionDependencies(expr.left, deps);
-    collectExpressionDependencies(expr.right, deps);
-    return;
-  }
-  if (expr.kind === "ConditionalExpression") {
-    collectExpressionDependencies(expr.test, deps);
-    collectExpressionDependencies(expr.consequent, deps);
-    collectExpressionDependencies(expr.alternate, deps);
-    return;
-  }
-  if (expr.kind === "UnaryExpression") {
-    collectExpressionDependencies(expr.argument, deps);
-    return;
-  }
-  if (expr.kind === "ArrayExpression") {
-    expr.elements.forEach((el) => collectExpressionDependencies(el, deps));
-    return;
-  }
-  if (expr.kind === "ObjectExpression") {
-    expr.properties.forEach((p) => {
-      if (p.kind === "SpreadElement") {
-        collectExpressionDependencies(p.argument, deps);
-      } else {
-        if (p.computed) collectExpressionDependencies(p.key, deps);
-        collectExpressionDependencies(p.value, deps);
-      }
-    });
-    return;
-  }
-  if (expr.kind === "TemplateLiteral") {
-    expr.expressions.forEach((e) => collectExpressionDependencies(e, deps));
-    return;
-  }
+  });
 }
 
 // src/ir/codegen-reactive-kind.ts
@@ -26125,8 +26201,31 @@ function extractHIRStaticHtml(jsx, ctx, ops, parentPath = [], namespace = null)
   const resolvedNamespace = resolveNamespaceContext(tagName, namespace);
   let html = `<${tagName}`;
   const bindings = [];
-  for (const attr of jsx.attributes) {
+  for (let attrIndex = 0; attrIndex < jsx.attributes.length; attrIndex++) {
+    const attr = jsx.attributes[attrIndex];
     if (attr.isSpread) {
+      if (attr.spreadExpr) {
+        const excluded = /* @__PURE__ */ new Set();
+        for (let nextIndex = attrIndex + 1; nextIndex < jsx.attributes.length; nextIndex++) {
+          const nextAttr = jsx.attributes[nextIndex];
+          if (nextAttr.isSpread) continue;
+          let nextName = normalizeHIRAttrName(nextAttr.name);
+          if (nextName.endsWith("$")) {
+            nextName = nextName.slice(0, -1);
+          }
+          if (nextName === "key") continue;
+          excluded.add(nextName);
+          if (nextName !== nextAttr.name) {
+            excluded.add(nextAttr.name);
+          }
+        }
+        bindings.push({
+          type: "spread",
+          path: [...parentPath],
+          expr: attr.spreadExpr,
+          exclude: excluded.size > 0 ? Array.from(excluded) : void 0
+        });
+      }
       continue;
     }
     let name = normalizeHIRAttrName(attr.name);
@@ -28311,10 +28410,28 @@ function lowerIntrinsicElement(jsx, ctx) {
         )
       );
     }
+    fusedPatchGroups.clear();
   };
   for (const binding of bindings) {
     const targetId = resolveHIRBindingPath(binding.path, nodeCache, statements, ctx, genTemp3);
-    if (binding.type === "event" && binding.expr && binding.name) {
+    if (binding.type === "spread" && binding.expr) {
+      flushFusedPatchGroups();
+      ctx.helpersUsed.add("spread");
+      const spreadValueExpr = lowerDomExpression(binding.expr, ctx, containingRegion);
+      const spreadGetter = t4.arrowFunctionExpression([], spreadValueExpr);
+      const spreadArgs = [
+        targetId,
+        spreadGetter,
+        t4.booleanLiteral(Boolean(isSVG || isMathML)),
+        t4.booleanLiteral(true)
+      ];
+      if (binding.exclude && binding.exclude.length > 0) {
+        spreadArgs.push(t4.arrayExpression(binding.exclude.map((name) => t4.stringLiteral(name))));
+      }
+      statements.push(
+        t4.expressionStatement(t4.callExpression(t4.identifier(RUNTIME_ALIASES.spread), spreadArgs))
+      );
+    } else if (binding.type === "event" && binding.expr && binding.name) {
       const eventName = binding.name;
       const hasEventOptions = binding.eventOptions && (binding.eventOptions.capture || binding.eventOptions.passive || binding.eventOptions.once);
       const isDelegated = DelegatedEvents.has(eventName) && !hasEventOptions;
@@ -33102,106 +33219,106 @@ function collectUsesFromTerminator(term, add, inFunctionBody = false) {
   }
 }
 function collectUsesFromExpression(expr, add, inFunctionBody = false) {
-  walkExpression(expr, add, { inFunctionBody, shadowed: /* @__PURE__ */ new Set() });
+  walkExpression2(expr, add, { inFunctionBody, shadowed: /* @__PURE__ */ new Set() });
 }
-function walkExpression(expr, add, ctx) {
+function walkExpression2(expr, add, ctx) {
   switch (expr.kind) {
     case "Identifier":
       if (!ctx.shadowed.has(expr.name)) add(expr.name, ctx.inFunctionBody);
       return;
     case "CallExpression":
     case "OptionalCallExpression":
-      walkExpression(expr.callee, add, ctx);
-      expr.arguments.forEach((arg) => walkExpression(arg, add, ctx));
+      walkExpression2(expr.callee, add, ctx);
+      expr.arguments.forEach((arg) => walkExpression2(arg, add, ctx));
       return;
     case "MemberExpression":
     case "OptionalMemberExpression":
-      walkExpression(expr.object, add, ctx);
-      if (expr.computed) walkExpression(expr.property, add, ctx);
+      walkExpression2(expr.object, add, ctx);
+      if (expr.computed) walkExpression2(expr.property, add, ctx);
       return;
     case "BinaryExpression":
     case "LogicalExpression":
-      walkExpression(expr.left, add, ctx);
-      walkExpression(expr.right, add, ctx);
+      walkExpression2(expr.left, add, ctx);
+      walkExpression2(expr.right, add, ctx);
       return;
     case "UnaryExpression":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "ConditionalExpression":
-      walkExpression(expr.test, add, ctx);
-      walkExpression(expr.consequent, add, ctx);
-      walkExpression(expr.alternate, add, ctx);
+      walkExpression2(expr.test, add, ctx);
+      walkExpression2(expr.consequent, add, ctx);
+      walkExpression2(expr.alternate, add, ctx);
       return;
     case "ArrayExpression":
       expr.elements.forEach((el) => {
-        if (el) walkExpression(el, add, ctx);
+        if (el) walkExpression2(el, add, ctx);
       });
       return;
     case "ObjectExpression":
       expr.properties.forEach((prop) => {
         if (prop.kind === "SpreadElement") {
-          walkExpression(prop.argument, add, ctx);
+          walkExpression2(prop.argument, add, ctx);
         } else {
-          if (prop.computed) walkExpression(prop.key, add, ctx);
-          walkExpression(prop.value, add, ctx);
+          if (prop.computed) walkExpression2(prop.key, add, ctx);
+          walkExpression2(prop.value, add, ctx);
         }
       });
       return;
     case "TemplateLiteral":
-      expr.expressions.forEach((e) => walkExpression(e, add, ctx));
+      expr.expressions.forEach((e) => walkExpression2(e, add, ctx));
       return;
     case "SpreadElement":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "SequenceExpression":
-      expr.expressions.forEach((e) => walkExpression(e, add, ctx));
+      expr.expressions.forEach((e) => walkExpression2(e, add, ctx));
       return;
     case "AwaitExpression":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "NewExpression":
-      walkExpression(expr.callee, add, ctx);
-      expr.arguments.forEach((arg) => walkExpression(arg, add, ctx));
+      walkExpression2(expr.callee, add, ctx);
+      expr.arguments.forEach((arg) => walkExpression2(arg, add, ctx));
       return;
     case "ArrowFunction": {
       const shadowed = new Set(ctx.shadowed);
       expr.params.forEach((p) => shadowed.add(p.name));
       if (expr.isExpression) {
-        walkExpression(expr.body, add, { inFunctionBody: true, shadowed });
+        walkExpression2(expr.body, add, { inFunctionBody: true, shadowed });
         return;
       }
-      walkBlocks(expr.body, add, { inFunctionBody: true, shadowed });
+      walkBlocks2(expr.body, add, { inFunctionBody: true, shadowed });
       return;
     }
     case "FunctionExpression": {
       const shadowed = new Set(ctx.shadowed);
       expr.params.forEach((p) => shadowed.add(p.name));
-      walkBlocks(expr.body, add, { inFunctionBody: true, shadowed });
+      walkBlocks2(expr.body, add, { inFunctionBody: true, shadowed });
       return;
     }
     case "AssignmentExpression":
-      walkExpression(expr.left, add, ctx);
-      walkExpression(expr.right, add, ctx);
+      walkExpression2(expr.left, add, ctx);
+      walkExpression2(expr.right, add, ctx);
       return;
     case "UpdateExpression":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "JSXElement":
       if (typeof expr.tagName !== "string") {
-        walkExpression(expr.tagName, add, ctx);
+        walkExpression2(expr.tagName, add, ctx);
       }
       expr.attributes.forEach((attr) => {
         if (attr.isSpread && attr.spreadExpr) {
-          walkExpression(attr.spreadExpr, add, ctx);
+          walkExpression2(attr.spreadExpr, add, ctx);
         } else if (attr.value) {
-          walkExpression(attr.value, add, ctx);
+          walkExpression2(attr.value, add, ctx);
         }
       });
       expr.children.forEach((child) => {
         if (child.kind === "expression") {
-          walkExpression(child.value, add, ctx);
+          walkExpression2(child.value, add, ctx);
         } else if (child.kind === "element") {
-          walkExpression(child.value, add, ctx);
+          walkExpression2(child.value, add, ctx);
         }
       });
       return;
@@ -33209,16 +33326,16 @@ function walkExpression(expr, add, ctx) {
       return;
   }
 }
-function walkBlocks(blocks, add, ctx) {
+function walkBlocks2(blocks, add, ctx) {
   for (const block of blocks) {
     for (const instr of block.instructions) {
       if (instr.kind === "Assign") {
-        walkExpression(instr.value, add, ctx);
+        walkExpression2(instr.value, add, ctx);
         if (instr.declarationKind) {
           ctx.shadowed.add(instr.target.name);
         }
       } else if (instr.kind === "Expression") {
-        walkExpression(instr.value, add, ctx);
+        walkExpression2(instr.value, add, ctx);
       } else if (instr.kind === "Phi") {
         instr.sources.forEach((src) => {
           if (!ctx.shadowed.has(src.id.name)) add(src.id.name, ctx.inFunctionBody);
@@ -33237,7 +33354,7 @@ function walkBlocks(blocks, add, ctx) {
 function collectExpressionIdentifiers2(expr, deep = false) {
   const deps = /* @__PURE__ */ new Set();
   const collect = (name) => deps.add(name);
-  walkExpression(expr, (name, _inFunctionBody) => collect(name), {
+  walkExpression2(expr, (name, _inFunctionBody) => collect(name), {
     inFunctionBody: deep,
     shadowed: /* @__PURE__ */ new Set()
   });

package/dist/index.js

@@ -14159,6 +14159,7 @@ var RUNTIME_HELPERS = {
   bindEvent: "bindEvent",
   callEventHandler: "callEventHandler",
   bindRef: "bindRef",
+  spread: "spread",
   nonReactive: "nonReactive",
   toNodeArray: "toNodeArray",
   template: "template",
@@ -14216,6 +14217,7 @@ var RUNTIME_ALIASES = {
   bindEvent: "bindEvent",
   callEventHandler: "callEventHandler",
   bindRef: "bindRef",
+  spread: "spread",
   nonReactive: "nonReactive",
   toNodeArray: "toNodeArray",
   template: "template",
@@ -22601,138 +22603,212 @@ function emitConditionalChild(startMarkerId, endMarkerId, expr, statements, ctx,
   );
 }
 
-// src/ir/codegen-expression-deps.ts
-function getMemberDependencyPath(expr) {
-  if (expr.kind === "MemberExpression") {
-    const prop = expr.property;
-    let propName;
-    if (!expr.computed && prop.kind === "Identifier") {
-      propName = prop.name;
-    } else if (prop.kind === "Literal" && typeof prop.value === "string") {
-      propName = prop.value;
-    }
-    if (!propName) return void 0;
-    const object = expr.object;
-    if (object.kind === "Identifier") {
-      return `${deSSAVarName(object.name)}.${propName}`;
-    }
-    if (object.kind === "MemberExpression") {
-      const parent = getMemberDependencyPath(object);
-      return parent ? `${parent}.${propName}` : void 0;
-    }
+// src/ir/walk-expression.ts
+function assertNever(value) {
+  throw new Error(`Unhandled node in walkExpression: ${JSON.stringify(value)}`);
+}
+function walkTerminator(term, visitNode, inFunctionBody) {
+  switch (term.kind) {
+    case "Return":
+      if (term.argument) visitNode(term.argument, null, inFunctionBody);
+      return;
+    case "Throw":
+      visitNode(term.argument, null, inFunctionBody);
+      return;
+    case "Branch":
+      visitNode(term.test, null, inFunctionBody);
+      return;
+    case "Switch":
+      visitNode(term.discriminant, null, inFunctionBody);
+      term.cases.forEach((c) => {
+        if (c.test) visitNode(c.test, null, inFunctionBody);
+      });
+      return;
+    case "ForOf":
+      visitNode(term.iterable, null, inFunctionBody);
+      return;
+    case "ForIn":
+      visitNode(term.object, null, inFunctionBody);
+      return;
+    case "Jump":
+    case "Unreachable":
+    case "Break":
+    case "Continue":
+    case "Try":
+      return;
+    default:
+      assertNever(term);
   }
-  return void 0;
 }
-function collectBlockDependencies(blocks, deps) {
+function walkInstruction(instr, visitNode, inFunctionBody) {
+  switch (instr.kind) {
+    case "Assign":
+    case "Expression":
+      visitNode(instr.value, null, inFunctionBody);
+      return;
+    case "Phi":
+      instr.sources.forEach((source) => visitNode(source.id, null, inFunctionBody));
+      return;
+    default:
+      assertNever(instr);
+  }
+}
+function walkBlocks(blocks, visitNode, inFunctionBody) {
   for (const block of blocks) {
-    for (const instr of block.instructions) {
-      switch (instr.kind) {
-        case "Assign":
-        case "Expression":
-          collectExpressionDependencies(instr.value, deps);
-          break;
-        case "Phi":
-          for (const source of instr.sources) {
-            deps.add(deSSAVarName(source.id.name));
+    block.instructions.forEach((instr) => walkInstruction(instr, visitNode, inFunctionBody));
+    walkTerminator(block.terminator, visitNode, inFunctionBody);
+  }
+}
+function walkExpression(expr, visit, options = {}) {
+  const includeFunctionBodies = options.includeFunctionBodies ?? true;
+  const visitNode = (node, parent, inFunctionBody) => {
+    visit(node, { parent, inFunctionBody });
+    switch (node.kind) {
+      case "Identifier":
+      case "Literal":
+      case "MetaProperty":
+      case "ThisExpression":
+      case "SuperExpression":
+        return;
+      case "ImportExpression":
+        visitNode(node.source, node, inFunctionBody);
+        return;
+      case "CallExpression":
+      case "OptionalCallExpression":
+        visitNode(node.callee, node, inFunctionBody);
+        node.arguments.forEach((arg) => visitNode(arg, node, inFunctionBody));
+        return;
+      case "MemberExpression":
+      case "OptionalMemberExpression":
+        visitNode(node.object, node, inFunctionBody);
+        if (node.computed) {
+          visitNode(node.property, node, inFunctionBody);
+        }
+        return;
+      case "BinaryExpression":
+      case "LogicalExpression":
+        visitNode(node.left, node, inFunctionBody);
+        visitNode(node.right, node, inFunctionBody);
+        return;
+      case "UnaryExpression":
+      case "AwaitExpression":
+        visitNode(node.argument, node, inFunctionBody);
+        return;
+      case "ConditionalExpression":
+        visitNode(node.test, node, inFunctionBody);
+        visitNode(node.consequent, node, inFunctionBody);
+        visitNode(node.alternate, node, inFunctionBody);
+        return;
+      case "ArrayExpression":
+        node.elements.forEach((el) => visitNode(el, node, inFunctionBody));
+        return;
+      case "ObjectExpression":
+        node.properties.forEach((prop) => {
+          if (prop.kind === "SpreadElement") {
+            visitNode(prop.argument, node, inFunctionBody);
+          } else {
+            if (prop.computed) {
+              visitNode(prop.key, node, inFunctionBody);
+            }
+            visitNode(prop.value, node, inFunctionBody);
           }
-          break;
-        default:
-          break;
-      }
-    }
-    const term = block.terminator;
-    switch (term.kind) {
-      case "Return":
-        if (term.argument) collectExpressionDependencies(term.argument, deps);
-        break;
-      case "Throw":
-        collectExpressionDependencies(term.argument, deps);
-        break;
-      case "Branch":
-        collectExpressionDependencies(term.test, deps);
-        break;
-      case "Switch":
-        collectExpressionDependencies(term.discriminant, deps);
-        for (const c of term.cases) {
-          if (c.test) collectExpressionDependencies(c.test, deps);
+        });
+        return;
+      case "JSXElement":
+        if (typeof node.tagName !== "string") {
+          visitNode(node.tagName, node, inFunctionBody);
         }
-        break;
-      case "ForOf":
-        collectExpressionDependencies(term.iterable, deps);
-        break;
-      case "ForIn":
-        collectExpressionDependencies(term.object, deps);
-        break;
+        node.attributes.forEach((attr) => {
+          if (attr.isSpread && attr.spreadExpr) {
+            visitNode(attr.spreadExpr, node, inFunctionBody);
+          } else if (attr.value) {
+            visitNode(attr.value, node, inFunctionBody);
+          }
+        });
+        node.children.forEach((child) => {
+          if (child.kind === "expression") {
+            visitNode(child.value, node, inFunctionBody);
+          } else if (child.kind === "element") {
+            visitNode(child.value, node, inFunctionBody);
+          }
+        });
+        return;
+      case "ArrowFunction":
+        if (!includeFunctionBodies) return;
+        if (node.isExpression && !Array.isArray(node.body)) {
+          visitNode(node.body, node, true);
+        } else if (Array.isArray(node.body)) {
+          walkBlocks(node.body, visitNode, true);
+        }
+        return;
+      case "FunctionExpression":
+        if (!includeFunctionBodies) return;
+        walkBlocks(node.body, visitNode, true);
+        return;
+      case "AssignmentExpression":
+        visitNode(node.left, node, inFunctionBody);
+        visitNode(node.right, node, inFunctionBody);
+        return;
+      case "UpdateExpression":
+        visitNode(node.argument, node, inFunctionBody);
+        return;
+      case "TemplateLiteral":
+        node.expressions.forEach((item) => visitNode(item, node, inFunctionBody));
+        return;
+      case "SpreadElement":
+        visitNode(node.argument, node, inFunctionBody);
+        return;
+      case "NewExpression":
+        visitNode(node.callee, node, inFunctionBody);
+        node.arguments.forEach((arg) => visitNode(arg, node, inFunctionBody));
+        return;
+      case "SequenceExpression":
+        node.expressions.forEach((item) => visitNode(item, node, inFunctionBody));
+        return;
+      case "YieldExpression":
+        if (node.argument) {
+          visitNode(node.argument, node, inFunctionBody);
+        }
+        return;
+      case "TaggedTemplateExpression":
+        visitNode(node.tag, node, inFunctionBody);
+        node.quasi.expressions.forEach((item) => visitNode(item, node, inFunctionBody));
+        return;
+      case "ClassExpression":
+        if (node.superClass) {
+          visitNode(node.superClass, node, inFunctionBody);
+        }
+        return;
       default:
-        break;
+        assertNever(node);
     }
+  };
+  visitNode(expr, null, false);
+}
+
+// src/ir/codegen-expression-deps.ts
+function getMemberDependencyPath(expr) {
+  if (expr.kind !== "MemberExpression" && expr.kind !== "OptionalMemberExpression") return void 0;
+  const depPath = extractDependencyPath(expr);
+  if (!depPath || depPath.segments.length === 0) return void 0;
+  const base = deSSAVarName(depPath.base);
+  if (depPath.segments.some((segment) => segment.computed)) {
+    return base;
   }
+  const tail = depPath.segments.map((segment) => segment.property).join(".");
+  return tail ? `${base}.${tail}` : void 0;
 }
 function collectExpressionDependencies(expr, deps) {
-  if (expr.kind === "Identifier") {
-    deps.add(deSSAVarName(expr.name));
-    return;
-  }
-  if (expr.kind === "ArrowFunction") {
-    if (expr.isExpression && !Array.isArray(expr.body)) {
-      collectExpressionDependencies(expr.body, deps);
-    } else if (Array.isArray(expr.body)) {
-      collectBlockDependencies(expr.body, deps);
+  walkExpression(expr, (node) => {
+    if (node.kind === "Identifier") {
+      deps.add(deSSAVarName(node.name));
+      return;
     }
-    return;
-  }
-  if (expr.kind === "FunctionExpression") {
-    collectBlockDependencies(expr.body, deps);
-    return;
-  }
-  if (expr.kind === "MemberExpression") {
-    const path2 = getMemberDependencyPath(expr);
-    if (path2) deps.add(path2);
-    collectExpressionDependencies(expr.object, deps);
-    if (expr.computed && expr.property.kind !== "Literal") {
-      collectExpressionDependencies(expr.property, deps);
+    const path2 = getMemberDependencyPath(node);
+    if (path2) {
+      deps.add(path2);
     }
-    return;
-  }
-  if (expr.kind === "CallExpression") {
-    collectExpressionDependencies(expr.callee, deps);
-    expr.arguments.forEach((a) => collectExpressionDependencies(a, deps));
-    return;
-  }
-  if (expr.kind === "BinaryExpression" || expr.kind === "LogicalExpression") {
-    collectExpressionDependencies(expr.left, deps);
-    collectExpressionDependencies(expr.right, deps);
-    return;
-  }
-  if (expr.kind === "ConditionalExpression") {
-    collectExpressionDependencies(expr.test, deps);
-    collectExpressionDependencies(expr.consequent, deps);
-    collectExpressionDependencies(expr.alternate, deps);
-    return;
-  }
-  if (expr.kind === "UnaryExpression") {
-    collectExpressionDependencies(expr.argument, deps);
-    return;
-  }
-  if (expr.kind === "ArrayExpression") {
-    expr.elements.forEach((el) => collectExpressionDependencies(el, deps));
-    return;
-  }
-  if (expr.kind === "ObjectExpression") {
-    expr.properties.forEach((p) => {
-      if (p.kind === "SpreadElement") {
-        collectExpressionDependencies(p.argument, deps);
-      } else {
-        if (p.computed) collectExpressionDependencies(p.key, deps);
-        collectExpressionDependencies(p.value, deps);
-      }
-    });
-    return;
-  }
-  if (expr.kind === "TemplateLiteral") {
-    expr.expressions.forEach((e) => collectExpressionDependencies(e, deps));
-    return;
-  }
+  });
 }
 
 // src/ir/codegen-reactive-kind.ts
@@ -26110,8 +26186,31 @@ function extractHIRStaticHtml(jsx, ctx, ops, parentPath = [], namespace = null)
   const resolvedNamespace = resolveNamespaceContext(tagName, namespace);
   let html = `<${tagName}`;
   const bindings = [];
-  for (const attr of jsx.attributes) {
+  for (let attrIndex = 0; attrIndex < jsx.attributes.length; attrIndex++) {
+    const attr = jsx.attributes[attrIndex];
     if (attr.isSpread) {
+      if (attr.spreadExpr) {
+        const excluded = /* @__PURE__ */ new Set();
+        for (let nextIndex = attrIndex + 1; nextIndex < jsx.attributes.length; nextIndex++) {
+          const nextAttr = jsx.attributes[nextIndex];
+          if (nextAttr.isSpread) continue;
+          let nextName = normalizeHIRAttrName(nextAttr.name);
+          if (nextName.endsWith("$")) {
+            nextName = nextName.slice(0, -1);
+          }
+          if (nextName === "key") continue;
+          excluded.add(nextName);
+          if (nextName !== nextAttr.name) {
+            excluded.add(nextAttr.name);
+          }
+        }
+        bindings.push({
+          type: "spread",
+          path: [...parentPath],
+          expr: attr.spreadExpr,
+          exclude: excluded.size > 0 ? Array.from(excluded) : void 0
+        });
+      }
       continue;
     }
     let name = normalizeHIRAttrName(attr.name);
@@ -28296,10 +28395,28 @@ function lowerIntrinsicElement(jsx, ctx) {
         )
       );
     }
+    fusedPatchGroups.clear();
   };
   for (const binding of bindings) {
     const targetId = resolveHIRBindingPath(binding.path, nodeCache, statements, ctx, genTemp3);
-    if (binding.type === "event" && binding.expr && binding.name) {
+    if (binding.type === "spread" && binding.expr) {
+      flushFusedPatchGroups();
+      ctx.helpersUsed.add("spread");
+      const spreadValueExpr = lowerDomExpression(binding.expr, ctx, containingRegion);
+      const spreadGetter = t4.arrowFunctionExpression([], spreadValueExpr);
+      const spreadArgs = [
+        targetId,
+        spreadGetter,
+        t4.booleanLiteral(Boolean(isSVG || isMathML)),
+        t4.booleanLiteral(true)
+      ];
+      if (binding.exclude && binding.exclude.length > 0) {
+        spreadArgs.push(t4.arrayExpression(binding.exclude.map((name) => t4.stringLiteral(name))));
+      }
+      statements.push(
+        t4.expressionStatement(t4.callExpression(t4.identifier(RUNTIME_ALIASES.spread), spreadArgs))
+      );
+    } else if (binding.type === "event" && binding.expr && binding.name) {
       const eventName = binding.name;
       const hasEventOptions = binding.eventOptions && (binding.eventOptions.capture || binding.eventOptions.passive || binding.eventOptions.once);
       const isDelegated = DelegatedEvents.has(eventName) && !hasEventOptions;
@@ -33087,106 +33204,106 @@ function collectUsesFromTerminator(term, add, inFunctionBody = false) {
   }
 }
 function collectUsesFromExpression(expr, add, inFunctionBody = false) {
-  walkExpression(expr, add, { inFunctionBody, shadowed: /* @__PURE__ */ new Set() });
+  walkExpression2(expr, add, { inFunctionBody, shadowed: /* @__PURE__ */ new Set() });
 }
-function walkExpression(expr, add, ctx) {
+function walkExpression2(expr, add, ctx) {
   switch (expr.kind) {
     case "Identifier":
       if (!ctx.shadowed.has(expr.name)) add(expr.name, ctx.inFunctionBody);
       return;
     case "CallExpression":
     case "OptionalCallExpression":
-      walkExpression(expr.callee, add, ctx);
-      expr.arguments.forEach((arg) => walkExpression(arg, add, ctx));
+      walkExpression2(expr.callee, add, ctx);
+      expr.arguments.forEach((arg) => walkExpression2(arg, add, ctx));
       return;
     case "MemberExpression":
     case "OptionalMemberExpression":
-      walkExpression(expr.object, add, ctx);
-      if (expr.computed) walkExpression(expr.property, add, ctx);
+      walkExpression2(expr.object, add, ctx);
+      if (expr.computed) walkExpression2(expr.property, add, ctx);
       return;
     case "BinaryExpression":
     case "LogicalExpression":
-      walkExpression(expr.left, add, ctx);
-      walkExpression(expr.right, add, ctx);
+      walkExpression2(expr.left, add, ctx);
+      walkExpression2(expr.right, add, ctx);
       return;
     case "UnaryExpression":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "ConditionalExpression":
-      walkExpression(expr.test, add, ctx);
-      walkExpression(expr.consequent, add, ctx);
-      walkExpression(expr.alternate, add, ctx);
+      walkExpression2(expr.test, add, ctx);
+      walkExpression2(expr.consequent, add, ctx);
+      walkExpression2(expr.alternate, add, ctx);
       return;
     case "ArrayExpression":
       expr.elements.forEach((el) => {
-        if (el) walkExpression(el, add, ctx);
+        if (el) walkExpression2(el, add, ctx);
       });
       return;
     case "ObjectExpression":
       expr.properties.forEach((prop) => {
         if (prop.kind === "SpreadElement") {
-          walkExpression(prop.argument, add, ctx);
+          walkExpression2(prop.argument, add, ctx);
         } else {
-          if (prop.computed) walkExpression(prop.key, add, ctx);
-          walkExpression(prop.value, add, ctx);
+          if (prop.computed) walkExpression2(prop.key, add, ctx);
+          walkExpression2(prop.value, add, ctx);
         }
       });
       return;
     case "TemplateLiteral":
-      expr.expressions.forEach((e) => walkExpression(e, add, ctx));
+      expr.expressions.forEach((e) => walkExpression2(e, add, ctx));
       return;
     case "SpreadElement":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "SequenceExpression":
-      expr.expressions.forEach((e) => walkExpression(e, add, ctx));
+      expr.expressions.forEach((e) => walkExpression2(e, add, ctx));
       return;
     case "AwaitExpression":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "NewExpression":
-      walkExpression(expr.callee, add, ctx);
-      expr.arguments.forEach((arg) => walkExpression(arg, add, ctx));
+      walkExpression2(expr.callee, add, ctx);
+      expr.arguments.forEach((arg) => walkExpression2(arg, add, ctx));
       return;
     case "ArrowFunction": {
       const shadowed = new Set(ctx.shadowed);
       expr.params.forEach((p) => shadowed.add(p.name));
       if (expr.isExpression) {
-        walkExpression(expr.body, add, { inFunctionBody: true, shadowed });
+        walkExpression2(expr.body, add, { inFunctionBody: true, shadowed });
         return;
       }
-      walkBlocks(expr.body, add, { inFunctionBody: true, shadowed });
+      walkBlocks2(expr.body, add, { inFunctionBody: true, shadowed });
       return;
     }
     case "FunctionExpression": {
       const shadowed = new Set(ctx.shadowed);
       expr.params.forEach((p) => shadowed.add(p.name));
-      walkBlocks(expr.body, add, { inFunctionBody: true, shadowed });
+      walkBlocks2(expr.body, add, { inFunctionBody: true, shadowed });
       return;
     }
     case "AssignmentExpression":
-      walkExpression(expr.left, add, ctx);
-      walkExpression(expr.right, add, ctx);
+      walkExpression2(expr.left, add, ctx);
+      walkExpression2(expr.right, add, ctx);
       return;
     case "UpdateExpression":
-      walkExpression(expr.argument, add, ctx);
+      walkExpression2(expr.argument, add, ctx);
       return;
     case "JSXElement":
       if (typeof expr.tagName !== "string") {
-        walkExpression(expr.tagName, add, ctx);
+        walkExpression2(expr.tagName, add, ctx);
       }
       expr.attributes.forEach((attr) => {
         if (attr.isSpread && attr.spreadExpr) {
-          walkExpression(attr.spreadExpr, add, ctx);
+          walkExpression2(attr.spreadExpr, add, ctx);
         } else if (attr.value) {
-          walkExpression(attr.value, add, ctx);
+          walkExpression2(attr.value, add, ctx);
         }
       });
       expr.children.forEach((child) => {
         if (child.kind === "expression") {
-          walkExpression(child.value, add, ctx);
+          walkExpression2(child.value, add, ctx);
         } else if (child.kind === "element") {
-          walkExpression(child.value, add, ctx);
+          walkExpression2(child.value, add, ctx);
         }
       });
       return;
@@ -33194,16 +33311,16 @@ function walkExpression(expr, add, ctx) {
       return;
   }
 }
-function walkBlocks(blocks, add, ctx) {
+function walkBlocks2(blocks, add, ctx) {
   for (const block of blocks) {
     for (const instr of block.instructions) {
       if (instr.kind === "Assign") {
-        walkExpression(instr.value, add, ctx);
+        walkExpression2(instr.value, add, ctx);
         if (instr.declarationKind) {
           ctx.shadowed.add(instr.target.name);
         }
       } else if (instr.kind === "Expression") {
-        walkExpression(instr.value, add, ctx);
+        walkExpression2(instr.value, add, ctx);
       } else if (instr.kind === "Phi") {
         instr.sources.forEach((src) => {
           if (!ctx.shadowed.has(src.id.name)) add(src.id.name, ctx.inFunctionBody);
@@ -33222,7 +33339,7 @@ function walkBlocks(blocks, add, ctx) {
 function collectExpressionIdentifiers2(expr, deep = false) {
   const deps = /* @__PURE__ */ new Set();
   const collect = (name) => deps.add(name);
-  walkExpression(expr, (name, _inFunctionBody) => collect(name), {
+  walkExpression2(expr, (name, _inFunctionBody) => collect(name), {
     inFunctionBody: deep,
     shadowed: /* @__PURE__ */ new Set()
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fictjs/compiler",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Babel plugin for Fict Compiler",
   "publishConfig": {
     "access": "public",
@@ -48,7 +48,7 @@
     "@types/babel__helper-plugin-utils": "^7.10.3",
     "@types/babel__traverse": "^7.28.0",
     "tsup": "^8.5.1",
-    "@fictjs/runtime": "0.14.0"
+    "@fictjs/runtime": "0.15.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts",