@collie-lang/compiler 1.3.3 → 1.5.2

package/dist/index.cjs

@@ -50,15 +50,15 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/rewrite.ts
-function createTemplateEnv(propsDecls) {
-  const propAliases = /* @__PURE__ */ new Map();
-  if (propsDecls) {
-    for (const decl of propsDecls) {
-      propAliases.set(decl.name, decl.kind);
+function createTemplateEnv(inputsDecls) {
+  const inputNames = /* @__PURE__ */ new Set();
+  if (inputsDecls) {
+    for (const decl of inputsDecls) {
+      inputNames.add(decl.name);
     }
   }
   return {
-    propAliases,
+    inputNames,
     localsStack: []
   };
 }
@@ -77,12 +77,6 @@ function isLocal(env, name) {
   }
   return false;
 }
-function isPropAlias(env, name) {
-  if (isLocal(env, name)) {
-    return false;
-  }
-  return env.propAliases.has(name);
-}
 var IGNORED_IDENTIFIERS = /* @__PURE__ */ new Set([
   "null",
   "undefined",
@@ -90,10 +84,10 @@ var IGNORED_IDENTIFIERS = /* @__PURE__ */ new Set([
   "false",
   "NaN",
   "Infinity",
-  "this",
-  "props"
+  "this"
 ]);
 var RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
+  "async",
   "await",
   "break",
   "case",
@@ -135,185 +129,33 @@ var RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
   "yield"
 ]);
 function rewriteExpression(expression, env) {
-  let i = 0;
-  let state = "code";
-  let output = "";
+  const tokens = tokenizeExpression(expression);
   const usedBare = /* @__PURE__ */ new Set();
-  const usedPropsDot = /* @__PURE__ */ new Set();
   const callSitesBare = /* @__PURE__ */ new Set();
-  const callSitesPropsDot = /* @__PURE__ */ new Set();
-  const rewrittenAliases = /* @__PURE__ */ new Set();
-  while (i < expression.length) {
-    const ch = expression[i];
-    if (state === "code") {
-      if (ch === "'" || ch === '"') {
-        state = ch === "'" ? "single" : "double";
-        output += ch;
-        i++;
-        continue;
-      }
-      if (ch === "`") {
-        state = "template";
-        output += ch;
-        i++;
-        continue;
-      }
-      if (ch === "/" && expression[i + 1] === "/") {
-        state = "line";
-        output += ch;
-        i++;
-        continue;
-      }
-      if (ch === "/" && expression[i + 1] === "*") {
-        state = "block";
-        output += ch;
-        i++;
-        continue;
-      }
-      if (isIdentifierStart(ch)) {
-        const start = i;
-        i++;
-        while (i < expression.length && isIdentifierPart(expression[i])) {
-          i++;
-        }
-        const name = expression.slice(start, i);
-        const prevNonSpace = findPreviousNonSpace(expression, start - 1);
-        const nextNonSpace = findNextNonSpace(expression, i);
-        const isMemberAccess = prevNonSpace === ".";
-        const isObjectKey = nextNonSpace === ":" && (prevNonSpace === "{" || prevNonSpace === ",");
-        const isCall = nextNonSpace === "(";
-        if (prevNonSpace === "." && start >= 2) {
-          const propsStart = findPreviousIdentifierStart(expression, start - 2);
-          if (propsStart !== null) {
-            const possibleProps = expression.slice(propsStart, start - 1).trim();
-            if (possibleProps === "props") {
-              usedPropsDot.add(name);
-              if (isCall) {
-                callSitesPropsDot.add(name);
-              }
-            }
-          }
-        }
-        if (isMemberAccess || isObjectKey || isLocal(env, name) || shouldIgnoreIdentifier(name)) {
-          output += name;
-          continue;
-        }
-        if (isPropAlias(env, name)) {
-          output += `props.${name}`;
-          rewrittenAliases.add(name);
-          if (isCall) {
-            callSitesBare.add(name);
-          }
-          continue;
-        }
-        usedBare.add(name);
-        if (isCall) {
-          callSitesBare.add(name);
-        }
-        output += name;
-        continue;
-      }
-      output += ch;
-      i++;
-      continue;
-    }
-    if (state === "line") {
-      output += ch;
-      if (ch === "\n") {
-        state = "code";
-      }
-      i++;
-      continue;
-    }
-    if (state === "block") {
-      output += ch;
-      if (ch === "*" && expression[i + 1] === "/") {
-        output += "/";
-        i += 2;
-        state = "code";
-        continue;
-      }
-      i++;
-      continue;
-    }
-    if (state === "single") {
-      output += ch;
-      if (ch === "\\") {
-        if (i + 1 < expression.length) {
-          output += expression[i + 1];
-          i += 2;
-          continue;
-        }
-      }
-      if (ch === "'") {
-        state = "code";
-      }
-      i++;
-      continue;
-    }
-    if (state === "double") {
-      output += ch;
-      if (ch === "\\") {
-        if (i + 1 < expression.length) {
-          output += expression[i + 1];
-          i += 2;
-          continue;
-        }
-      }
-      if (ch === '"') {
-        state = "code";
-      }
-      i++;
-      continue;
-    }
-    if (state === "template") {
-      output += ch;
-      if (ch === "\\") {
-        if (i + 1 < expression.length) {
-          output += expression[i + 1];
-          i += 2;
-          continue;
-        }
-      }
-      if (ch === "`") {
-        state = "code";
-      }
-      i++;
-      continue;
-    }
-  }
-  return { code: output, usedBare, usedPropsDot, callSitesBare, callSitesPropsDot, rewrittenAliases };
+  const localScopes = [/* @__PURE__ */ new Set()];
+  analyzeTokens(tokens, 0, tokens.length, env, localScopes, usedBare, callSitesBare, false);
+  return { code: expression, usedBare, callSitesBare };
 }
 function rewriteJsxExpression(expression, env) {
-  let output = "";
   let i = 0;
   const usedBare = /* @__PURE__ */ new Set();
-  const usedPropsDot = /* @__PURE__ */ new Set();
   const callSitesBare = /* @__PURE__ */ new Set();
-  const callSitesPropsDot = /* @__PURE__ */ new Set();
-  const rewrittenAliases = /* @__PURE__ */ new Set();
   while (i < expression.length) {
     const ch = expression[i];
     if (ch === "{") {
       const braceResult = readBalancedBraces(expression, i + 1);
       if (!braceResult) {
-        output += expression.slice(i);
         break;
       }
       const result = rewriteExpression(braceResult.content, env);
-      output += `{${result.code}}`;
       for (const name of result.usedBare) usedBare.add(name);
-      for (const name of result.usedPropsDot) usedPropsDot.add(name);
       for (const name of result.callSitesBare) callSitesBare.add(name);
-      for (const name of result.callSitesPropsDot) callSitesPropsDot.add(name);
-      for (const name of result.rewrittenAliases) rewrittenAliases.add(name);
       i = braceResult.endIndex + 1;
       continue;
     }
-    output += ch;
     i++;
   }
-  return { code: output, usedBare, usedPropsDot, callSitesBare, callSitesPropsDot, rewrittenAliases };
+  return { code: expression, usedBare, callSitesBare };
 }
 function readBalancedBraces(source, startIndex) {
   let i = startIndex;
@@ -405,38 +247,6 @@ function readBalancedBraces(source, startIndex) {
   }
   return null;
 }
-function findPreviousNonSpace(text, index) {
-  for (let i = index; i >= 0; i--) {
-    const ch = text[i];
-    if (!/\s/.test(ch)) {
-      return ch;
-    }
-  }
-  return null;
-}
-function findNextNonSpace(text, index) {
-  for (let i = index; i < text.length; i++) {
-    const ch = text[i];
-    if (!/\s/.test(ch)) {
-      return ch;
-    }
-  }
-  return null;
-}
-function findPreviousIdentifierStart(text, index) {
-  let i = index;
-  while (i >= 0 && /\s/.test(text[i])) {
-    i--;
-  }
-  if (i < 0) return null;
-  if (!isIdentifierPart(text[i])) {
-    return null;
-  }
-  while (i > 0 && isIdentifierPart(text[i - 1])) {
-    i--;
-  }
-  return i;
-}
 function isIdentifierStart(ch) {
   return /[A-Za-z_$]/.test(ch);
 }
@@ -446,96 +256,592 @@ function isIdentifierPart(ch) {
 function shouldIgnoreIdentifier(name) {
   return IGNORED_IDENTIFIERS.has(name) || RESERVED_KEYWORDS.has(name);
 }
-
-// src/codegen.ts
-function generateRenderModule(root, options) {
-  const { prelude, propsType, propsDestructure, jsx, isTsx } = buildModuleParts(root, options);
-  const parts = [...prelude, propsType];
-  if (!isTsx) {
-    parts.push(`/** @param {any} props */`);
-  }
-  const functionLines = [
-    isTsx ? "export function render(props: any) {" : "export function render(props) {"
-  ];
-  if (propsDestructure) {
-    functionLines.push(`  ${propsDestructure}`);
+function tokenizeExpression(expression) {
+  const tokens = [];
+  let i = 0;
+  while (i < expression.length) {
+    const ch = expression[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (ch === "/" && expression[i + 1] === "/") {
+      i += 2;
+      while (i < expression.length && expression[i] !== "\n") {
+        i++;
+      }
+      continue;
+    }
+    if (ch === "/" && expression[i + 1] === "*") {
+      i += 2;
+      while (i < expression.length && !(expression[i] === "*" && expression[i + 1] === "/")) {
+        i++;
+      }
+      i += 2;
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      i = skipStringLiteral(expression, i, ch);
+      tokens.push({ type: "literal", value: "string" });
+      continue;
+    }
+    if (ch === "`") {
+      i = skipTemplateLiteral(expression, i);
+      tokens.push({ type: "literal", value: "template" });
+      continue;
+    }
+    if (isIdentifierStart(ch)) {
+      const start = i;
+      i++;
+      while (i < expression.length && isIdentifierPart(expression[i])) {
+        i++;
+      }
+      tokens.push({ type: "identifier", value: expression.slice(start, i) });
+      continue;
+    }
+    if (/[0-9]/.test(ch)) {
+      const start = i;
+      i++;
+      while (i < expression.length && /[0-9._]/.test(expression[i])) {
+        i++;
+      }
+      tokens.push({ type: "literal", value: expression.slice(start, i) });
+      continue;
+    }
+    if (expression.startsWith("...", i)) {
+      tokens.push({ type: "punctuator", value: "..." });
+      i += 3;
+      continue;
+    }
+    if (expression.startsWith("=>", i)) {
+      tokens.push({ type: "punctuator", value: "=>" });
+      i += 2;
+      continue;
+    }
+    if (expression.startsWith("?.", i)) {
+      tokens.push({ type: "punctuator", value: "?." });
+      i += 2;
+      continue;
+    }
+    if (expression.startsWith("??", i)) {
+      tokens.push({ type: "punctuator", value: "??" });
+      i += 2;
+      continue;
+    }
+    tokens.push({ type: "punctuator", value: ch });
+    i++;
   }
-  functionLines.push(`  return ${jsx};`, `}`);
-  parts.push(functionLines.join("\n"));
-  return parts.join("\n\n");
+  return tokens;
 }
-function buildModuleParts(root, options) {
-  const { jsxRuntime, flavor } = options;
-  const isTsx = flavor === "tsx";
-  const aliasEnv = buildClassAliasEnvironment(root.classAliases);
-  const env = createTemplateEnv(root.propsDecls);
-  const jsx = renderRootChildren(root.children, aliasEnv, env);
-  const propsDestructure = emitPropsDestructure(root.props);
-  const prelude = [];
-  if (root.clientComponent) {
-    prelude.push(`"use client";`);
-  }
-  if (jsxRuntime === "classic" && templateUsesJsx(root)) {
-    prelude.push(`import React from "react";`);
+function skipStringLiteral(source, start, quote) {
+  let i = start + 1;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === quote) {
+      return i + 1;
+    }
+    i++;
   }
-  const propsType = emitPropsType(root.props, flavor);
-  return { prelude, propsType, propsDestructure, jsx, isTsx };
+  return source.length;
 }
-function buildClassAliasEnvironment(decl) {
-  const env = /* @__PURE__ */ new Map();
-  if (!decl) {
-    return env;
+function skipTemplateLiteral(source, start) {
+  let i = start + 1;
+  while (i < source.length) {
+    const ch = source[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "`") {
+      return i + 1;
+    }
+    i++;
   }
-  for (const alias of decl.aliases) {
-    env.set(alias.name, alias.classes);
+  return source.length;
+}
+function analyzeTokens(tokens, start, end, env, scopes, usedBare, callSitesBare, allowStatements) {
+  let i = start;
+  while (i < end) {
+    const token = tokens[i];
+    if (token.type === "identifier") {
+      if (token.value === "function") {
+        const fnResult = parseFunctionExpression(tokens, i, end, env, scopes, usedBare, callSitesBare);
+        if (fnResult > i) {
+          i = fnResult;
+          continue;
+        }
+      }
+      if (allowStatements && (token.value === "const" || token.value === "let" || token.value === "var")) {
+        const declResult = parseVariableDeclaration(tokens, i, end, env, scopes, usedBare, callSitesBare);
+        if (declResult > i) {
+          i = declResult;
+          continue;
+        }
+      }
+      if (allowStatements && token.value === "catch") {
+        const catchResult = parseCatchClause(tokens, i, end, env, scopes, usedBare, callSitesBare);
+        if (catchResult > i) {
+          i = catchResult;
+          continue;
+        }
+      }
+      const arrowResult = parseArrowFunction(tokens, i, end, env, scopes, usedBare, callSitesBare);
+      if (arrowResult > i) {
+        i = arrowResult;
+        continue;
+      }
+      if (shouldIgnoreIdentifier(token.value)) {
+        i++;
+        continue;
+      }
+      if (isShadowed(env, scopes, token.value)) {
+        i++;
+        continue;
+      }
+      if (isMemberAccess(tokens, i) || isObjectKey(tokens, i)) {
+        i++;
+        continue;
+      }
+      usedBare.add(token.value);
+      if (isCallSite(tokens, i)) {
+        callSitesBare.add(token.value);
+      }
+      i++;
+      continue;
+    }
+    if (token.type === "punctuator" && token.value === "(") {
+      const arrowResult = parseArrowFunction(tokens, i, end, env, scopes, usedBare, callSitesBare);
+      if (arrowResult > i) {
+        i = arrowResult;
+        continue;
+      }
+    }
+    i++;
   }
-  return env;
 }
-function renderRootChildren(children, aliasEnv, env) {
-  return emitNodesExpression(children, aliasEnv, env);
-}
-function templateUsesJsx(root) {
-  if (root.children.length === 0) {
-    return false;
+function parseArrowFunction(tokens, index, end, env, scopes, usedBare, callSitesBare) {
+  const token = tokens[index];
+  if (!token) {
+    return index;
   }
-  if (root.children.length > 1) {
-    return true;
+  if (token.type === "identifier") {
+    const next = tokens[index + 1];
+    if (next && next.value === "=>") {
+      const params = /* @__PURE__ */ new Set([token.value]);
+      return analyzeArrowBody(tokens, index + 2, end, params, env, scopes, usedBare, callSitesBare);
+    }
   }
-  return nodeUsesJsx(root.children[0]);
-}
-function nodeUsesJsx(node) {
-  if (node.type === "Element" || node.type === "Text" || node.type === "Component") {
-    return true;
+  if (token.type === "punctuator" && token.value === "(") {
+    const closeIndex = findMatchingToken(tokens, index, "(", ")");
+    if (closeIndex !== -1) {
+      const afterClose = tokens[closeIndex + 1];
+      if (afterClose && afterClose.value === "=>") {
+        const params = /* @__PURE__ */ new Set();
+        collectBindingNamesFromList(tokens, index + 1, closeIndex, params);
+        return analyzeArrowBody(tokens, closeIndex + 2, end, params, env, scopes, usedBare, callSitesBare);
+      }
+    }
   }
-  if (node.type === "Expression" || node.type === "JSXPassthrough") {
-    return false;
+  return index;
+}
+function analyzeArrowBody(tokens, start, end, params, env, scopes, usedBare, callSitesBare) {
+  const bodyToken = tokens[start];
+  if (!bodyToken) {
+    return start;
+  }
+  const scope = new Set(params);
+  scopes.push(scope);
+  if (bodyToken.type === "punctuator" && bodyToken.value === "{") {
+    const closeIndex = findMatchingToken(tokens, start, "{", "}");
+    const bodyEnd2 = closeIndex === -1 ? end : closeIndex;
+    analyzeTokens(tokens, start + 1, bodyEnd2, env, scopes, usedBare, callSitesBare, true);
+    scopes.pop();
+    return closeIndex === -1 ? end : closeIndex + 1;
+  }
+  const bodyEnd = findExpressionEnd(tokens, start, end, EXPRESSION_TERMINATORS);
+  analyzeTokens(tokens, start, bodyEnd, env, scopes, usedBare, callSitesBare, false);
+  scopes.pop();
+  return bodyEnd;
+}
+function parseFunctionExpression(tokens, index, end, env, scopes, usedBare, callSitesBare) {
+  let i = index + 1;
+  const nameToken = tokens[i];
+  let fnName;
+  if (nameToken && nameToken.type === "identifier" && tokens[i + 1]?.value === "(") {
+    fnName = nameToken.value;
+    i++;
   }
-  if (node.type === "Conditional") {
-    return node.branches.some((branch) => branchUsesJsx(branch));
+  if (!tokens[i] || tokens[i].value !== "(") {
+    return index;
   }
-  if (node.type === "For") {
-    return node.body.some((child) => nodeUsesJsx(child));
+  const closeIndex = findMatchingToken(tokens, i, "(", ")");
+  if (closeIndex === -1) {
+    return index;
+  }
+  const params = /* @__PURE__ */ new Set();
+  collectBindingNamesFromList(tokens, i + 1, closeIndex, params);
+  if (fnName) {
+    params.add(fnName);
+  }
+  const bodyStart = closeIndex + 1;
+  if (!tokens[bodyStart] || tokens[bodyStart].value !== "{") {
+    return index;
+  }
+  const closeBody = findMatchingToken(tokens, bodyStart, "{", "}");
+  const bodyEnd = closeBody === -1 ? end : closeBody;
+  scopes.push(params);
+  analyzeTokens(tokens, bodyStart + 1, bodyEnd, env, scopes, usedBare, callSitesBare, true);
+  scopes.pop();
+  return closeBody === -1 ? end : closeBody + 1;
+}
+function parseCatchClause(tokens, index, end, env, scopes, usedBare, callSitesBare) {
+  const next = tokens[index + 1];
+  if (!next || next.value !== "(") {
+    return index;
+  }
+  const closeIndex = findMatchingToken(tokens, index + 1, "(", ")");
+  if (closeIndex === -1) {
+    return index;
+  }
+  const params = /* @__PURE__ */ new Set();
+  collectBindingNamesFromList(tokens, index + 2, closeIndex, params);
+  const bodyStart = closeIndex + 1;
+  if (!tokens[bodyStart] || tokens[bodyStart].value !== "{") {
+    return index;
+  }
+  const closeBody = findMatchingToken(tokens, bodyStart, "{", "}");
+  const bodyEnd = closeBody === -1 ? end : closeBody;
+  scopes.push(params);
+  analyzeTokens(tokens, bodyStart + 1, bodyEnd, env, scopes, usedBare, callSitesBare, true);
+  scopes.pop();
+  return closeBody === -1 ? end : closeBody + 1;
+}
+function parseVariableDeclaration(tokens, index, end, env, scopes, usedBare, callSitesBare) {
+  let i = index + 1;
+  const scope = scopes[scopes.length - 1];
+  while (i < end) {
+    const names = /* @__PURE__ */ new Set();
+    const nextIndex = parseBindingPattern(tokens, i, end, names);
+    if (nextIndex === i) {
+      return index;
+    }
+    i = nextIndex;
+    if (tokens[i] && tokens[i].value === "=") {
+      const initStart = i + 1;
+      const initEnd = findExpressionEnd(tokens, initStart, end, DECLARATION_TERMINATORS);
+      analyzeTokens(tokens, initStart, initEnd, env, scopes, usedBare, callSitesBare, false);
+      i = initEnd;
+    }
+    for (const name of names) {
+      scope.add(name);
+    }
+    if (tokens[i] && tokens[i].value === ",") {
+      i++;
+      continue;
+    }
+    break;
   }
-  return false;
+  return i;
 }
-function branchUsesJsx(branch) {
-  if (!branch.body.length) {
-    return false;
+function parseBindingPattern(tokens, start, end, names) {
+  const token = tokens[start];
+  if (!token) {
+    return start;
   }
-  return branch.body.some((child) => nodeUsesJsx(child));
-}
-function emitNodeInJsx(node, aliasEnv, env) {
-  if (node.type === "Text") {
-    return emitText(node, env);
+  if (token.type === "identifier") {
+    names.add(token.value);
+    return start + 1;
   }
-  if (node.type === "Expression") {
-    return `{${emitExpressionValue(node.value, env)}}`;
+  if (token.value === "{") {
+    return parseObjectPattern(tokens, start + 1, end, names);
   }
-  if (node.type === "JSXPassthrough") {
-    return `{${emitJsxExpression(node.expression, env)}}`;
+  if (token.value === "[") {
+    return parseArrayPattern(tokens, start + 1, end, names);
   }
-  if (node.type === "Conditional") {
-    return `{${emitConditionalExpression(node, aliasEnv, env)}}`;
+  return start + 1;
+}
+function parseObjectPattern(tokens, start, end, names) {
+  let i = start;
+  while (i < end) {
+    const token = tokens[i];
+    if (!token) {
+      return i;
+    }
+    if (token.value === "}") {
+      return i + 1;
+    }
+    if (token.value === ",") {
+      i++;
+      continue;
+    }
+    if (token.value === "...") {
+      i++;
+      i = parseBindingPattern(tokens, i, end, names);
+      i = skipDefaultValue(tokens, i, end, OBJECT_PATTERN_TERMINATORS);
+      continue;
+    }
+    if (token.value === "[") {
+      const closeIndex = findMatchingToken(tokens, i, "[", "]");
+      i = closeIndex === -1 ? end : closeIndex + 1;
+      if (tokens[i] && tokens[i].value === ":") {
+        i++;
+        i = parseBindingPattern(tokens, i, end, names);
+        i = skipDefaultValue(tokens, i, end, OBJECT_PATTERN_TERMINATORS);
+      }
+      continue;
+    }
+    if (token.type === "identifier" || token.type === "literal") {
+      const key = token.value;
+      i++;
+      if (tokens[i] && tokens[i].value === ":") {
+        i++;
+        i = parseBindingPattern(tokens, i, end, names);
+      } else if (token.type === "identifier") {
+        names.add(key);
+      }
+      i = skipDefaultValue(tokens, i, end, OBJECT_PATTERN_TERMINATORS);
+      continue;
+    }
+    i++;
+  }
+  return i;
+}
+function parseArrayPattern(tokens, start, end, names) {
+  let i = start;
+  while (i < end) {
+    const token = tokens[i];
+    if (!token) {
+      return i;
+    }
+    if (token.value === "]") {
+      return i + 1;
+    }
+    if (token.value === ",") {
+      i++;
+      continue;
+    }
+    if (token.value === "...") {
+      i++;
+      i = parseBindingPattern(tokens, i, end, names);
+      i = skipDefaultValue(tokens, i, end, ARRAY_PATTERN_TERMINATORS);
+      continue;
+    }
+    i = parseBindingPattern(tokens, i, end, names);
+    i = skipDefaultValue(tokens, i, end, ARRAY_PATTERN_TERMINATORS);
+    if (tokens[i] && tokens[i].value === ",") {
+      i++;
+    }
+  }
+  return i;
+}
+function collectBindingNamesFromList(tokens, start, end, names) {
+  let i = start;
+  while (i < end) {
+    if (tokens[i] && tokens[i].value === ",") {
+      i++;
+      continue;
+    }
+    const nextIndex = parseBindingPattern(tokens, i, end, names);
+    if (nextIndex === i) {
+      i++;
+      continue;
+    }
+    i = skipParameterSuffix(tokens, nextIndex, end);
+    if (tokens[i] && tokens[i].value === ",") {
+      i++;
+    }
+  }
+}
+function skipParameterSuffix(tokens, start, end) {
+  if (!tokens[start]) {
+    return start;
+  }
+  if (tokens[start].value === "=" || tokens[start].value === ":") {
+    return findExpressionEnd(tokens, start + 1, end, PARAMETER_TERMINATORS);
+  }
+  return start;
+}
+function skipDefaultValue(tokens, start, end, terminators) {
+  if (!tokens[start] || tokens[start].value !== "=") {
+    return start;
+  }
+  return findExpressionEnd(tokens, start + 1, end, terminators);
+}
+function findMatchingToken(tokens, start, open, close) {
+  let depth = 0;
+  for (let i = start; i < tokens.length; i++) {
+    const value = tokens[i].value;
+    if (value === open) {
+      depth++;
+    } else if (value === close) {
+      depth--;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function findExpressionEnd(tokens, start, end, terminators) {
+  let depthParen = 0;
+  let depthBracket = 0;
+  let depthBrace = 0;
+  for (let i = start; i < end; i++) {
+    const value = tokens[i].value;
+    if (value === "(") {
+      depthParen++;
+    } else if (value === ")") {
+      if (depthParen === 0 && terminators.has(value)) {
+        return i;
+      }
+      depthParen = Math.max(0, depthParen - 1);
+    } else if (value === "[") {
+      depthBracket++;
+    } else if (value === "]") {
+      if (depthBracket === 0 && terminators.has(value)) {
+        return i;
+      }
+      depthBracket = Math.max(0, depthBracket - 1);
+    } else if (value === "{") {
+      depthBrace++;
+    } else if (value === "}") {
+      if (depthBrace === 0 && terminators.has(value)) {
+        return i;
+      }
+      depthBrace = Math.max(0, depthBrace - 1);
+    }
+    if (depthParen === 0 && depthBracket === 0 && depthBrace === 0 && terminators.has(value)) {
+      return i;
+    }
+  }
+  return end;
+}
+function isMemberAccess(tokens, index) {
+  const prev = tokens[index - 1];
+  return prev?.value === "." || prev?.value === "?.";
+}
+function isObjectKey(tokens, index) {
+  const next = tokens[index + 1];
+  if (!next || next.value !== ":") {
+    return false;
+  }
+  const prev = tokens[index - 1];
+  return prev?.value === "{" || prev?.value === ",";
+}
+function isCallSite(tokens, index) {
+  const next = tokens[index + 1];
+  return next?.value === "(";
+}
+function isShadowed(env, scopes, name) {
+  if (isLocal(env, name)) {
+    return true;
+  }
+  for (let i = scopes.length - 1; i >= 0; i--) {
+    if (scopes[i].has(name)) {
+      return true;
+    }
+  }
+  return false;
+}
+var PARAMETER_TERMINATORS = /* @__PURE__ */ new Set([","]);
+var OBJECT_PATTERN_TERMINATORS = /* @__PURE__ */ new Set([",", "}"]);
+var ARRAY_PATTERN_TERMINATORS = /* @__PURE__ */ new Set([",", "]"]);
+var EXPRESSION_TERMINATORS = /* @__PURE__ */ new Set([",", ")", "]", "}", ";"]);
+var DECLARATION_TERMINATORS = /* @__PURE__ */ new Set([",", ")", "]", "}", ";"]);
+
+// src/codegen.ts
+function generateRenderModule(root, options) {
+  const { prelude, inputsType, inputsPrelude, jsx, isTsx } = buildModuleParts(root, options);
+  const parts = [...prelude, inputsType];
+  if (!isTsx) {
+    parts.push(`/** @param {any} __inputs */`);
+  }
+  const functionLines = [
+    isTsx ? "export function render(__inputs: any) {" : "export function render(__inputs) {"
+  ];
+  if (inputsPrelude) {
+    functionLines.push(`  ${inputsPrelude}`);
+  }
+  functionLines.push(`  return ${jsx};`, `}`);
+  parts.push(functionLines.join("\n"));
+  return parts.join("\n\n");
+}
+function buildModuleParts(root, options) {
+  const { jsxRuntime, flavor } = options;
+  const isTsx = flavor === "tsx";
+  const aliasEnv = buildClassAliasEnvironment(root.classAliases);
+  const env = createTemplateEnv(root.inputsDecls);
+  const jsx = renderRootChildren(root.children, aliasEnv, env);
+  const inputsPrelude = emitInputsPrelude(root.inputsDecls);
+  const prelude = [];
+  if (root.clientComponent) {
+    prelude.push(`"use client";`);
+  }
+  if (jsxRuntime === "classic" && templateUsesJsx(root)) {
+    prelude.push(`import React from "react";`);
+  }
+  const inputsType = emitInputsType(root.inputs, flavor);
+  return { prelude, inputsType, inputsPrelude, jsx, isTsx };
+}
+function buildClassAliasEnvironment(decl) {
+  const env = /* @__PURE__ */ new Map();
+  if (!decl) {
+    return env;
+  }
+  for (const alias of decl.aliases) {
+    env.set(alias.name, alias.classes);
+  }
+  return env;
+}
+function renderRootChildren(children, aliasEnv, env) {
+  return emitNodesExpression(children, aliasEnv, env);
+}
+function templateUsesJsx(root) {
+  if (root.children.length === 0) {
+    return false;
+  }
+  if (root.children.length > 1) {
+    return true;
+  }
+  return nodeUsesJsx(root.children[0]);
+}
+function nodeUsesJsx(node) {
+  if (node.type === "Element" || node.type === "Text" || node.type === "Component") {
+    return true;
+  }
+  if (node.type === "Expression" || node.type === "JSXPassthrough") {
+    return false;
+  }
+  if (node.type === "Conditional") {
+    return node.branches.some((branch) => branchUsesJsx(branch));
+  }
+  if (node.type === "For") {
+    return node.body.some((child) => nodeUsesJsx(child));
+  }
+  return false;
+}
+function branchUsesJsx(branch) {
+  if (!branch.body.length) {
+    return false;
+  }
+  return branch.body.some((child) => nodeUsesJsx(child));
+}
+function emitNodeInJsx(node, aliasEnv, env) {
+  if (node.type === "Text") {
+    return emitText(node, env);
+  }
+  if (node.type === "Expression") {
+    return `{${emitExpressionValue(node.value, env)}}`;
+  }
+  if (node.type === "JSXPassthrough") {
+    return `{${emitJsxExpression(node.expression, env)}}`;
+  }
+  if (node.type === "Conditional") {
+    return `{${emitConditionalExpression(node, aliasEnv, env)}}`;
   }
   if (node.type === "For") {
     return `{${emitForExpression(node, aliasEnv, env)}}`;
@@ -559,8 +865,8 @@ function emitElement(node, aliasEnv, env) {
 }
 function emitComponent(node, aliasEnv, env) {
   const attrs = emitAttributes(node.attributes, aliasEnv, env);
-  const slotProps = emitSlotProps(node, aliasEnv, env);
-  const allAttrs = `${attrs}${slotProps}`;
+  const slotBindings = emitSlotBindings(node, aliasEnv, env);
+  const allAttrs = `${attrs}${slotBindings}`;
   const children = emitChildrenWithSpacing(node.children, aliasEnv, env);
   if (children.length > 0) {
     return `<${node.name}${allAttrs}>${children}</${node.name}>`;
@@ -598,7 +904,7 @@ function emitAttributes(attributes, aliasEnv, env) {
     return ` ${attr.name}=${emitAttributeValue(attr.value, env)}`;
   }).join("");
 }
-function emitSlotProps(node, aliasEnv, env) {
+function emitSlotBindings(node, aliasEnv, env) {
   if (!node.slots || node.slots.length === 0) {
     return "";
   }
@@ -729,41 +1035,41 @@ function emitSingleNodeExpression(node, aliasEnv, env) {
   }
   return emitNodeInJsx(node, aliasEnv, env);
 }
-function emitPropsType(props, flavor) {
+function emitInputsType(inputs, flavor) {
   if (flavor === "tsx") {
-    return emitTsPropsType(props);
+    return emitTsInputsType(inputs);
   }
-  return emitJsDocPropsType(props);
+  return emitJsDocInputsType(inputs);
 }
-function emitJsDocPropsType(props) {
-  if (!props) {
-    return "/** @typedef {any} Props */";
+function emitJsDocInputsType(inputs) {
+  if (!inputs) {
+    return "/** @typedef {any} Inputs */";
   }
-  if (!props.fields.length) {
-    return "/** @typedef {{}} Props */";
+  if (!inputs.fields.length) {
+    return "/** @typedef {{}} Inputs */";
   }
-  const fields = props.fields.map((field) => {
+  const fields = inputs.fields.map((field) => {
     const optional = field.optional ? "?" : "";
     return `${field.name}${optional}: ${field.typeText}`;
   }).join("; ");
-  return `/** @typedef {{ ${fields} }} Props */`;
+  return `/** @typedef {{ ${fields} }} Inputs */`;
 }
-function emitTsPropsType(props) {
-  if (!props || props.fields.length === 0) {
-    return "export type Props = Record<string, never>;";
+function emitTsInputsType(inputs) {
+  if (!inputs || inputs.fields.length === 0) {
+    return "export type Inputs = Record<string, never>;";
   }
-  const lines = props.fields.map((field) => {
+  const lines = inputs.fields.map((field) => {
     const optional = field.optional ? "?" : "";
     return `  ${field.name}${optional}: ${field.typeText};`;
   });
-  return ["export interface Props {", ...lines, "}"].join("\n");
+  return ["export interface Inputs {", ...lines, "}"].join("\n");
 }
-function emitPropsDestructure(props) {
-  if (!props || props.fields.length === 0) {
+function emitInputsPrelude(inputsDecls) {
+  if (!inputsDecls || inputsDecls.length === 0) {
     return null;
   }
-  const names = props.fields.map((field) => field.name);
-  return `const { ${names.join(", ")} } = props ?? {};`;
+  const names = inputsDecls.map((decl) => decl.name);
+  return `const { ${names.join(", ")} } = __inputs ?? {};`;
 }
 function escapeText(value) {
   return value.replace(/[&<>{}]/g, (char) => {
@@ -925,836 +1231,196 @@ function unescapeChar(char, quote) {
     default:
       if (char === quote) {
         return quote;
-      }
-      return char;
-  }
-}
-function buildClassAliasEnvironment2(decl) {
-  const env = /* @__PURE__ */ new Map();
-  if (!decl) {
-    return env;
-  }
-  for (const alias of decl.aliases) {
-    env.set(alias.name, alias.classes);
-  }
-  return env;
-}
-function expandClasses2(classes, aliasEnv) {
-  const result = [];
-  for (const cls of classes) {
-    const match = cls.match(/^\$([A-Za-z_][A-Za-z0-9_]*)$/);
-    if (!match) {
-      result.push(cls);
-      continue;
-    }
-    const aliasClasses = aliasEnv.get(match[1]);
-    if (!aliasClasses) {
-      continue;
-    }
-    result.push(...aliasClasses);
-  }
-  return result;
-}
-function escapeStaticText(value) {
-  return value.replace(/[&<>{}]/g, (char) => {
-    switch (char) {
-      case "&":
-        return "&amp;";
-      case "<":
-        return "&lt;";
-      case ">":
-        return "&gt;";
-      case "{":
-        return "&#123;";
-      case "}":
-        return "&#125;";
-      default:
-        return char;
-    }
-  });
-}
-function escapeAttributeValue(value) {
-  return value.replace(/["&<>]/g, (char) => {
-    switch (char) {
-      case "&":
-        return "&amp;";
-      case "<":
-        return "&lt;";
-      case ">":
-        return "&gt;";
-      case '"':
-        return "&quot;";
-      default:
-        return char;
-    }
-  });
-}
-
-// src/diagnostics.ts
-function createSpan(line, col, length, lineOffset) {
-  const startOffset = lineOffset + col - 1;
-  return {
-    start: { line, col, offset: startOffset },
-    end: { line, col: col + length, offset: startOffset + length }
-  };
-}
-
-// src/dialect.ts
-function enforceDialect(root, config) {
-  const diagnostics = [];
-  if (root.idToken) {
-    diagnostics.push(
-      ...evaluateToken(
-        { kind: "id", token: root.idToken, span: root.idTokenSpan },
-        config.tokens.id
-      )
-    );
-  }
-  walkNodes(root.children, (occurrence) => {
-    const rule = config.tokens[occurrence.kind];
-    diagnostics.push(...evaluateToken(occurrence, rule));
-  });
-  return diagnostics;
-}
-function walkNodes(nodes, onToken) {
-  for (const node of nodes) {
-    if (node.type === "For") {
-      onFor(node, onToken);
-      walkNodes(node.body, onToken);
-      continue;
-    }
-    if (node.type === "Conditional") {
-      onConditional(node, onToken);
-      continue;
-    }
-    if (node.type === "Element" || node.type === "Component") {
-      walkNodes(node.children, onToken);
-      if (node.type === "Component" && node.slots) {
-        for (const slot of node.slots) {
-          walkNodes(slot.children, onToken);
-        }
-      }
-      continue;
-    }
-  }
-}
-function onFor(node, onToken) {
-  if (!node.token) {
-    return;
-  }
-  onToken({ kind: "for", token: node.token, span: node.tokenSpan });
-}
-function onConditional(node, onToken) {
-  for (const branch of node.branches) {
-    onBranch(branch, onToken);
-    walkNodes(branch.body, onToken);
-  }
-}
-function onBranch(branch, onToken) {
-  if (!branch.token || !branch.kind) {
-    return;
-  }
-  onToken({ kind: branch.kind, token: branch.token, span: branch.tokenSpan });
-}
-function evaluateToken(occurrence, rule) {
-  const diagnostics = [];
-  const used = occurrence.token;
-  const preferred = rule.preferred;
-  const isAllowed = rule.allow.includes(used);
-  if (!isAllowed) {
-    const severity = levelToSeverity(rule.onDisallowed);
-    if (severity) {
-      diagnostics.push(
-        createDialectDiagnostic(
-          "dialect.token.disallowed",
-          severity,
-          used,
-          preferred,
-          occurrence.span,
-          `Token "${used}" is not allowed for ${occurrence.kind}. Preferred: "${preferred}".`
-        )
-      );
-    }
-    return diagnostics;
-  }
-  if (used !== preferred) {
-    const severity = levelToSeverity(rule.onDisallowed);
-    if (severity) {
-      diagnostics.push(
-        createDialectDiagnostic(
-          "dialect.token.nonPreferred",
-          severity,
-          used,
-          preferred,
-          occurrence.span,
-          `Token "${used}" is allowed but not preferred for ${occurrence.kind}. Preferred: "${preferred}".`
-        )
-      );
-    }
-  }
-  return diagnostics;
-}
-function createDialectDiagnostic(code, severity, used, preferred, span, message) {
-  const fix = span ? {
-    range: span,
-    replacementText: preferred
-  } : void 0;
-  return {
-    severity,
-    code,
-    message: message.replace(/\\s+/g, " "),
-    span,
-    fix
-  };
-}
-function levelToSeverity(level) {
-  if (level === "off") {
-    return null;
-  }
-  if (level === "error") {
-    return "error";
-  }
-  return "warning";
-}
-
-// src/props.ts
-var IGNORED_IDENTIFIERS2 = /* @__PURE__ */ new Set([
-  "null",
-  "undefined",
-  "true",
-  "false",
-  "NaN",
-  "Infinity",
-  "this",
-  "props"
-]);
-var RESERVED_KEYWORDS2 = /* @__PURE__ */ new Set([
-  "await",
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "enum",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "import",
-  "in",
-  "instanceof",
-  "let",
-  "new",
-  "null",
-  "return",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "yield"
-]);
-function enforceProps(root, propsConfig) {
-  const diagnostics = [];
-  const declaredProps = /* @__PURE__ */ new Map();
-  const usedLocal = /* @__PURE__ */ new Map();
-  const usedNamespace = /* @__PURE__ */ new Map();
-  const usedAny = /* @__PURE__ */ new Set();
-  const missingReported = /* @__PURE__ */ new Set();
-  const localStyleReported = /* @__PURE__ */ new Set();
-  const namespaceStyleReported = /* @__PURE__ */ new Set();
-  if (root.props?.fields) {
-    for (const field of root.props.fields) {
-      declaredProps.set(field.name, field);
-    }
-  }
-  const preferStyle = propsConfig.preferAccessStyle;
-  const flagLocalStyle = !propsConfig.allowDeclaredLocals || preferStyle === "namespace";
-  const flagNamespaceStyle = !propsConfig.allowPropsNamespace || preferStyle === "locals";
-  const walkNodes2 = (nodes, locals) => {
-    for (const node of nodes) {
-      if (node.type === "Conditional") {
-        handleConditional(node, locals);
-        continue;
-      }
-      if (node.type === "For") {
-        handleFor(node, locals);
-        continue;
-      }
-      if (node.type === "Expression") {
-        handleExpression(node.value, node.span, locals);
-        continue;
-      }
-      if (node.type === "JSXPassthrough") {
-        handleExpression(node.expression, node.span, locals);
-        continue;
-      }
-      if (node.type === "Text") {
-        handleText(node.parts, locals);
-        continue;
-      }
-      if (node.type === "Element") {
-        handleElement(node, locals);
-        continue;
-      }
-      if (node.type === "Component") {
-        handleComponent(node, locals);
-        continue;
-      }
-    }
-  };
-  const handleConditional = (node, locals) => {
-    for (const branch of node.branches) {
-      if (branch.test) {
-        handleExpression(branch.test, branch.testSpan, locals);
-      }
-      walkNodes2(branch.body, locals);
-    }
-  };
-  const handleFor = (node, locals) => {
-    handleExpression(node.arrayExpr, node.arrayExprSpan, locals);
-    const nextLocals = new Set(locals);
-    nextLocals.add(node.itemName);
-    walkNodes2(node.body, nextLocals);
-  };
-  const handleElement = (node, locals) => {
-    if (node.guard) {
-      handleExpression(node.guard, node.guardSpan, locals);
-    }
-    handleAttributes(node.attributes, locals);
-    walkNodes2(node.children, locals);
-  };
-  const handleComponent = (node, locals) => {
-    if (node.guard) {
-      handleExpression(node.guard, node.guardSpan, locals);
-    }
-    handleAttributes(node.attributes, locals);
-    if (node.slots) {
-      for (const slot of node.slots) {
-        walkNodes2(slot.children, locals);
-      }
-    }
-    walkNodes2(node.children, locals);
-  };
-  const handleText = (parts, locals) => {
-    for (const part of parts) {
-      if (part.type === "expr") {
-        handleExpression(part.value, part.span, locals);
-      }
-    }
-  };
-  const handleAttributes = (attributes, locals) => {
-    for (const attr of attributes) {
-      if (!attr.value) continue;
-      const trimmed = attr.value.trim();
-      if (!trimmed || trimmed.startsWith("'") || trimmed.startsWith('"')) {
-        continue;
-      }
-      handleExpression(trimmed, void 0, locals);
-    }
-  };
-  const handleExpression = (expression, span, locals) => {
-    const occurrences = scanExpression(expression);
-    for (const occurrence of occurrences) {
-      const name = occurrence.name;
-      if (occurrence.kind === "local" && locals.has(name)) {
-        continue;
-      }
-      if (shouldIgnoreIdentifier2(name)) {
-        continue;
-      }
-      const usageSpan = span ? offsetSpan(span, occurrence.index, occurrence.length) : void 0;
-      if (occurrence.kind === "namespace") {
-        recordUsage(usedNamespace, name, usageSpan);
-        usedAny.add(name);
-        if (propsConfig.requireDeclarationForLocals && !declaredProps.has(name) && !missingReported.has(name)) {
-          const severity = levelToSeverity2(propsConfig.diagnostics.missingDeclaration);
-          if (severity) {
-            diagnostics.push(createMissingDeclarationDiagnostic(name, severity, usageSpan));
-            missingReported.add(name);
-          }
-        }
-        if (flagNamespaceStyle && !namespaceStyleReported.has(name)) {
-          const severity = levelToSeverity2(propsConfig.diagnostics.style);
-          if (severity) {
-            diagnostics.push(
-              createStyleDiagnostic(
-                name,
-                "namespace",
-                severity,
-                usageSpan,
-                propsConfig.allowPropsNamespace
-              )
-            );
-            namespaceStyleReported.add(name);
-          }
-        }
-        continue;
-      }
-      recordUsage(usedLocal, name, usageSpan);
-      usedAny.add(name);
-      if (propsConfig.requireDeclarationForLocals && !declaredProps.has(name) && !missingReported.has(name)) {
-        const severity = levelToSeverity2(propsConfig.diagnostics.missingDeclaration);
-        if (severity) {
-          diagnostics.push(createMissingDeclarationDiagnostic(name, severity, usageSpan));
-          missingReported.add(name);
-        }
-      }
-      if (flagLocalStyle && !localStyleReported.has(name)) {
-        const severity = levelToSeverity2(propsConfig.diagnostics.style);
-        if (severity) {
-          diagnostics.push(
-            createStyleDiagnostic(name, "local", severity, usageSpan, propsConfig.allowDeclaredLocals)
-          );
-          localStyleReported.add(name);
-        }
-      }
-    }
-  };
-  walkNodes2(root.children, /* @__PURE__ */ new Set());
-  if (root.props?.fields) {
-    for (const field of root.props.fields) {
-      if (!usedAny.has(field.name)) {
-        const severity = levelToSeverity2(propsConfig.diagnostics.unusedDeclaration);
-        if (severity) {
-          diagnostics.push({
-            severity,
-            code: "props.unusedDeclaration",
-            message: `Prop "${field.name}" is declared but never used.`,
-            span: field.span
-          });
-        }
-      }
-    }
-  }
-  if (propsConfig.requirePropsBlockWhen.enabled && !root.props && usedAny.size >= propsConfig.requirePropsBlockWhen.minUniquePropsUsed) {
-    const severity = levelToSeverity2(propsConfig.requirePropsBlockWhen.severity);
-    if (severity) {
-      diagnostics.push({
-        severity,
-        code: "props.block.recommendedOrRequired",
-        message: `Props block recommended: ${usedAny.size} unique prop${usedAny.size === 1 ? "" : "s"} used.`
-      });
-    }
-  }
-  return diagnostics;
-}
-function createMissingDeclarationDiagnostic(name, severity, span) {
-  return {
-    severity,
-    code: "props.missingDeclaration",
-    message: `Prop \`${name}\` is used but not declared in \`#props\`.`,
-    span,
-    data: {
-      kind: "addPropDeclaration",
-      propName: name
-    }
-  };
-}
-function createStyleDiagnostic(name, kind, severity, span, allowed) {
-  if (kind === "namespace") {
-    const message2 = allowed ? `props.${name} is allowed but not preferred; use "${name}" instead.` : `props.${name} is disabled; use "${name}" instead.`;
-    return {
-      severity,
-      code: "props.style.nonPreferred",
-      message: message2,
-      span
-    };
-  }
-  const message = allowed ? `"${name}" is allowed but not preferred; use props.${name} instead.` : `"${name}" is disabled; use props.${name} instead.`;
-  return {
-    severity,
-    code: "props.style.nonPreferred",
-    message,
-    span
-  };
-}
-function recordUsage(map, name, span) {
-  const existing = map.get(name);
-  if (existing) {
-    existing.count += 1;
-    return;
-  }
-  map.set(name, { count: 1, span });
-}
-function scanExpression(expression) {
-  const occurrences = [];
-  let i = 0;
-  let state = "code";
-  while (i < expression.length) {
-    const ch = expression[i];
-    if (state === "code") {
-      if (ch === "'" || ch === '"') {
-        state = ch === "'" ? "single" : "double";
-        i++;
-        continue;
-      }
-      if (ch === "`") {
-        state = "template";
-        i++;
-        continue;
-      }
-      if (ch === "/" && expression[i + 1] === "/") {
-        state = "line";
-        i += 2;
-        continue;
-      }
-      if (ch === "/" && expression[i + 1] === "*") {
-        state = "block";
-        i += 2;
-        continue;
-      }
-      if (isIdentifierStart2(ch)) {
-        const start = i;
-        i++;
-        while (i < expression.length && isIdentifierPart2(expression[i])) {
-          i++;
-        }
-        const name = expression.slice(start, i);
-        const prevNonSpace = findPreviousNonSpace2(expression, start - 1);
-        if (name === "props" && prevNonSpace !== ".") {
-          const namespace = readNamespaceAccess(expression, i);
-          if (namespace) {
-            occurrences.push({
-              name: namespace.name,
-              kind: "namespace",
-              index: namespace.index,
-              length: namespace.name.length
-            });
-            i = namespace.endIndex;
-            continue;
-          }
-        }
-        if (prevNonSpace !== ".") {
-          occurrences.push({ name, kind: "local", index: start, length: name.length });
-        }
-        continue;
-      }
-      i++;
-      continue;
-    }
-    if (state === "line") {
-      if (ch === "\n") {
-        state = "code";
-      }
-      i++;
-      continue;
-    }
-    if (state === "block") {
-      if (ch === "*" && expression[i + 1] === "/") {
-        state = "code";
-        i += 2;
-        continue;
-      }
-      i++;
-      continue;
-    }
-    if (state === "single") {
-      if (ch === "\\") {
-        i += 2;
-        continue;
-      }
-      if (ch === "'") {
-        state = "code";
-      }
-      i++;
-      continue;
-    }
-    if (state === "double") {
-      if (ch === "\\") {
-        i += 2;
-        continue;
-      }
-      if (ch === '"') {
-        state = "code";
-      }
-      i++;
-      continue;
-    }
-    if (state === "template") {
-      if (ch === "\\") {
-        i += 2;
-        continue;
-      }
-      if (ch === "`") {
-        state = "code";
-        i++;
-        continue;
-      }
-      i++;
-      continue;
-    }
+      }
+      return char;
   }
-  return occurrences;
 }
-function readNamespaceAccess(expression, startIndex) {
-  let i = startIndex;
-  while (i < expression.length && /\s/.test(expression[i])) {
-    i++;
-  }
-  if (expression[i] === "?") {
-    if (expression[i + 1] !== ".") {
-      return null;
-    }
-    i += 2;
-  } else if (expression[i] === ".") {
-    i++;
-  } else {
-    return null;
-  }
-  while (i < expression.length && /\s/.test(expression[i])) {
-    i++;
-  }
-  if (!isIdentifierStart2(expression[i])) {
-    return null;
+function buildClassAliasEnvironment2(decl) {
+  const env = /* @__PURE__ */ new Map();
+  if (!decl) {
+    return env;
   }
-  const propStart = i;
-  i++;
-  while (i < expression.length && isIdentifierPart2(expression[i])) {
-    i++;
+  for (const alias of decl.aliases) {
+    env.set(alias.name, alias.classes);
   }
-  return {
-    name: expression.slice(propStart, i),
-    index: propStart,
-    endIndex: i
-  };
+  return env;
 }
-function findPreviousNonSpace2(text, index) {
-  for (let i = index; i >= 0; i--) {
-    const ch = text[i];
-    if (!/\s/.test(ch)) {
-      return ch;
+function expandClasses2(classes, aliasEnv) {
+  const result = [];
+  for (const cls of classes) {
+    const match = cls.match(/^\$([A-Za-z_][A-Za-z0-9_]*)$/);
+    if (!match) {
+      result.push(cls);
+      continue;
+    }
+    const aliasClasses = aliasEnv.get(match[1]);
+    if (!aliasClasses) {
+      continue;
     }
+    result.push(...aliasClasses);
   }
-  return null;
-}
-function isIdentifierStart2(ch) {
-  return /[A-Za-z_$]/.test(ch);
-}
-function isIdentifierPart2(ch) {
-  return /[A-Za-z0-9_$]/.test(ch);
+  return result;
 }
-function shouldIgnoreIdentifier2(name) {
-  return IGNORED_IDENTIFIERS2.has(name) || RESERVED_KEYWORDS2.has(name);
+function escapeStaticText(value) {
+  return value.replace(/[&<>{}]/g, (char) => {
+    switch (char) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case "{":
+        return "&#123;";
+      case "}":
+        return "&#125;";
+      default:
+        return char;
+    }
+  });
 }
-function levelToSeverity2(level) {
-  if (level === "off") {
-    return null;
-  }
-  if (level === "error") {
-    return "error";
-  }
-  return "warning";
+function escapeAttributeValue(value) {
+  return value.replace(/["&<>]/g, (char) => {
+    switch (char) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      default:
+        return char;
+    }
+  });
 }
-function offsetSpan(base, index, length) {
-  const startOffset = base.start.offset + index;
-  const startCol = base.start.col + index;
+
+// src/diagnostics.ts
+function createSpan(line, col, length, lineOffset) {
+  const startOffset = lineOffset + col - 1;
   return {
-    start: {
-      line: base.start.line,
-      col: startCol,
-      offset: startOffset
-    },
-    end: {
-      line: base.start.line,
-      col: startCol + length,
-      offset: startOffset + length
-    }
+    start: { line, col, offset: startOffset },
+    end: { line, col: col + length, offset: startOffset + length }
   };
 }
-function enforcePropAliases(root) {
-  if (!root.propsDecls || root.propsDecls.length === 0) {
-    return [];
-  }
+
+// src/dialect.ts
+function enforceDialect(root, config) {
   const diagnostics = [];
-  const declaredProps = new Map(root.propsDecls.map((d) => [d.name, d]));
-  const allUsage = collectTemplateUsage(root);
-  for (const name of allUsage.usedBare) {
-    if (!declaredProps.has(name) && !shouldIgnoreForDiagnostics(name)) {
-      diagnostics.push({
-        severity: "warning",
-        code: "props.missingDeclaration",
-        message: `Identifier "${name}" is used without "props." but is not declared in #props. Declare "${name}" in #props or use "props.${name}".`
-      });
-    }
-  }
-  for (const [name, decl] of declaredProps) {
-    const usedAsBare = allUsage.usedBareAliases.has(name);
-    const usedAsProps = allUsage.usedPropsDot.has(name);
-    if (!usedAsBare && !usedAsProps) {
-      diagnostics.push({
-        severity: "warning",
-        code: "props.unusedDeclaration",
-        message: `Prop "${name}" is declared in #props but never used in this template.`,
-        span: decl.span
-      });
-    }
-  }
-  for (const name of allUsage.usedPropsDot) {
-    if (declaredProps.has(name)) {
-      diagnostics.push({
-        severity: "warning",
-        code: "props.style.nonPreferred",
-        message: `"props.${name}" is unnecessary because "${name}" is declared in #props. Use "{${name}}" instead.`
-      });
-    }
-  }
-  for (const [name, decl] of declaredProps) {
-    const isCallable = decl.kind === "callable";
-    const usedAsCall = allUsage.callSitesBare.has(name);
-    const usedAsValue = allUsage.usedBareAliases.has(name) && !usedAsCall;
-    if (isCallable && usedAsValue) {
-      diagnostics.push({
-        severity: "warning",
-        code: "props.style.nonPreferred",
-        message: `"${name}" is declared as callable in #props (${name}()) but used as a value.`
-      });
-    } else if (!isCallable && usedAsCall) {
-      diagnostics.push({
-        severity: "warning",
-        code: "props.style.nonPreferred",
-        message: `"${name}" is declared as a value in #props but used as a function call.`
-      });
-    }
+  if (root.idToken) {
+    diagnostics.push(
+      ...evaluateToken(
+        { kind: "id", token: root.idToken, span: root.idTokenSpan },
+        config.tokens.id
+      )
+    );
   }
+  walkNodes(root.children, (occurrence) => {
+    const rule = config.tokens[occurrence.kind];
+    diagnostics.push(...evaluateToken(occurrence, rule));
+  });
   return diagnostics;
 }
-function collectTemplateUsage(root) {
-  const usage = {
-    usedBare: /* @__PURE__ */ new Set(),
-    usedBareAliases: /* @__PURE__ */ new Set(),
-    usedPropsDot: /* @__PURE__ */ new Set(),
-    callSitesBare: /* @__PURE__ */ new Set(),
-    callSitesPropsDot: /* @__PURE__ */ new Set()
-  };
-  const env = createTemplateEnv(root.propsDecls);
-  function mergeResult(result) {
-    for (const name of result.usedBare) {
-      usage.usedBare.add(name);
-    }
-    for (const name of result.rewrittenAliases) {
-      usage.usedBareAliases.add(name);
-    }
-    for (const name of result.usedPropsDot) {
-      usage.usedPropsDot.add(name);
+function walkNodes(nodes, onToken) {
+  for (const node of nodes) {
+    if (node.type === "For") {
+      onFor(node, onToken);
+      walkNodes(node.body, onToken);
+      continue;
     }
-    for (const name of result.callSitesBare) {
-      usage.callSitesBare.add(name);
+    if (node.type === "Conditional") {
+      onConditional(node, onToken);
+      continue;
     }
-    for (const name of result.callSitesPropsDot) {
-      usage.callSitesPropsDot.add(name);
+    if (node.type === "Element" || node.type === "Component") {
+      walkNodes(node.children, onToken);
+      if (node.type === "Component" && node.slots) {
+        for (const slot of node.slots) {
+          walkNodes(slot.children, onToken);
+        }
+      }
+      continue;
     }
   }
-  function analyzeExpression(expr) {
-    if (!expr) return;
-    const result = rewriteExpression(expr, env);
-    mergeResult(result);
+}
+function onFor(node, onToken) {
+  if (!node.token) {
+    return;
   }
-  function analyzeJsxExpression(expr) {
-    if (!expr) return;
-    const result = rewriteJsxExpression(expr, env);
-    mergeResult(result);
+  onToken({ kind: "for", token: node.token, span: node.tokenSpan });
+}
+function onConditional(node, onToken) {
+  for (const branch of node.branches) {
+    onBranch(branch, onToken);
+    walkNodes(branch.body, onToken);
   }
-  function walkNode(node) {
-    switch (node.type) {
-      case "Text":
-        for (const part of node.parts) {
-          if (part.type === "expr") {
-            analyzeExpression(part.value);
-          }
-        }
-        break;
-      case "Expression":
-        analyzeExpression(node.value);
-        break;
-      case "JSXPassthrough":
-        analyzeJsxExpression(node.expression);
-        break;
-      case "Element":
-        if (node.guard) {
-          analyzeExpression(node.guard);
-        }
-        for (const attr of node.attributes) {
-          if (attr.value) {
-            analyzeAttributeValue(attr.value);
-          }
-        }
-        for (const child of node.children) {
-          walkNode(child);
-        }
-        break;
-      case "Component":
-        if (node.guard) {
-          analyzeExpression(node.guard);
-        }
-        for (const attr of node.attributes) {
-          if (attr.value) {
-            analyzeAttributeValue(attr.value);
-          }
-        }
-        if (node.slots) {
-          for (const slot of node.slots) {
-            for (const child of slot.children) {
-              walkNode(child);
-            }
-          }
-        }
-        for (const child of node.children) {
-          walkNode(child);
-        }
-        break;
-      case "Conditional":
-        for (const branch of node.branches) {
-          if (branch.test) {
-            analyzeExpression(branch.test);
-          }
-          for (const child of branch.body) {
-            walkNode(child);
-          }
-        }
-        break;
-      case "For":
-        analyzeExpression(node.arrayExpr);
-        for (const child of node.body) {
-          walkNode(child);
-        }
-        break;
-    }
+}
+function onBranch(branch, onToken) {
+  if (!branch.token || !branch.kind) {
+    return;
   }
-  function analyzeAttributeValue(value) {
-    const trimmed = value.trim();
-    if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
-      return;
-    }
-    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-      const inner = trimmed.slice(1, -1);
-      analyzeExpression(inner);
-    } else {
-      analyzeExpression(trimmed);
+  onToken({ kind: branch.kind, token: branch.token, span: branch.tokenSpan });
+}
+function evaluateToken(occurrence, rule) {
+  const diagnostics = [];
+  const used = occurrence.token;
+  const preferred = rule.preferred;
+  const isAllowed = rule.allow.includes(used);
+  if (!isAllowed) {
+    const severity = levelToSeverity(rule.onDisallowed);
+    if (severity) {
+      diagnostics.push(
+        createDialectDiagnostic(
+          "dialect.token.disallowed",
+          severity,
+          used,
+          preferred,
+          occurrence.span,
+          `Token "${used}" is not allowed for ${occurrence.kind}. Preferred: "${preferred}".`
+        )
+      );
     }
+    return diagnostics;
   }
-  for (const child of root.children) {
-    walkNode(child);
+  if (used !== preferred) {
+    const severity = levelToSeverity(rule.onDisallowed);
+    if (severity) {
+      diagnostics.push(
+        createDialectDiagnostic(
+          "dialect.token.nonPreferred",
+          severity,
+          used,
+          preferred,
+          occurrence.span,
+          `Token "${used}" is allowed but not preferred for ${occurrence.kind}. Preferred: "${preferred}".`
+        )
+      );
+    }
   }
-  return usage;
+  return diagnostics;
+}
+function createDialectDiagnostic(code, severity, used, preferred, span, message) {
+  const fix = span ? {
+    range: span,
+    replacementText: preferred
+  } : void 0;
+  return {
+    severity,
+    code,
+    message: message.replace(/\\s+/g, " "),
+    span,
+    fix
+  };
 }
-function shouldIgnoreForDiagnostics(name) {
-  return IGNORED_IDENTIFIERS2.has(name) || RESERVED_KEYWORDS2.has(name);
+function levelToSeverity(level) {
+  if (level === "off") {
+    return null;
+  }
+  if (level === "error") {
+    return "error";
+  }
+  return "warning";
 }
 
 // src/parser.ts
@@ -1934,7 +1600,7 @@ function parseTemplateBlock(lines, lineOffsets, startIndex, endIndex, options) {
   const diagnostics = [];
   const root = { type: "Root", children: [] };
   const stack = [{ node: root, level: -1 }];
-  let propsBlockLevel = null;
+  let inputsBlockLevel = null;
   let classesBlockLevel = null;
   let sawTopLevelTemplateNode = false;
   const conditionalChains = /* @__PURE__ */ new Map();
@@ -1976,19 +1642,19 @@ function parseTemplateBlock(lines, lineOffsets, startIndex, endIndex, options) {
       continue;
     }
     let level = indent / 2;
-    if (propsBlockLevel !== null && level <= propsBlockLevel) {
-      propsBlockLevel = null;
+    if (inputsBlockLevel !== null && level <= inputsBlockLevel) {
+      inputsBlockLevel = null;
     }
     if (classesBlockLevel !== null && level <= classesBlockLevel) {
       classesBlockLevel = null;
     }
-    const isInPropsBlock = propsBlockLevel !== null && level > propsBlockLevel;
+    const isInInputsBlock = inputsBlockLevel !== null && level > inputsBlockLevel;
     const isInClassesBlock = classesBlockLevel !== null && level > classesBlockLevel;
     while (stack.length > 1 && stack[stack.length - 1].level >= level) {
       stack.pop();
     }
     const parentLevel = stack[stack.length - 1].level;
-    if (level > parentLevel + 1 && !isInPropsBlock && !isInClassesBlock) {
+    if (level > parentLevel + 1 && !isInInputsBlock && !isInClassesBlock) {
       pushDiag(
         diagnostics,
         "COLLIE003",
@@ -2034,48 +1700,35 @@ function parseTemplateBlock(lines, lineOffsets, startIndex, endIndex, options) {
       }
       continue;
     }
-    if (trimmed === "props") {
-      pushDiag(
-        diagnostics,
-        "COLLIE103",
-        "`props` must be declared using `#props`.",
-        lineNumber,
-        indent + 1,
-        lineOffset,
-        trimmed.length
-      );
-      if (level === 0) {
-        propsBlockLevel = level;
-      }
-      continue;
-    }
-    if (trimmed === "#props") {
+    if (trimmed === "#inputs") {
       if (level !== 0) {
         pushDiag(
           diagnostics,
           "COLLIE102",
-          "#props block must be at the top level.",
+          "#inputs block must be at the top level.",
           lineNumber,
           indent + 1,
           lineOffset,
           trimmed.length
         );
-      } else if (root.props) {
+      } else if (root.inputs) {
         pushDiag(
           diagnostics,
           "COLLIE101",
-          "Only one #props block is allowed per #id.",
+          "Only one #inputs block is allowed per #id.",
           lineNumber,
           indent + 1,
           lineOffset,
           trimmed.length
         );
       } else {
-        root.props = { fields: [] };
-        root.propsDecls = [];
+        root.inputs = { fields: [] };
       }
       if (level === 0) {
-        propsBlockLevel = level;
+        if (!root.inputsDecls) {
+          root.inputsDecls = [];
+        }
+        inputsBlockLevel = level;
       }
       continue;
     }
@@ -2115,33 +1768,33 @@ function parseTemplateBlock(lines, lineOffsets, startIndex, endIndex, options) {
       }
       continue;
     }
-    if (propsBlockLevel !== null && level > propsBlockLevel) {
-      if (level !== propsBlockLevel + 1) {
+    if (inputsBlockLevel !== null && level > inputsBlockLevel) {
+      if (level !== inputsBlockLevel + 1) {
         pushDiag(
           diagnostics,
           "COLLIE102",
-          "#props lines must be indented two spaces under the #props header.",
+          "#inputs lines must be indented two spaces under the #inputs header.",
           lineNumber,
           indent + 1,
           lineOffset
         );
         continue;
       }
-      const decl = parsePropDecl(lineContent, lineNumber, indent + 1, lineOffset, diagnostics);
-      if (decl && root.propsDecls) {
-        const existing = root.propsDecls.find((d) => d.name === decl.name);
+      const decl = parseInputDecl(lineContent, lineNumber, indent + 1, lineOffset, diagnostics);
+      if (decl && root.inputsDecls) {
+        const existing = root.inputsDecls.find((d) => d.name === decl.name);
         if (existing) {
           pushDiag(
             diagnostics,
             "COLLIE106",
-            `Duplicate prop declaration "${decl.name}".`,
+            `Duplicate input declaration "${decl.name}".`,
             lineNumber,
             indent + 1,
             lineOffset,
             trimmed.length
           );
         } else {
-          root.propsDecls.push(decl);
+          root.inputsDecls.push(decl);
         }
       }
       continue;
@@ -2554,9 +2207,7 @@ function parseTemplateBlock(lines, lineOffsets, startIndex, endIndex, options) {
   }
   if (options.dialect) {
     diagnostics.push(...enforceDialect(root, options.dialect));
-    diagnostics.push(...enforceProps(root, options.dialect.props));
   }
-  diagnostics.push(...enforcePropAliases(root));
   return { root, diagnostics };
 }
 function buildLineOffsets(lines) {
@@ -3716,13 +3367,13 @@ function parseAndAddAttribute(attrStr, attributes, diagnostics, lineNumber, colu
     }
   }
 }
-function parsePropDecl(line, lineNumber, column, lineOffset, diagnostics) {
+function parseInputDecl(line, lineNumber, column, lineOffset, diagnostics) {
   const trimmed = line.trim();
   if (trimmed.includes(":") || trimmed.includes("<") || trimmed.includes("?")) {
     pushDiag(
       diagnostics,
       "COLLIE104",
-      'Types are not supported in #props yet. Use "name" or "name()".',
+      'Types are not supported in #inputs yet. Use "name" or "name()".',
       lineNumber,
       column,
       lineOffset,
@@ -3730,32 +3381,32 @@ function parsePropDecl(line, lineNumber, column, lineOffset, diagnostics) {
     );
     return null;
   }
-  const callableMatch = trimmed.match(/^([A-Za-z_$][A-Za-z0-9_$]*)\(\)$/);
-  if (callableMatch) {
-    const name = callableMatch[1];
+  const valueMatch = trimmed.match(/^([A-Za-z_$][A-Za-z0-9_$]*)$/);
+  if (valueMatch) {
+    const name = valueMatch[1];
     const nameStart = line.indexOf(name);
     const nameColumn = column + nameStart;
     return {
       name,
-      kind: "callable",
+      kind: "value",
       span: createSpan(lineNumber, nameColumn, name.length, lineOffset)
     };
   }
-  const valueMatch = trimmed.match(/^([A-Za-z_$][A-Za-z0-9_$]*)$/);
-  if (valueMatch) {
-    const name = valueMatch[1];
+  const fnMatch = trimmed.match(/^([A-Za-z_$][A-Za-z0-9_$]*)\(\)$/);
+  if (fnMatch) {
+    const name = fnMatch[1];
     const nameStart = line.indexOf(name);
     const nameColumn = column + nameStart;
     return {
       name,
-      kind: "value",
+      kind: "fn",
       span: createSpan(lineNumber, nameColumn, name.length, lineOffset)
     };
   }
   pushDiag(
     diagnostics,
     "COLLIE105",
-    'Invalid #props declaration. Use "name" or "name()".',
+    'Invalid #inputs declaration. Use "name" or "name()".',
     lineNumber,
     column,
     lineOffset,
@@ -3890,8 +3541,8 @@ function serializeRoot(root, indentSize) {
   if (root.classAliases && root.classAliases.aliases.length > 0) {
     sections.push(formatClassAliases(root.classAliases, indentSize));
   }
-  if (root.props && root.props.fields.length > 0) {
-    sections.push(formatProps(root.props, indentSize));
+  if (root.inputs && root.inputs.fields.length > 0) {
+    sections.push(formatInputs(root.inputs, indentSize));
   }
   if (root.children.length > 0) {
     sections.push(formatNodes(root.children, 0, indentSize));
@@ -3920,10 +3571,10 @@ function formatClassAliases(decl, indentSize) {
   }
   return lines;
 }
-function formatProps(props, indentSize) {
+function formatInputs(inputs, indentSize) {
   const indent = indentString(1, indentSize);
-  const lines = ["props"];
-  for (const field of props.fields) {
+  const lines = ["#inputs"];
+  for (const field of inputs.fields) {
     const optionalFlag = field.optional ? "?" : "";
     lines.push(cleanLine(`${indent}${field.name}${optionalFlag}: ${field.typeText.trim()}`));
   }
@@ -4113,19 +3764,19 @@ function convertTsxToCollie(source, options = {}) {
   );
   const warnings = [];
   const ctx = { sourceFile, warnings };
-  const propDeclarations = collectPropDeclarations(sourceFile);
-  const component = findComponentInfo(sourceFile, propDeclarations, ctx);
+  const inputDeclarations = collectInputDeclarations(sourceFile);
+  const component = findComponentInfo(sourceFile, inputDeclarations, ctx);
   if (!component) {
     throw new Error("Could not find a component that returns JSX in this file.");
   }
-  const propsLines = buildPropsBlock(component, propDeclarations, ctx);
+  const inputsLines = buildInputsBlock(component, inputDeclarations, ctx);
   const templateLines = convertJsxNode(component.jsxRoot, ctx, 0);
   if (!templateLines.length) {
     throw new Error("Unable to convert JSX tree to Collie template.");
   }
   const sections = [];
-  if (propsLines.length) {
-    sections.push(propsLines.join("\n"));
+  if (inputsLines.length) {
+    sections.push(inputsLines.join("\n"));
   }
   sections.push(templateLines.join("\n"));
   const collie = `${sections.join("\n\n").trimEnd()}
@@ -4140,18 +3791,18 @@ function inferScriptKind(filename) {
   if (ext === ".ts") return import_typescript.default.ScriptKind.TS;
   return import_typescript.default.ScriptKind.JS;
 }
-function collectPropDeclarations(sourceFile) {
+function collectInputDeclarations(sourceFile) {
   const map = /* @__PURE__ */ new Map();
   for (const statement of sourceFile.statements) {
     if (import_typescript.default.isInterfaceDeclaration(statement) && statement.name) {
-      map.set(statement.name.text, extractPropsFromMembers(statement.members, sourceFile));
+      map.set(statement.name.text, extractInputsFromMembers(statement.members, sourceFile));
     } else if (import_typescript.default.isTypeAliasDeclaration(statement) && import_typescript.default.isTypeLiteralNode(statement.type)) {
-      map.set(statement.name.text, extractPropsFromMembers(statement.type.members, sourceFile));
+      map.set(statement.name.text, extractInputsFromMembers(statement.type.members, sourceFile));
     }
   }
   return map;
 }
-function extractPropsFromMembers(members, sourceFile) {
+function extractInputsFromMembers(members, sourceFile) {
   const fields = [];
   for (const member of members) {
     if (!import_typescript.default.isPropertySignature(member) || member.name === void 0) {
@@ -4176,11 +3827,11 @@ function findComponentInfo(sourceFile, declarations, ctx) {
       const jsx = findJsxReturn(statement.body);
       if (jsx) {
         const defaults = extractDefaultsFromParameters(statement.parameters, ctx);
-        const propsInfo = resolvePropsFromParameters(statement.parameters, declarations, ctx);
+        const inputsInfo = resolveInputsFromParameters(statement.parameters, declarations, ctx);
         return {
           jsxRoot: jsx,
-          propsTypeName: propsInfo.typeName,
-          inlineProps: propsInfo.inline,
+          inputsTypeName: inputsInfo.typeName,
+          inlineInputs: inputsInfo.inline,
           defaults
         };
       }
@@ -4194,20 +3845,20 @@ function findComponentInfo(sourceFile, declarations, ctx) {
             continue;
           }
           const defaults = extractDefaultsFromParameters(init.parameters, ctx);
-          const propsInfo = resolvePropsFromParameters(init.parameters, declarations, ctx);
-          if (!propsInfo.typeName && !propsInfo.inline && decl.type) {
-            const inferred = resolvePropsFromTypeAnnotation(decl.type, sourceFile, declarations);
-            if (inferred.typeName && !propsInfo.typeName) {
-              propsInfo.typeName = inferred.typeName;
+          const inputsInfo = resolveInputsFromParameters(init.parameters, declarations, ctx);
+          if (!inputsInfo.typeName && !inputsInfo.inline && decl.type) {
+            const inferred = resolveInputsFromTypeAnnotation(decl.type, sourceFile, declarations);
+            if (inferred.typeName && !inputsInfo.typeName) {
+              inputsInfo.typeName = inferred.typeName;
             }
-            if (inferred.inline && !propsInfo.inline) {
-              propsInfo.inline = inferred.inline;
+            if (inferred.inline && !inputsInfo.inline) {
+              inputsInfo.inline = inferred.inline;
             }
           }
           return {
             jsxRoot: jsx,
-            propsTypeName: propsInfo.typeName,
-            inlineProps: propsInfo.inline,
+            inputsTypeName: inputsInfo.typeName,
+            inlineInputs: inputsInfo.inline,
             defaults
           };
         }
@@ -4216,13 +3867,13 @@ function findComponentInfo(sourceFile, declarations, ctx) {
   }
   return null;
 }
-function resolvePropsFromParameters(parameters, declarations, ctx) {
+function resolveInputsFromParameters(parameters, declarations, ctx) {
   if (!parameters.length) {
     return {};
   }
   const param = parameters[0];
   if (param.type) {
-    const inferred = resolvePropsFromTypeAnnotation(param.type, ctx.sourceFile, declarations);
+    const inferred = resolveInputsFromTypeAnnotation(param.type, ctx.sourceFile, declarations);
     if (inferred.inline) {
       return inferred;
     }
@@ -4232,7 +3883,7 @@ function resolvePropsFromParameters(parameters, declarations, ctx) {
   }
   return {};
 }
-function resolvePropsFromTypeAnnotation(typeNode, sourceFile, declarations) {
+function resolveInputsFromTypeAnnotation(typeNode, sourceFile, declarations) {
   if (import_typescript.default.isTypeReferenceNode(typeNode)) {
     const referenced = getTypeReferenceName(typeNode.typeName);
     if (referenced && declarations.has(referenced)) {
@@ -4246,12 +3897,12 @@ function resolvePropsFromTypeAnnotation(typeNode, sourceFile, declarations) {
           return { typeName: nested };
         }
       } else if (import_typescript.default.isTypeLiteralNode(typeArg)) {
-        return { inline: extractPropsFromMembers(typeArg.members, sourceFile) };
+        return { inline: extractInputsFromMembers(typeArg.members, sourceFile) };
       }
     }
   }
   if (import_typescript.default.isTypeLiteralNode(typeNode)) {
-    return { inline: extractPropsFromMembers(typeNode.members, sourceFile) };
+    return { inline: extractInputsFromMembers(typeNode.members, sourceFile) };
   }
   return {};
 }
@@ -4307,16 +3958,16 @@ function extractDefaultsFromParameters(parameters, ctx) {
     if (!element.initializer) {
       continue;
     }
-    const propName = getBindingElementPropName(element, ctx.sourceFile);
-    if (!propName) {
+    const inputName = getBindingElementInputName(element, ctx.sourceFile);
+    if (!inputName) {
       ctx.warnings.push("Skipping complex destructured default value.");
       continue;
     }
-    defaults.set(propName, element.initializer.getText(ctx.sourceFile).trim());
+    defaults.set(inputName, element.initializer.getText(ctx.sourceFile).trim());
   }
   return defaults;
 }
-function getBindingElementPropName(element, sourceFile) {
+function getBindingElementInputName(element, sourceFile) {
   const prop = element.propertyName;
   if (prop) {
     if (import_typescript.default.isIdentifier(prop) || import_typescript.default.isStringLiteral(prop) || import_typescript.default.isNumericLiteral(prop)) {
@@ -4338,24 +3989,25 @@ function getPropertyName(name, sourceFile) {
   }
   return name.getText(sourceFile);
 }
-function buildPropsBlock(info, propDeclarations, ctx) {
-  const fields = info.inlineProps ?? (info.propsTypeName ? propDeclarations.get(info.propsTypeName) ?? [] : void 0) ?? [];
+function buildInputsBlock(info, inputDeclarations, ctx) {
+  const fields = info.inlineInputs ?? (info.inputsTypeName ? inputDeclarations.get(info.inputsTypeName) ?? [] : void 0) ?? [];
   if (!fields.length && !info.defaults.size) {
     return [];
   }
-  const lines = ["props"];
+  const lines = ["#inputs"];
   if (fields.length) {
     for (const field of fields) {
       const def = info.defaults.get(field.name);
-      let line = `  ${field.name}${field.optional ? "?" : ""}: ${field.typeText}`;
+      let line = `  ${field.name}`;
       if (def) {
-        line += ` = ${def}`;
+        ctx.warnings.push(`Default value for "${field.name}" cannot be preserved in Collie #inputs.`);
       }
       lines.push(line);
     }
   } else {
     for (const [name, defValue] of info.defaults.entries()) {
-      lines.push(`  ${name}: any = ${defValue}`);
+      ctx.warnings.push(`Default value for "${name}" cannot be preserved in Collie #inputs.`);
+      lines.push(`  ${name}`);
     }
   }
   return lines;
@@ -4636,28 +4288,28 @@ function hasErrors(diagnostics) {
 function createStubComponent(name, flavor) {
   if (flavor === "tsx") {
     return [
-      "export type Props = Record<string, never>;",
-      `export default function ${name}(props: Props) {`,
+      "export type Inputs = Record<string, never>;",
+      `export default function ${name}(__inputs: Inputs) {`,
       "  return null;",
       "}"
     ].join("\n");
   }
-  return [`export default function ${name}(props) {`, "  return null;", "}"].join("\n");
+  return [`export default function ${name}(__inputs) {`, "  return null;", "}"].join("\n");
 }
 function createStubRender(flavor) {
   if (flavor === "tsx") {
     return [
-      "export type Props = Record<string, never>;",
-      "export function render(props: any) {",
+      "export type Inputs = Record<string, never>;",
+      "export function render(__inputs: any) {",
       "  return null;",
       "}"
     ].join("\n");
   }
-  return ["export function render(props) {", "  return null;", "}"].join("\n");
+  return ["export function render(__inputs) {", "  return null;", "}"].join("\n");
 }
 function wrapRenderModuleAsComponent(renderModule, name, flavor) {
-  const signature = flavor === "tsx" ? `export default function ${name}(props: Props) {` : `export default function ${name}(props) {`;
-  const wrapper = [signature, "  return render(props);", "}"].join("\n");
+  const signature = flavor === "tsx" ? `export default function ${name}(__inputs: Inputs) {` : `export default function ${name}(__inputs) {`;
+  const wrapper = [signature, "  return render(__inputs);", "}"].join("\n");
   return `${renderModule}
 
 ${wrapper}`;