@solidjs/babel-plugin 2.0.0-rc.5 → 2.0.0-rc.7

package/index.js

@@ -1520,7 +1520,11 @@ value,
   const isLocked = isLockedDOMProperty(tagName, name);
 
   if (isChildProp || namespace === "prop" || isLocked) {
-    if (config.hydratable && namespace !== "prop" && !isLocked) {
+    // Locked/stateful DOM properties (value/checked/...) must go through the
+    // runtime in hydratable builds so the hydration claim pass can adopt
+    // pre-hydration user state instead of overwriting it (#3182). setProperty
+    // carries the select-microtask and input/textarea nullish special cases.
+    if (config.hydratable && (isLocked || namespace !== "prop")) {
       return t$1.callExpression(registerImportMethod(path, "setProperty"), [
       elem,
       t$1.stringLiteral(name),
@@ -2330,7 +2334,10 @@ results)
       }
 
       // properties
-      if (staticValue && ChildProperties.has(key)) {
+      if (
+      staticValue && (
+      ChildProperties.has(key) || tagName === "select" && key === "value"))
+      {
         results.exprs.push(
           t$1.expressionStatement(
             setAttr$2(attribute, elem, key, staticValue, { tagName })
@@ -2814,170 +2821,6 @@ attributes,
 
 }
 
-/**
- * Patch-mode eligibility + emission (DESIGN-PATCH-CHANNEL.md, PR-C).
- *
- * A template scope qualifies for patch mode when EVERY dynamic binding's
- * value is a pure expression over member reads of ONE stable subject
- * identifier (Tier 1: bare member chains; Tier 2: ternary/binary/logical/
- * template-literal/unary compositions of Tier-1 reads and literals).
- * Anything else — calls, assignments, functions, foreign identifiers —
- * disqualifies the SCOPE (per-binding islands remain future work; v1 is
- * all-or-nothing per template scope, matching the fixture shape).
- *
- * Emission (dual driver, shared body):
- *
- *   _$patchDriver(subject, (_n$, _p$, _f$) => {
- *     let _v$;
- *     if (_f$ || (_v$ = <expr(_n$)>) !== <expr(_p$)>) <setAttr(..., _v$)>;
- *     ...
- *   });
- *
- * The runtime driver registers on the store's patch channel when the
- * subject is a patchable record, else falls back to a tracked force-mode
- * effect running the same body (reads through the subject track; force
- * short-circuits every compare, so `prev` is never dereferenced there).
- * Semantics are therefore IDENTICAL either way; patch mode only changes
- * who dispatches.
- */
-
-// Node types allowed inside an eligible binding expression (Tier 1+2).
-function isEligibleExpr(node, subject) {
-  switch (node.type) {
-    case "Identifier":
-      return node.name === subject || node.name === "undefined";
-    case "MemberExpression":{
-        const m = node;
-        if (m.computed) {
-          if (!t__namespace.isStringLiteral(m.property) && !t__namespace.isNumericLiteral(m.property)) return false;
-        } else if (!t__namespace.isIdentifier(m.property)) {
-          return false;
-        }
-        return isEligibleExpr(m.object, subject);
-      }
-    case "StringLiteral":
-    case "NumericLiteral":
-    case "BooleanLiteral":
-    case "NullLiteral":
-    case "BigIntLiteral":
-      return true;
-    case "ConditionalExpression":{
-        const c = node;
-        return (
-          isEligibleExpr(c.test, subject) &&
-          isEligibleExpr(c.consequent, subject) &&
-          isEligibleExpr(c.alternate, subject));
-
-      }
-    case "BinaryExpression":{
-        const b = node;
-        if (b.operator === "in" || b.operator === "instanceof") return false;
-        return isEligibleExpr(b.left, subject) && isEligibleExpr(b.right, subject);
-      }
-    case "LogicalExpression":{
-        const l = node;
-        return isEligibleExpr(l.left, subject) && isEligibleExpr(l.right, subject);
-      }
-    case "UnaryExpression":{
-        const u = node;
-        if (u.operator === "delete" || u.operator === "throw") return false;
-        return isEligibleExpr(u.argument, subject);
-      }
-    case "TemplateLiteral":
-      return node.expressions.every((e) =>
-      t__namespace.isExpression(e) ? isEligibleExpr(e, subject) : false
-      );
-    case "ParenthesizedExpression":
-      return isEligibleExpr(node.expression, subject);
-    default:
-      return false;
-  }
-}
-
-/** Find the single subject: the root identifier of the FIRST member chain
- * encountered. Every other read must root at the same name. */
-function findSubject(node) {
-  switch (node.type) {
-    case "MemberExpression":
-      return findSubject(node.object);
-    case "Identifier":
-      return node.name === "undefined" ? null : node.name;
-    case "ConditionalExpression":
-      return (
-        findSubject(node.test) ??
-        findSubject(node.consequent) ??
-        findSubject(node.alternate));
-
-    case "BinaryExpression":
-    case "LogicalExpression":
-      return (
-        findSubject(node.left) ?? findSubject(node.right));
-
-    case "UnaryExpression":
-      return findSubject(node.argument);
-    case "TemplateLiteral":{
-        for (const e of node.expressions) {
-          const s = findSubject(e);
-          if (s) return s;
-        }
-        return null;
-      }
-    case "ParenthesizedExpression":
-      return findSubject(node.expression);
-    default:
-      return null;
-  }
-}
-
-
-
-
-
-/** Analyze a template scope's dynamic binding values. Returns the subject
- * when EVERY value is an eligible pure expression over it, else null. */
-function analyzePatchEligibility(values) {
-  if (values.length === 0) return null;
-  let subject = null;
-  for (const v of values) {
-    const s = findSubject(v);
-    if (s === null) return null; // static-only binding: no dispatch source
-    if (subject === null) subject = s;else
-    if (subject !== s) return null; // multi-subject: Q3 territory, bail in v1
-  }
-  if (subject === null) return null;
-  for (const v of values) {
-    if (!isEligibleExpr(v, subject)) return null;
-  }
-  return { subject };
-}
-
-/** Clone `expr` substituting the subject identifier with `replacement`.
- * Safe because eligibility rejected functions/shadowing constructs. */
-function substituteSubject(
-expr,
-subject,
-replacement)
-{
-  const clone = t__namespace.cloneNode(expr, true);
-  const rewrite = (node) => {
-    if (t__namespace.isIdentifier(node) && node.name === subject) return t__namespace.cloneNode(replacement);
-    for (const key of Object.keys(node)) {
-      const value = node[key];
-      if (Array.isArray(value)) {
-        for (let i = 0; i < value.length; i++) {
-          if (value[i] && typeof value[i].type === "string") value[i] = rewrite(value[i]);
-        }
-      } else if (value && typeof value.type === "string") {
-        // Never rewrite non-computed member PROPERTY positions.
-        if (t__namespace.isMemberExpression(node) && key === "property" && !node.computed) continue;
-        node[key] = rewrite(value);
-      }
-    }
-    return node;
-  };
-  return rewrite(clone);
-}
-
 function createTemplate$2(
 path,
 result,
@@ -2991,16 +2834,9 @@ wrap)
     !(result.exprs.length || result.dynamics.length || result.postExprs?.length) &&
     decl.declarations.length === 1)
     {
-      // Static single-root template: a candidate row function returning it is
-      // trivially pure (no reactive work at all).
-      if (config.patchDriver) recordPureRow(path, result, null);
       return decl.declarations[0].init;
     } else {
-      const patched = config.patchDriver ? wrapPatchMode(path, result.dynamics) : undefined;
-      const dynamicsStmt = patched ? patched.stmt : wrapDynamics$1(path, result.dynamics);
-      if (config.patchDriver && (result.dynamics.length === 0 || patched)) {
-        recordPureRow(path, result, patched ? patched.subject : null);
-      }
+      const dynamicsStmt = wrapDynamics$1(path, result.dynamics);
       const stmts = [
       decl,
       ...result.exprs,
@@ -3116,179 +2952,6 @@ function registerTemplate(path, results) {
   results.decl = t__namespace.variableDeclaration("var", results.declarations);
 }
 
-/**
- * Row-proof analysis (DESIGN-PATCH-CHANNEL §3c). A function qualifies as a
- * PURE ROW — buildable with no per-row owner, so the patch-mode list driver
- * may engage — when ALL of:
- *
- *  - it is a single-parameter function (plain Identifier param, not
- *    destructured; not async/generator) whose body is exactly this compiled
- *    template: an expression body, or a block whose ONLY statement returns
- *    it (checked before the flat-statement emission inserts our own);
- *  - the template has a single root element (`result.id` — fragments never
- *    reach here) and emitted NO reactive or owned work: dynamics either
- *    absent or all landed in ONE patchDriver body, and `result.exprs` holds
- *    only inert DOM wiring (member-target assignments like `_el$.$$click =
- *    fn` / `_el$.style.cssText = v`, and `_el$.addEventListener(...)`) —
- *    any `insert`/`createComponent`/`memo`/`use`/ref/spread emission is a
- *    call or conditional shape and fails the walk (default-deny);
- *  - the patch subject IS the row parameter. A pure template patching an
- *    OUTER subject would register once per created row on a long-lived
- *    record with no per-row disposal — the foreign-subject leak the runtime
- *    probe never caught.
- *
- * Handler/attribute VALUE expressions may be arbitrary user code: stamped
- * rows are only ever built for real mounts (never speculatively), so their
- * evaluation timing is identical to the classic path. Event handlers are
- * not reactive bindings — values evaluate exactly once at build — so the
- * only ownership divergence is a factory creating owned work in value
- * position (`onClick={makeHandler(row)}` calling onCleanup), which is not
- * a supported pattern (owned work belongs in effects/refs; ruled
- * non-responsibility). Denying evaluation-position calls would cost
- * legitimate currying to guard it; instead the runtime dev-asserts that a
- * stamped row's build attaches nothing to the list owner.
- *
- * Qualifying functions are recorded and wrapped with `rowProof` at program
- * exit (postprocess) — the stamp travels with the function object, so
- * extracted row functions prove at their DEFINITION site and work across
- * modules, which the runtime probe could never see.
- */
-function recordPureRow(path, result, subject) {
-  const parent = path.parentPath;
-  if (!parent) return;
-  let fn;
-  if (
-  (t__namespace.isArrowFunctionExpression(parent.node) || t__namespace.isFunctionExpression(parent.node)) &&
-  parent.node.body === path.node)
-  {
-    fn = parent.node;
-  } else if (
-  t__namespace.isReturnStatement(parent.node) &&
-  parent.node.argument === path.node &&
-  parent.parentPath &&
-  t__namespace.isBlockStatement(parent.parentPath.node) &&
-  parent.parentPath.node.body.length === 1 &&
-  parent.parentPath.parentPath && (
-  t__namespace.isArrowFunctionExpression(parent.parentPath.parentPath.node) ||
-  t__namespace.isFunctionExpression(parent.parentPath.parentPath.node)) &&
-  parent.parentPath.parentPath.node.body === parent.parentPath.node)
-  {
-    fn = parent.parentPath.parentPath.node;
-  }
-  if (!fn || fn.async || fn.generator) return;
-  if (fn.params.length !== 1 || !t__namespace.isIdentifier(fn.params[0])) return;
-  const param = fn.params[0].name;
-  if (subject !== null && subject !== param) return;
-
-  const isLocalMemberTarget = (n) => {
-    if (!t__namespace.isMemberExpression(n) || n.computed) return false;
-    let obj = n.object;
-    while (t__namespace.isMemberExpression(obj) && !obj.computed) obj = obj.object;
-    return t__namespace.isIdentifier(obj);
-  };
-  for (const stmt of result.exprs) {
-    if (!t__namespace.isExpressionStatement(stmt)) return;
-    const e = stmt.expression;
-    if (t__namespace.isAssignmentExpression(e) && e.operator === "=" && isLocalMemberTarget(e.left)) continue;
-    if (
-    t__namespace.isCallExpression(e) &&
-    t__namespace.isMemberExpression(e.callee) &&
-    !e.callee.computed &&
-    t__namespace.isIdentifier(e.callee.property) &&
-    e.callee.property.name === "addEventListener")
-
-    continue;
-    return;
-  }
-  if (result.postExprs?.length) {
-    const data = path.scope.getProgramParent().data;
-    const moduleName = getRendererConfig(path, "dom").moduleName;
-    const rheUid = data.imports?.get(`${moduleName}:runHydrationEvents`);
-    for (const stmt of result.postExprs) {
-      if (
-      !t__namespace.isExpressionStatement(stmt) ||
-      !t__namespace.isCallExpression(stmt.expression) ||
-      !t__namespace.isIdentifier(stmt.expression.callee) ||
-      !rheUid ||
-      stmt.expression.callee.name !== rheUid.name)
-
-      return;
-    }
-  }
-
-  const data = path.scope.getProgramParent().data;
-  (data.pureRows || (data.pureRows = new Set())).add(fn);
-}
-
-/** Patch-mode emission (shared/patch.ts): one compiled body doing inline
- * compares + setAttr writes, handed to the runtime driver which registers
- * on the store patch channel (patchable subject) or falls back to a
- * tracked force-mode effect running the SAME body. Returns undefined when
- * the scope is ineligible — caller falls through to the effect shapes.
- * The subject rides along for row-proof analysis (recordPureRow). */
-function wrapPatchMode(
-path,
-dynamics)
-{
-  const config = getConfig(path);
-  if (dynamics.length === 0) return;
-  const eligibility = analyzePatchEligibility(dynamics.map((d) => d.value));
-  if (!eligibility) return;
-  const subject = eligibility.subject;
-  // The subject must be a stable local binding (not reassigned): row params
-  // and const destructures qualify; anything else falls back to effects.
-  const binding = path.scope.getBinding(subject);
-  if (!binding || !binding.constant) return;
-  // Fixed `$`-suffixed locals, matching wrapDynamics' `_v$`/`_p$` convention
-  // (and byte-parity with the Oxc compiler's emission): substitution only
-  // rewrites subject references, so nothing else in an eligible expression
-  // can collide with these.
-  const nId = t__namespace.identifier("_n$");
-  const pId = t__namespace.identifier("_p$");
-  const fId = t__namespace.identifier("_f$");
-  const stmts = [];
-  let vIndex = 0;
-  for (const d of dynamics) {
-    let value = d.value;
-    if (d.classProperty && !t__namespace.isBooleanLiteral(value) && !t__namespace.isUnaryExpression(value)) {
-      value = t__namespace.unaryExpression("!", t__namespace.unaryExpression("!", value));
-    }
-    const vId = t__namespace.identifier(++vIndex === 1 ? "_v$" : `_v$${vIndex}`);
-    stmts.push(
-      t__namespace.variableDeclaration("const", [
-      t__namespace.variableDeclarator(vId, substituteSubject(value, subject, nId))]
-      )
-    );
-    stmts.push(
-      t__namespace.ifStatement(
-        t__namespace.logicalExpression(
-          "||",
-          t__namespace.cloneNode(fId),
-          t__namespace.binaryExpression("!==", t__namespace.cloneNode(vId), substituteSubject(value, subject, pId))
-        ),
-        t__namespace.expressionStatement(
-          setAttr$2(path, d.elem, d.key, t__namespace.cloneNode(vId), {
-            tagName: d.tagName,
-            dynamic: true,
-            styleProperty: d.styleProperty,
-            classProperty: d.classProperty
-          })
-        )
-      )
-    );
-  }
-  const driverId = registerImportMethod(path, config.patchDriver, undefined);
-  return {
-    stmt: t__namespace.expressionStatement(
-      t__namespace.callExpression(driverId, [
-      t__namespace.identifier(subject),
-      t__namespace.arrowFunctionExpression([nId, pId, fId], t__namespace.blockStatement(stmts))]
-      )
-    ),
-    subject
-  };
-}
-
 function wrapDynamics$1(path, dynamics) {
   if (!dynamics.length) return;
   const config = getConfig(path);
@@ -4375,9 +4038,15 @@ path,
       return memo;
     }, []);
 
+  // The DOM transform handles `ref` outside its spread prop sources.
+  const propAttributes = attributes.filter((attribute) => {
+    const node = attribute.node;
+    return !(t.isJSXAttribute(node) && t.isJSXIdentifier(node.name) && node.name.name === "ref");
+  });
+
   let props;
-  if (attributes.length === 1 && t.isJSXSpreadAttribute(attributes[0].node)) {
-    props = [attributes[0].node.argument];
+  if (propAttributes.length === 1 && t.isJSXSpreadAttribute(propAttributes[0].node)) {
+    props = [propAttributes[0].node.argument];
   } else {
     props = [];
     let runningObject = [],
@@ -14276,6 +13945,29 @@ function serialize(node, options) {
   }
   return serializeChildNodes(node, opts);
 }
+/**
+ * Serializes an AST element node to an HTML string, including the element node.
+ *
+ * @example
+ *
+ * ```js
+ * const parse5 = require('parse5');
+ *
+ * const document = parse5.parseFragment('<div>Hello, <b>world</b>!</div>');
+ *
+ * // Serializes the <div> element.
+ * const str = parse5.serializeOuter(document.childNodes[0]);
+ *
+ * console.log(str); //> '<div>Hello, <b>world</b>!</div>'
+ * ```
+ *
+ * @param node Node to serialize.
+ * @param options Serialization options.
+ */
+function serializeOuter(node, options) {
+  const opts = { ...defaultOpts, ...options };
+  return serializeNode(node, opts);
+}
 function serializeChildNodes(parentNode, options) {
   let html = '';
   // Get container of the child nodes
@@ -14409,6 +14101,29 @@ function innerHTML(htmlFragment) {
   return serialize(parsedFragment);
 }
 
+/**
+ * A document shell (`<html>`/`<head>`/`<body>` root) can never round-trip a
+ * body-context fragment parse — the parser strips those wrappers no matter
+ * how well-formed the markup is — so it is parsed as a DOCUMENT instead and
+ * the shell element serialized back out (#3259). The same "used in the right
+ * place" assumption the synthetic `<table>` makes for table partials: a
+ * shell template is hydrated against a real document, not client-created.
+ * Restructuring inside the shell still mismatches — an implied `<head>`,
+ * flow content hoisted out of `<head>`, a `<p>` split in `<body>` — so the
+ * #3099 guarantee holds for markup a browser would actually rebuild.
+ */
+function documentShell(html, tag) {
+  const document = parse(html);
+  const htmlElement = document.childNodes.find(
+    (node) => node.tagName === "html"
+  );
+  const shell =
+  tag === "html" ?
+  htmlElement :
+  htmlElement.childNodes.find((node) => node.tagName === tag);
+  return serializeOuter(shell);
+}
+
 /**
  * Returns an object with information when the markup is invalid
  *
@@ -14479,7 +14194,8 @@ function isInvalidMarkup(html) {
   }
 
   /** Parse HTML. `browser` is a string with the supposed resulting html of a real `innerHTML` call */
-  const browser = innerHTML(html);
+  const shell = /^<(html|head|body)>/.exec(html);
+  const browser = shell ? documentShell(html, shell[1]) : innerHTML(html);
 
   if (html.toLowerCase() !== browser.toLowerCase()) {
     return {
@@ -14540,35 +14256,11 @@ var postprocess = (path, state) => {
     domTemplates.length > 0 && appendTemplates$1(path, domTemplates);
     ssrTemplates.length > 0 && appendTemplates(path, ssrTemplates);
   }
-
-  // Compile-time row proofs (DESIGN-PATCH-CHANNEL §3c): wrap each function
-  // recorded by recordPureRow with the runtime's `rowProof` marker so the
-  // patch-mode list driver can engage on proven-pure rows — admission is
-  // decided here, statically; there is no runtime purity probe. The stamp
-  // travels with the function object, so extracted row functions qualify at
-  // their definition site.
-  if (data.pureRows?.size) {
-    const rowProofId = registerImportMethod(
-      path,
-      "rowProof",
-      getRendererConfig(path, "dom").moduleName
-    );
-    const pureRows = data.pureRows;
-    path.traverse({
-      "ArrowFunctionExpression|FunctionExpression"(fnPath) {
-        if (!pureRows.has(fnPath.node)) return;
-        pureRows.delete(fnPath.node);
-        fnPath.replaceWith(
-          t__namespace.callExpression(t__namespace.cloneNode(rowProofId), [fnPath.node])
-        );
-        fnPath.skip();
-      }
-    });
-  }
 };
 
 const config = {
   moduleName: "@solidjs/web",
+  syntax: "auto",
   generate: "dom",
   hydratable: false,
   dev: false,
@@ -14595,7 +14287,6 @@ const config = {
   contextToCustomElements: true,
   staticMarker: "@static",
   effectWrapper: "effect",
-  patchDriver: false,
   memoWrapper: "memo",
   validate: true,
   inlineStyles: true,
@@ -14604,10 +14295,13 @@ const config = {
 
 var preprocess = (path, state) => {
   const file = path.hub.file;
+  const parsedMetadata = file.ast.tsrxStyle;
+  if (parsedMetadata) {
+    file.metadata.css = parsedMetadata.css;
+    file.metadata.cssHash = parsedMetadata.cssHash;
+    delete file.ast.tsrxStyle;
+  }
   const merged = file.metadata.config = Object.assign({}, config, state.opts);
-  // Boolean opt-in parity with the native loader: `patchDriver: true` means
-  // the default import name (downstream code uses the value AS the name).
-  if (merged.patchDriver === true) merged.patchDriver = "patchDriver";
   const lib = merged.requireImportSource;
   if (lib) {
     const comments = file.ast.comments ?? [];
@@ -14627,14 +14321,3459 @@ var preprocess = (path, state) => {
   }
 };
 
-var index = () =>
+/**
+ * TSRX → Solid JSX desugaring.
+ *
+ * Walks the ESTree AST produced by `@tsrx/core` (before Solid's local
+ * lazy-destructuring transform runs) and lowers every TSRX construct to Solid 2.0 builtIn
+ * component JSX, in place. The result is a plain ESTree TSX program that
+ * `estree-to-babel` converts for the existing JSX pipeline. BuiltIns are
+ * referenced as bare identifiers (`Show`, `For`, …) so the plugin's normal
+ * `builtIns` auto-import machinery resolves them against `moduleName`.
+ *
+ * Lowering contract (mirrored byte-for-byte by the Oxc frontend):
+ * - `@{ body; render }` — expression position: `render` alone when there is no
+ *   setup, otherwise `(() => { body; return render; })()`; function-body
+ *   position: inline statements ending in `return render`.
+ * - `@if` — `Show` for a single branch, `Switch`/`Match` for chains; `@else`
+ *   becomes `fallback`.
+ * - `@for (const x of expr; index i; key k)` — `For`; `key` present emits
+ *   `keyed={(x) => k}`, while an index without a key emits `keyed={false}`;
+ *   `@empty` becomes `fallback`. RC `For` hands the callback an item accessor
+ *   in custom-key and non-keyed modes. The index is an accessor only with a
+ *   custom key.
+ * - `@switch` — `Switch` with one `Match when={disc === test}` per `@case`;
+ *   `@default` becomes `fallback`.
+ * - `@try/@pending/@catch (e, reset)` — `<Errored fallback={(e, reset) =>
+ *   …}><Loading fallback={pending}>{content}</Loading></Errored>`; RC
+ *   `Errored` passes an `ErrorAccessor`, so reads of `e` rewrite to calls.
+ * - `<{expr}>` — `<Dynamic component={expr} …>` (deliberate adaptation from
+ *   `@tsrx/solid`'s hoisted `dynamic()` factory; semantically equivalent).
+ *
+ * Scoped `<style>` elements are handled and stripped by the preceding style
+ * pass, so they must never reach this transform.
+ */
 
 
 
-{
-  return {
-    name: "@solidjs/babel-plugin",
-    inherits: SyntaxJSX.default,
+
+
+
+
+
+
+
+
+/** Keys that are never traversed: locations, tooling metadata, and TSRX
+ * keyword-span pointers that carry no semantics of their own. */
+const SKIP_KEYS$2 = new Set([
+"type",
+"loc",
+"start",
+"end",
+"range",
+"metadata",
+"leadingComments",
+"trailingComments",
+"innerComments",
+"alternateKeyword",
+"emptyKeyword"]
+);
+
+const RENDER_ENTRY_TYPES = new Set([
+"JSXElement",
+"JSXFragment",
+"JSXText",
+"JSXCodeBlock",
+"JSXIfExpression",
+"JSXForExpression",
+"JSXSwitchExpression",
+"JSXTryExpression",
+"JSXStyleElement"]
+);
+
+const VALID_JSX_CHILD_TYPES = new Set([
+"JSXElement",
+"JSXFragment",
+"JSXText",
+"JSXExpressionContainer",
+"JSXSpreadChild"]
+);
+
+const FUNCTION_TYPES$1 = new Set([
+"FunctionDeclaration",
+"FunctionExpression",
+"ArrowFunctionExpression"]
+);
+
+function isNode$3(value) {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof value.type === "string");
+
+}
+
+function fail$2(message, node) {
+  const start = node?.loc?.start;
+  throw new SyntaxError(start ? `${message} (${start.line}:${start.column})` : message);
+}
+
+// ---------------------------------------------------------------------------
+// ESTree builders (converted to Babel shapes later by estree-to-babel)
+// ---------------------------------------------------------------------------
+
+function withLoc$2(node, src) {
+  if (src) {
+    if (src.start !== undefined) node.start = src.start;
+    if (src.end !== undefined) node.end = src.end;
+    if (src.loc !== undefined) node.loc = src.loc;
+  }
+  return node;
+}
+
+function ident$1(name, src) {
+  return withLoc$2({ type: "Identifier", name }, src);
+}
+
+function jsxIdent(name, src) {
+  return withLoc$2({ type: "JSXIdentifier", name }, src);
+}
+
+function jsxContainer(expression, src) {
+  return withLoc$2({ type: "JSXExpressionContainer", expression }, src ?? expression);
+}
+
+function jsxAttr(name, expression, src) {
+  return withLoc$2(
+    {
+      type: "JSXAttribute",
+      name: jsxIdent(name, src),
+      value: jsxContainer(expression, src ?? expression)
+    },
+    src ?? expression
+  );
+}
+
+function jsxElement(name, attributes, children, src) {
+  const selfClosing = children.length === 0;
+  return withLoc$2(
+    {
+      type: "JSXElement",
+      openingElement: withLoc$2(
+        { type: "JSXOpeningElement", name: jsxIdent(name, src), attributes, selfClosing },
+        src
+      ),
+      closingElement: selfClosing ?
+      null :
+      withLoc$2({ type: "JSXClosingElement", name: jsxIdent(name, src) }, src),
+      children
+    },
+    src
+  );
+}
+
+function jsxFragment(children, src) {
+  return withLoc$2(
+    {
+      type: "JSXFragment",
+      openingFragment: withLoc$2({ type: "JSXOpeningFragment" }, src),
+      closingFragment: withLoc$2({ type: "JSXClosingFragment" }, src),
+      children
+    },
+    src
+  );
+}
+
+function arrow(params, body, src) {
+  return withLoc$2(
+    {
+      type: "ArrowFunctionExpression",
+      id: null,
+      params,
+      body,
+      expression: body.type !== "BlockStatement",
+      async: false,
+      generator: false
+    },
+    src
+  );
+}
+
+function blockStatement(body, src) {
+  return withLoc$2({ type: "BlockStatement", body }, src);
+}
+
+function returnStatement(argument, src) {
+  return withLoc$2({ type: "ReturnStatement", argument }, src);
+}
+
+function iife(statements, src) {
+  return withLoc$2(
+    {
+      type: "CallExpression",
+      callee: arrow([], blockStatement(statements, src), src),
+      arguments: [],
+      optional: false
+    },
+    src
+  );
+}
+
+function callOn(callee, src) {
+  return withLoc$2({ type: "CallExpression", callee, arguments: [], optional: false }, src);
+}
+
+function strictEquals(left, right, src) {
+  return withLoc$2({ type: "BinaryExpression", operator: "===", left, right }, src);
+}
+
+function stringLiteral(value, src) {
+  return withLoc$2({ type: "Literal", value, raw: JSON.stringify(value) }, src);
+}
+
+function cloneNode$1(value) {
+  if (Array.isArray(value)) return value.map(cloneNode$1);
+  if (typeof value === "object" && value !== null) {
+    const out = {};
+    for (const key of Object.keys(value)) {
+      out[key] = cloneNode$1(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+
+function accessorLazyPattern(pattern) {
+  const clone = cloneNode$1(pattern);
+  clone.lazy = true;
+  const metadata = clone.metadata ??= {};
+  delete metadata.lazy_id;
+  metadata.lazy_source_accessor = true;
+  return clone;
+}
+
+function eagerPattern(pattern) {
+  const clone = cloneNode$1(pattern);
+  clearLazy(clone);
+  return clone;
+
+  function clearLazy(node) {
+    if (node.type === "ObjectPattern" || node.type === "ArrayPattern") node.lazy = false;
+    for (const key of Object.keys(node)) {
+      if (SKIP_KEYS$2.has(key)) continue;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value) if (isNode$3(item)) clearLazy(item);
+      } else if (isNode$3(value)) {
+        clearLazy(value);
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main walk
+// ---------------------------------------------------------------------------
+
+function desugarProgram(program) {
+  genericVisit(program);
+  return program;
+}
+
+/** Desugars `node`, returning its replacement for expression-shaped slots. */
+function transform$1(node) {
+  switch (node.type) {
+    case "JSXCodeBlock":
+      return codeBlockToExpression(node);
+    case "JSXIfExpression":
+      return ifToJsx(node);
+    case "JSXForExpression":
+      return forToJsx(node);
+    case "JSXSwitchExpression":
+      return switchToJsx(node);
+    case "JSXTryExpression":
+      return tryToJsx(node);
+    case "JSXStyleElement":
+      return fail$2("A TSRX <style> element survived the scoped style pass", node);
+    case "JSXElement":
+      return desugarElement(node);
+    case "JSXFragment":
+      node.children && (node.children = desugarChildren(node.children));
+      return node;
+    default:
+      if (FUNCTION_TYPES$1.has(node.type) && isNode$3(node.body) && node.body.type === "JSXCodeBlock") {
+        const body = node.body;
+        genericVisit(node, "body");
+        node.body = codeBlockToFunctionBody(body);
+        if (node.type === "ArrowFunctionExpression") node.expression = false;
+        return node;
+      }
+      genericVisit(node);
+      return node;
+  }
+}
+
+function genericVisit(node, skipKey) {
+  for (const key of Object.keys(node)) {
+    if (SKIP_KEYS$2.has(key) || key === skipKey) continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        if (isNode$3(value[i])) value[i] = transform$1(value[i]);
+      }
+    } else if (isNode$3(value)) {
+      node[key] = transform$1(value);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Elements and children
+// ---------------------------------------------------------------------------
+
+function desugarElement(el) {
+  const opening = el.openingElement;
+  const isDynamic = !!opening.isDynamic;
+  genericVisit(opening);
+  const children = desugarChildren(el.children ?? []);
+  if (isDynamic) {
+    const nameContainer = opening.name;
+    const componentExpr = nameContainer.expression;
+    const attributes = [
+    jsxAttr("component", componentExpr, nameContainer),
+    ...(opening.attributes ?? [])];
+
+    return jsxElement("Dynamic", attributes, children, el);
+  }
+  el.children = children;
+  return el;
+}
+
+function desugarChildren(children) {
+  return children.map((child) => {
+    const result = transform$1(child);
+    if (!VALID_JSX_CHILD_TYPES.has(result.type)) return jsxContainer(result, child);
+    return result;
+  });
+}
+
+/** Embed an expression as a JSX child: JSX stays structural, everything else
+ * goes through an expression container. */
+function asChild(expression) {
+  if (expression.type === "JSXElement" || expression.type === "JSXFragment") return expression;
+  return jsxContainer(expression);
+}
+
+// ---------------------------------------------------------------------------
+// Template blocks (implicit statement containers)
+// ---------------------------------------------------------------------------
+
+
+
+
+
+
+const LOOP_TYPES = new Set([
+"ForStatement",
+"ForInStatement",
+"ForOfStatement",
+"WhileStatement",
+"DoWhileStatement"]
+);
+
+/** TSRX constructs are validation boundaries: their blocks are checked when
+ * they desugar, with their own construct label. `@{}` containers become
+ * function bodies (IIFEs) where escaping statements are legal again. */
+const ESCAPE_BOUNDARY_TYPES = new Set([
+"JSXCodeBlock",
+"JSXIfExpression",
+"JSXForExpression",
+"JSXSwitchExpression",
+"JSXTryExpression"]
+);
+
+function escapeMessage(kind, construct) {
+  // Match the ecosystem (@tsrx/solid) diagnostics verbatim for @if and @for.
+  if (construct === "@if" || construct === "@else") {
+    if (kind === "return")
+    return "Return statements are not allowed inside TSRX template @if blocks. Move the return before the template output or render conditionally instead.";
+    if (kind === "break")
+    return "Break statements are not allowed inside TSRX template @if blocks.";
+    return "Continue statements are not allowed inside TSRX template @if blocks. Filter before rendering or use conditional output instead.";
+  }
+  if (construct === "@for" || construct === "@empty") {
+    if (kind === "return")
+    return "Return statements are not allowed inside TSRX template for...of loops. Filter the iterable before rendering or use an @empty fallback for empty lists.";
+    if (kind === "break")
+    return "Break statements are not allowed inside TSRX template for...of loops.";
+    return "Continue statements are not allowed inside TSRX template for...of loops. Filter the iterable before rendering.";
+  }
+  const noun = kind === "return" ? "Return" : kind === "break" ? "Break" : "Continue";
+  return `${noun} statements are not allowed inside TSRX template ${construct} blocks.`;
+}
+
+/** Reject return/break/continue that would escape a template control-flow
+ * block. Nested functions, loops, switches, and labels open their own escape
+ * targets; nested TSRX constructs validate themselves. */
+function validateNoControlFlowEscape(entries, construct) {
+  for (const entry of entries) check(entry, 0, 0, new Set());
+
+  function check(node, loops, breakables, labels) {
+    if (FUNCTION_TYPES$1.has(node.type) || ESCAPE_BOUNDARY_TYPES.has(node.type)) return;
+    switch (node.type) {
+      case "ReturnStatement":
+        fail$2(escapeMessage("return", construct), node);
+        break;
+      case "BreakStatement":{
+          const label = isNode$3(node.label) ? node.label.name : null;
+          if (label ? !labels.has(label) : breakables === 0) {
+            fail$2(escapeMessage("break", construct), node);
+          }
+          return;
+        }
+      case "ContinueStatement":{
+          const label = isNode$3(node.label) ? node.label.name : null;
+          if (label ? !labels.has(label) : loops === 0) {
+            fail$2(escapeMessage("continue", construct), node);
+          }
+          return;
+        }
+      case "SwitchStatement":{
+          if (isNode$3(node.discriminant)) check(node.discriminant, loops, breakables, labels);
+          for (const switchCase of node.cases) {
+            check(switchCase, loops, breakables + 1, labels);
+          }
+          return;
+        }
+      case "LabeledStatement":{
+          const withLabel = new Set(labels);
+          withLabel.add(node.label.name);
+          check(node.body, loops, breakables, withLabel);
+          return;
+        }
+    }
+    const nextLoops = LOOP_TYPES.has(node.type) ? loops + 1 : loops;
+    const nextBreakables = LOOP_TYPES.has(node.type) ? breakables + 1 : breakables;
+    for (const key of Object.keys(node)) {
+      if (SKIP_KEYS$2.has(key)) continue;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value) if (isNode$3(item)) check(item, nextLoops, nextBreakables, labels);
+      } else if (isNode$3(value)) {
+        check(value, nextLoops, nextBreakables, labels);
+      }
+    }
+  }
+}
+
+function toBlockBody(node) {
+  return node.type === "BlockStatement" ? node.body : [node];
+}
+
+/** Split a template block into leading setup statements and trailing render
+ * output nodes. Setup is desugared here; renders are desugared by callers
+ * (their lowering depends on the position they land in). When `construct` is
+ * given, escaping control flow (return/break/continue) is rejected first. */
+function blockToParts(entries, construct) {
+  if (construct) validateNoControlFlowEscape(entries, construct);
+  const setup = [];
+  const renders = [];
+  for (const entry of entries) {
+    if (RENDER_ENTRY_TYPES.has(entry.type)) {
+      if (entry.type === "JSXText" && /^\s*$/.test(String(entry.value))) continue;
+      renders.push(entry);
+    } else {
+      if (renders.length > 0) {
+        fail$2("Statements may not follow the rendered output inside a TSRX template block", entry);
+      }
+      setup.push(transform$1(entry));
+    }
+  }
+  return { setup, renders };
+}
+
+function renderNodeToExpression(node) {
+  const result = transform$1(node);
+  if (result.type === "JSXText") return stringLiteral(String(result.value), result);
+  return result;
+}
+
+/** Combine desugared render nodes into one expression (fragment for
+ * siblings). Returns null when the block rendered nothing. */
+function rendersToExpression(renders, src) {
+  if (renders.length === 0) return null;
+  if (renders.length === 1) return renderNodeToExpression(renders[0]);
+  return jsxFragment(
+    renders.map((render) => {
+      const result = transform$1(render);
+      if (!VALID_JSX_CHILD_TYPES.has(result.type)) return jsxContainer(result, render);
+      return result;
+    }),
+    src
+  );
+}
+
+/** Lower a whole template block to a single expression. Returns null only for
+ * a fully empty block; a block with setup but no render is an error. */
+function blockToExpression(blockNode, context) {
+  const parts = blockToParts(toBlockBody(blockNode), context);
+  const renderExpr = rendersToExpression(parts.renders, blockNode);
+  if (parts.setup.length === 0) return renderExpr;
+  if (!renderExpr) {
+    fail$2(`A TSRX ${context} block with setup statements must end with rendered output`, blockNode);
+  }
+  return iife([...parts.setup, returnStatement(renderExpr, blockNode)], blockNode);
+}
+
+// ---------------------------------------------------------------------------
+// @{} statement containers
+// ---------------------------------------------------------------------------
+
+function codeBlockToExpression(cb) {
+  const setup = cb.body.map(transform$1);
+  if (!isNode$3(cb.render)) {
+    fail$2("A TSRX statement container is missing its rendered output node", cb);
+  }
+  const renderExpr = renderNodeToExpression(cb.render);
+  if (setup.length === 0) return renderExpr;
+  return iife([...setup, returnStatement(renderExpr, cb)], cb);
+}
+
+function codeBlockToFunctionBody(cb) {
+  const setup = cb.body.map(transform$1);
+  if (!isNode$3(cb.render)) {
+    fail$2("A TSRX statement container is missing its rendered output node", cb);
+  }
+  const renderExpr = renderNodeToExpression(cb.render);
+  return blockStatement([...setup, returnStatement(renderExpr, cb)], cb);
+}
+
+// ---------------------------------------------------------------------------
+// @if — Show / Switch+Match
+// ---------------------------------------------------------------------------
+
+function ifToJsx(node) {
+  const branches = [];
+  let current = node;
+  let elseBlock = null;
+  for (;;) {
+    branches.push({
+      test: transform$1(current.test),
+      block: current.consequent,
+      src: current
+    });
+    const alternate = current.alternate;
+    if (alternate && (alternate.type === "IfStatement" || alternate.type === "JSXIfExpression")) {
+      current = alternate;
+    } else {
+      elseBlock = alternate;
+      break;
+    }
+  }
+
+  const elseExpr = elseBlock ? blockToExpression(elseBlock, "@else") : null;
+
+  if (branches.length === 1) {
+    const branch = branches[0];
+    const branchExpr = blockToExpression(branch.block, "@if");
+    const attributes = [jsxAttr("when", branch.test, branch.src)];
+    if (elseExpr) attributes.push(jsxAttr("fallback", elseExpr, elseBlock));
+    return jsxElement("Show", attributes, branchExpr ? [asChild(branchExpr)] : [], node);
+  }
+
+  const matches = branches.map((branch) => {
+    const branchExpr = blockToExpression(branch.block, "@if");
+    return jsxElement(
+      "Match",
+      [jsxAttr("when", branch.test, branch.src)],
+      branchExpr ? [asChild(branchExpr)] : [],
+      branch.src
+    );
+  });
+  const attributes = elseExpr ? [jsxAttr("fallback", elseExpr, elseBlock)] : [];
+  return jsxElement("Switch", attributes, matches, node);
+}
+
+// ---------------------------------------------------------------------------
+// @for — For
+// ---------------------------------------------------------------------------
+
+function forToJsx(node) {
+  if (node.statementType !== "ForOfStatement") {
+    fail$2(
+      "@for must iterate with for...of; for...in and classic for loops are not TSRX template constructs",
+      node
+    );
+  }
+  if (node.await) {
+    fail$2("`for await` is not supported inside Solid TSRX templates", node);
+  }
+
+  const left = node.left;
+  const pattern =
+  left.type === "VariableDeclaration" ? left.declarations[0].id : left;
+  const each = transform$1(node.right);
+  const index = isNode$3(node.index) ? node.index : null;
+  const key = isNode$3(node.key) ? node.key : null;
+  const usesIndexOnlyMode = index !== null && key === null;
+  const itemIsAccessor = key !== null || usesIndexOnlyMode;
+
+  const parts = blockToParts(toBlockBody(node.body), "@for");
+  const renderExpr = rendersToExpression(parts.renders, node.body);
+  if (!renderExpr) fail$2("A TSRX @for body must end with rendered output", node);
+
+  const callbackBody =
+  parts.setup.length > 0 ?
+  blockStatement(
+    [...parts.setup, returnStatement(renderExpr, node.body)],
+    node.body
+  ) :
+  renderExpr;
+
+  // RC `For` callback shape:
+  // - default keyed mode: raw item, accessor index (there is no TSRX index)
+  // - keyed={false}: accessor item, raw index
+  // - custom key: accessor item, accessor index
+  if (itemIsAccessor && pattern.type === "Identifier")
+  rewriteReadsToCalls(callbackBody, pattern.name);
+  if (key && index) rewriteReadsToCalls(callbackBody, index.name);
+
+  const callbackPattern =
+  itemIsAccessor && pattern.type !== "Identifier" ? accessorLazyPattern(pattern) : pattern;
+  const params = [callbackPattern];
+  if (index) params.push(index);
+
+  const attributes = [jsxAttr("each", each, node.right)];
+  if (key) {
+    attributes.push(jsxAttr("keyed", arrow([eagerPattern(pattern)], transform$1(key), key), key));
+  } else if (usesIndexOnlyMode) {
+    attributes.push(
+      jsxAttr("keyed", withLoc$2({ type: "Literal", value: false, raw: "false" }, index), index)
+    );
+  }
+  if (isNode$3(node.empty)) {
+    const emptyExpr = blockToExpression(node.empty, "@empty");
+    if (emptyExpr) attributes.push(jsxAttr("fallback", emptyExpr, node.empty));
+  }
+
+  return jsxElement(
+    "For",
+    attributes,
+    [jsxContainer(arrow(params, callbackBody, node), node)],
+    node
+  );
+}
+
+// ---------------------------------------------------------------------------
+// @switch — Switch / Match
+// ---------------------------------------------------------------------------
+
+function switchToJsx(node) {
+  const discriminant = transform$1(node.discriminant);
+  const matches = [];
+  let fallbackExpr = null;
+  let fallbackSrc = null;
+
+  for (const switchCase of node.cases) {
+    const consequent = switchCase.consequent;
+    const entries =
+    consequent.length === 1 && consequent[0].type === "BlockStatement" ?
+    consequent[0].body :
+    consequent;
+    const parts = blockToParts(entries, switchCase.test == null ? "@default" : "@case");
+    const renderExpr = rendersToExpression(parts.renders, switchCase);
+    const caseExpr =
+    parts.setup.length > 0 ?
+    renderExpr ?
+    iife([...parts.setup, returnStatement(renderExpr, switchCase)], switchCase) :
+    fail$2(
+      "A TSRX @case block with setup statements must end with rendered output",
+      switchCase
+    ) :
+    renderExpr;
+
+    if (switchCase.test == null) {
+      fallbackExpr = caseExpr;
+      fallbackSrc = switchCase;
+    } else {
+      const when = strictEquals(
+        cloneNode$1(discriminant),
+        transform$1(switchCase.test),
+        switchCase
+      );
+      matches.push(
+        jsxElement(
+          "Match",
+          [jsxAttr("when", when, switchCase)],
+          caseExpr ? [asChild(caseExpr)] : [],
+          switchCase
+        )
+      );
+    }
+  }
+
+  const attributes = fallbackExpr ? [jsxAttr("fallback", fallbackExpr, fallbackSrc)] : [];
+  return jsxElement("Switch", attributes, matches, node);
+}
+
+// ---------------------------------------------------------------------------
+// @try / @pending / @catch — Errored / Loading
+// ---------------------------------------------------------------------------
+
+function tryToJsx(node) {
+  if (isNode$3(node.finalizer)) {
+    fail$2("@finally is not part of the TSRX template grammar", node.finalizer);
+  }
+
+  const contentExpr = blockToExpression(node.block, "@try");
+  if (!contentExpr) fail$2("A TSRX @try block must end with rendered output", node);
+
+  let result = contentExpr;
+
+  if (isNode$3(node.pending)) {
+    const pendingExpr = blockToExpression(node.pending, "@pending");
+    const attributes = pendingExpr ? [jsxAttr("fallback", pendingExpr, node.pending)] : [];
+    result = jsxElement("Loading", attributes, [asChild(result)], node);
+  }
+
+  if (isNode$3(node.handler)) {
+    const handler = node.handler;
+    const param = isNode$3(handler.param) ? handler.param : null;
+    if (
+    param &&
+    param.type !== "Identifier" &&
+    param.type !== "ObjectPattern" &&
+    param.type !== "ArrayPattern")
+    {
+      fail$2(
+        "The @catch error binding must be an identifier, object pattern, or array pattern",
+        param
+      );
+    }
+    const resetParam = isNode$3(handler.resetParam) ? handler.resetParam : null;
+    const errorName = param ? param.name : "_e";
+
+    const handlerExpr = blockToExpression(handler.body, "@catch");
+    if (!handlerExpr) fail$2("A TSRX @catch block must end with rendered output", handler);
+    // RC `Errored` passes an `ErrorAccessor`: reads of the binding become calls.
+    if (param) rewriteReadsToCalls(handlerExpr, errorName);
+
+    const params = [
+    param && param.type !== "Identifier" ? accessorLazyPattern(param) : ident$1(errorName, param)];
+
+    if (resetParam)
+    params.push(ident$1(resetParam.name, resetParam));
+
+    result = jsxElement(
+      "Errored",
+      [jsxAttr("fallback", arrow(params, handlerExpr, handler), handler)],
+      [asChild(result)],
+      node
+    );
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Lazy-engine adaptation: intrinsic element names
+// ---------------------------------------------------------------------------
+
+/**
+ * Older lazy-transform paths rewrote *any* JSX name matching a lazy binding —
+ * including lowercase intrinsic tags (`<address>` with a lazy `address` in
+ * scope became `<__lazy0.address>`), which hijacked the element into a
+ * component. Per JSX semantics a single lowercase identifier tag is always
+ * intrinsic, so such rewrites are unambiguously wrong. Keep this repair for
+ * compatibility with trees produced by those paths; the local engine does not
+ * produce the invalid rewrite.
+ */
+function restoreIntrinsicJsxNames(root) {
+  visit(root);
+
+  function restore(owner) {
+    const name = owner.name;
+    if (!name || name.type !== "JSXMemberExpression") return;
+    const object = name.object;
+    const property = name.property;
+    if (
+    object.type === "JSXIdentifier" &&
+    /^__lazy\d+$/.test(object.name) &&
+    property.type === "JSXIdentifier" &&
+    /^[a-z]/.test(property.name))
+    {
+      owner.name = jsxIdent(property.name, name);
+    }
+  }
+
+  function visit(node) {
+    if (node.type === "JSXOpeningElement" || node.type === "JSXClosingElement") restore(node);
+    for (const key of Object.keys(node)) {
+      if (SKIP_KEYS$2.has(key)) continue;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value) if (isNode$3(item)) visit(item);
+      } else if (isNode$3(value)) {
+        visit(value);
+      }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Scope-aware read → call rewriting (accessor adaptations)
+// ---------------------------------------------------------------------------
+
+/** Keys whose contents are TS type positions — never value references. */
+const TYPE_KEYS$1 = new Set([
+"typeAnnotation",
+"typeParameters",
+"typeArguments",
+"superTypeArguments",
+"returnType"]
+);
+
+function patternNames$1(pattern, into) {
+  switch (pattern.type) {
+    case "Identifier":
+      into.add(pattern.name);
+      break;
+    case "ObjectPattern":
+      for (const prop of pattern.properties) {
+        if (prop.type === "RestElement") patternNames$1(prop.argument, into);else
+        patternNames$1(prop.value, into);
+      }
+      break;
+    case "ArrayPattern":
+      for (const el of pattern.elements) {
+        if (el) patternNames$1(el, into);
+      }
+      break;
+    case "AssignmentPattern":
+      patternNames$1(pattern.left, into);
+      break;
+    case "RestElement":
+      patternNames$1(pattern.argument, into);
+      break;
+  }
+}
+
+function statementsShadow(statements, name) {
+  const names = new Set();
+  for (const stmt of statements) {
+    if (stmt.type === "VariableDeclaration") {
+      for (const decl of stmt.declarations) patternNames$1(decl.id, names);
+    } else if (
+    (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") &&
+    isNode$3(stmt.id))
+    {
+      names.add(stmt.id.name);
+    }
+  }
+  return names.has(name);
+}
+
+/**
+ * Rewrite value reads of `name` within `root` (a plain, already-desugared
+ * subtree) to zero-argument calls, respecting shadowing by function params,
+ * block declarations, and catch clauses. Write targets are left untouched.
+ */
+function rewriteReadsToCalls(root, name) {
+  visit(root);
+
+  function shouldReplace(value) {
+    return isNode$3(value) && value.type === "Identifier" && value.name === name;
+  }
+
+  function replaceIn(container, key) {
+    const value = container[key];
+    container[key] = callOn(value, value);
+  }
+
+  function visit(node) {
+    if (FUNCTION_TYPES$1.has(node.type)) {
+      const bound = new Set();
+      for (const param of node.params) patternNames$1(param, bound);
+      if (bound.has(name)) return;
+      if (isNode$3(node.body)) visit(node.body);
+      return;
+    }
+    if (node.type === "BlockStatement" || node.type === "Program") {
+      if (statementsShadow(node.body, name)) return;
+    }
+    if (node.type === "CatchClause") {
+      const bound = new Set();
+      if (isNode$3(node.param)) patternNames$1(node.param, bound);
+      if (bound.has(name)) return;
+    }
+    if (node.type === "MetaProperty") return;
+
+    for (const key of Object.keys(node)) {
+      if (SKIP_KEYS$2.has(key) || TYPE_KEYS$1.has(key)) continue;
+      // Labels, binding sites, and non-computed accesses are not value reads.
+      if (key === "property" && node.type === "MemberExpression" && !node.computed) continue;
+      if (key === "property" && node.type === "JSXMemberExpression") continue;
+      if (key === "name" && (node.type === "JSXAttribute" || node.type === "JSXNamespacedName"))
+      continue;
+      if (key === "key" && node.type === "Property" && !node.computed) continue;
+      if (key === "id" && (node.type === "VariableDeclarator" || FUNCTION_TYPES$1.has(node.type)))
+      continue;
+      if (key === "label") continue;
+      if (key === "left" && node.type === "AssignmentExpression") {
+        // Writes to the accessor binding are invalid anyway; skip identifier
+        // targets but still walk member-expression targets.
+        if (shouldReplace(node.left)) continue;
+      }
+      if (key === "argument" && node.type === "UpdateExpression" && shouldReplace(node.argument))
+      continue;
+      if (
+      (key === "imported" || key === "local" || key === "exported") &&
+      /Specifier$/.test(node.type))
+
+      continue;
+
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+          const item = value[i];
+          if (shouldReplace(item)) replaceIn(value, i);else
+          if (isNode$3(item)) visit(item);
+        }
+      } else if (shouldReplace(value)) {
+        // Object-pattern shorthand shares the key/value node: split them.
+        if (node.type === "Property" && node.shorthand && key === "value") {
+          node.shorthand = false;
+          node.key = ident$1(name, value);
+        }
+        replaceIn(node, key);
+      } else if (isNode$3(value)) {
+        visit(value);
+      }
+    }
+  }
+}
+
+/**
+ * ESTree (acorn / typescript-eslint shaped, as produced by `@tsrx/core`) to
+ * Babel AST conversion.
+ *
+ * Purely mechanical: no TSRX node may reach this pass (the desugarer lowers
+ * them all first), and unknown shapes fail closed rather than producing a
+ * silently wrong tree. Location info (`start`/`end`/`loc`) is preserved for
+ * sourcemaps. Comments are not attached in v1 (documented limitation).
+ */
+
+
+
+
+/** ESTree/TSRX bookkeeping keys with no Babel equivalent. */
+const STRIP_KEYS = new Set([
+"type",
+"start",
+"end",
+"loc",
+"range",
+"metadata",
+"leadingComments",
+"trailingComments",
+"innerComments",
+"alternateKeyword",
+"emptyKeyword",
+"isDynamic",
+"statementType",
+"resetParam",
+"lazy",
+"directive"]
+);
+
+function isNode$2(value) {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof value.type === "string");
+
+}
+
+function fail$1(message, node) {
+  const start = node.loc?.start;
+  throw new SyntaxError(start ? `${message} (${start.line}:${start.column})` : message);
+}
+
+function copyLoc(from, to) {
+  if (from.start !== undefined) to.start = from.start;
+  if (from.end !== undefined) to.end = from.end;
+  if (from.loc !== undefined) to.loc = from.loc;
+}
+
+function convertValue(value) {
+  if (Array.isArray(value)) return value.map(convertValue);
+  if (isNode$2(value)) return convertNode(value);
+  return value;
+}
+
+/** Shallow-map every kept key, renaming typescript-eslint's `typeArguments`
+ * to Babel 7's `typeParameters` along the way. */
+function convertGeneric(node, overrideType) {
+  const out = { type: overrideType ?? node.type };
+  copyLoc(node, out);
+  for (const key of Object.keys(node)) {
+    if (STRIP_KEYS.has(key)) continue;
+    const outKey =
+    key === "typeArguments" && node.typeParameters === undefined ? "typeParameters" : key;
+    out[outKey] = convertValue(node[key]);
+  }
+  return out;
+}
+
+function convertLiteral(node) {
+  const out = {};
+  copyLoc(node, out);
+  const regex = node.regex;
+  if (regex) {
+    out.type = "RegExpLiteral";
+    out.pattern = regex.pattern;
+    out.flags = regex.flags;
+    return out;
+  }
+  if (node.bigint !== undefined && node.bigint !== null) {
+    out.type = "BigIntLiteral";
+    out.value = node.bigint;
+    return out;
+  }
+  const value = node.value;
+  if (value === null) {
+    out.type = "NullLiteral";
+    return out;
+  }
+  switch (typeof value) {
+    case "string":
+      out.type = "StringLiteral";
+      break;
+    case "number":
+      out.type = "NumericLiteral";
+      break;
+    case "boolean":
+      out.type = "BooleanLiteral";
+      break;
+    default:
+      return fail$1(`Unsupported literal value type: ${typeof value}`, node);
+  }
+  out.value = value;
+  if (typeof node.raw === "string") out.extra = { raw: node.raw, rawValue: value };
+  return out;
+}
+
+function extractDirectives(body) {
+  const directives = [];
+  let i = 0;
+  while (i < body.length) {
+    const stmt = body[i];
+    if (stmt.type !== "ExpressionStatement" || typeof stmt.directive !== "string") break;
+    const expr = stmt.expression;
+    const literal = {
+      type: "DirectiveLiteral",
+      value: expr.value
+    };
+    copyLoc(expr, literal);
+    if (typeof expr.raw === "string") literal.extra = { raw: expr.raw, rawValue: expr.value };
+    const directive = { type: "Directive", value: literal };
+    copyLoc(stmt, directive);
+    directives.push(directive);
+    i++;
+  }
+  return { directives, rest: body.slice(i) };
+}
+
+function convertFunctionParts(fn, out) {
+  out.params = convertValue(fn.params);
+  out.body = convertValue(fn.body);
+  out.generator = !!fn.generator;
+  out.async = !!fn.async;
+  if (fn.returnType !== undefined) out.returnType = convertValue(fn.returnType);
+  if (fn.typeParameters !== undefined) out.typeParameters = convertValue(fn.typeParameters);
+}
+
+/** Convert an optional chain, dropping the ESTree `ChainExpression` wrapper
+ * and switching member/call links to Babel's `Optional*` node types. */
+function convertChainLink(node) {
+  switch (node.type) {
+    case "MemberExpression":{
+        const out = {
+          type: "OptionalMemberExpression",
+          object: convertChainLink(node.object),
+          property: convertValue(node.property),
+          computed: !!node.computed,
+          optional: !!node.optional
+        };
+        copyLoc(node, out);
+        return out;
+      }
+    case "CallExpression":{
+        const out = {
+          type: "OptionalCallExpression",
+          callee: convertChainLink(node.callee),
+          arguments: convertValue(node.arguments),
+          optional: !!node.optional
+        };
+        copyLoc(node, out);
+        if (node.typeParameters !== undefined || node.typeArguments !== undefined) {
+          out.typeParameters = convertValue(node.typeParameters ?? node.typeArguments);
+        }
+        return out;
+      }
+    case "TSNonNullExpression":{
+        const out = {
+          type: "TSNonNullExpression",
+          expression: convertChainLink(node.expression)
+        };
+        copyLoc(node, out);
+        return out;
+      }
+    default:
+      return convertNode(node);
+  }
+}
+
+function convertNode(node) {
+  switch (node.type) {
+    case "Program":{
+        const { directives, rest } = extractDirectives(node.body);
+        const out = {
+          type: "Program",
+          sourceType: node.sourceType ?? "module",
+          interpreter: null,
+          body: rest.map(convertNode),
+          directives
+        };
+        copyLoc(node, out);
+        return out;
+      }
+
+    case "BlockStatement":{
+        const { directives, rest } = extractDirectives(node.body);
+        const out = {
+          type: "BlockStatement",
+          body: rest.map(convertNode),
+          directives
+        };
+        copyLoc(node, out);
+        return out;
+      }
+
+    case "Literal":
+      return convertLiteral(node);
+
+    case "Property":{
+        const kind = node.kind;
+        if (kind === "get" || kind === "set" || node.method) {
+          const fn = node.value;
+          const out = {
+            type: "ObjectMethod",
+            kind: node.method ? "method" : kind,
+            key: convertValue(node.key),
+            computed: !!node.computed
+          };
+          copyLoc(node, out);
+          convertFunctionParts(fn, out);
+          return out;
+        }
+        const out = {
+          type: "ObjectProperty",
+          key: convertValue(node.key),
+          value: convertValue(node.value),
+          computed: !!node.computed,
+          shorthand: !!node.shorthand
+        };
+        copyLoc(node, out);
+        return out;
+      }
+
+    case "MethodDefinition":{
+        const fn = node.value;
+        const isPrivate = node.key.type === "PrivateIdentifier";
+        const out = {
+          type: isPrivate ? "ClassPrivateMethod" : "ClassMethod",
+          kind: node.kind,
+          key: convertValue(node.key),
+          computed: !!node.computed,
+          static: !!node.static
+        };
+        copyLoc(node, out);
+        convertFunctionParts(fn, out);
+        if (node.accessibility !== undefined) out.accessibility = node.accessibility;
+        if (node.override !== undefined) out.override = node.override;
+        if (node.optional !== undefined) out.optional = node.optional;
+        return out;
+      }
+
+    case "PropertyDefinition":{
+        const isPrivate = node.key.type === "PrivateIdentifier";
+        const out = {
+          type: isPrivate ? "ClassPrivateProperty" : "ClassProperty",
+          key: convertValue(node.key),
+          value: node.value == null ? null : convertValue(node.value),
+          computed: !!node.computed,
+          static: !!node.static
+        };
+        copyLoc(node, out);
+        for (const key of [
+        "typeAnnotation",
+        "declare",
+        "readonly",
+        "accessibility",
+        "optional",
+        "definite",
+        "override"])
+        {
+          if (node[key] !== undefined) out[key] = convertValue(node[key]);
+        }
+        return out;
+      }
+
+    case "PrivateIdentifier":{
+        const id = { type: "Identifier", name: node.name };
+        copyLoc(node, id);
+        const out = { type: "PrivateName", id };
+        copyLoc(node, out);
+        return out;
+      }
+
+    case "ChainExpression":
+      return convertChainLink(node.expression);
+
+    case "ImportExpression":{
+        const importCallee = { type: "Import" };
+        copyLoc(node, importCallee);
+        const args = [convertValue(node.source)];
+        if (node.options != null) args.push(convertValue(node.options));
+        const out = {
+          type: "CallExpression",
+          callee: importCallee,
+          arguments: args
+        };
+        copyLoc(node, out);
+        return out;
+      }
+
+    case "JSXText":{
+        const out = { type: "JSXText", value: node.value };
+        copyLoc(node, out);
+        if (typeof node.raw === "string") out.extra = { raw: node.raw, rawValue: node.value };
+        return out;
+      }
+
+    case "TSTypeParameter":{
+        const out = convertGeneric(node);
+        if (isNode$2(out.name)) out.name = out.name.name;
+        return out;
+      }
+
+    case "TSInterfaceHeritage":
+      return convertGeneric(node, "TSExpressionWithTypeArguments");
+
+    case "TSAbstractMethodDefinition":
+    case "TSAbstractPropertyDefinition":
+    case "TSParameterProperty":
+      return fail$1(`Unsupported TypeScript construct in TSRX source: ${node.type}`, node);
+
+    case "JSXCodeBlock":
+    case "JSXIfExpression":
+    case "JSXForExpression":
+    case "JSXSwitchExpression":
+    case "JSXTryExpression":
+    case "JSXStyleElement":
+      return fail$1(
+        `TSRX node ${node.type} survived desugaring; this is a bug in the frontend`,
+        node
+      );
+
+    default:
+      return convertGeneric(node);
+  }
+}
+
+function toBabelFile(program) {
+  const file = {
+    type: "File",
+    program: convertNode(program),
+    comments: [],
+    tokens: []
+  };
+  copyLoc(program, file);
+  return file;
+}
+
+/**
+ * Solid's TSRX lazy-destructuring transform.
+ *
+ * This is intentionally local to the Babel frontend. `@tsrx/core` still owns
+ * parsing and semantic analysis, but its framework-agnostic lazy transform
+ * cannot express Solid's reactive object-rest view or JavaScript-correct lazy
+ * defaults and updates.
+ *
+ * The scope and pattern traversal is adapted from @tsrx/core 0.1.61's
+ * MIT-licensed `src/transform/lazy.js`.
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const FUNCTION_TYPES = new Set([
+"FunctionDeclaration",
+"FunctionExpression",
+"ArrowFunctionExpression"]
+);
+
+const TYPE_KEYS = new Set([
+"typeAnnotation",
+"typeParameters",
+"typeArguments",
+"superTypeArguments",
+"returnType",
+"implements"]
+);
+
+const SKIP_KEYS$1 = new Set([
+"type",
+"loc",
+"start",
+"end",
+"range",
+"metadata",
+"leadingComments",
+"trailingComments",
+"innerComments"]
+);
+
+function isNode$1(value) {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof value.type === "string");
+
+}
+
+function metadata(node) {
+  return node.metadata ??= {};
+}
+
+function withLoc$1(node, source) {
+  if (source) {
+    if (source.start !== undefined) node.start = source.start;
+    if (source.end !== undefined) node.end = source.end;
+    if (source.loc !== undefined) node.loc = source.loc;
+  }
+  return node;
+}
+
+function cloneNode(value) {
+  if (Array.isArray(value)) return value.map(cloneNode);
+  if (typeof value === "object" && value !== null) {
+    const clone = {};
+    for (const key of Object.keys(value)) {
+      clone[key] = cloneNode(value[key]);
+    }
+    return clone;
+  }
+  return value;
+}
+
+function ident(name, source) {
+  return withLoc$1({ type: "Identifier", name }, source);
+}
+
+function literal(value, source) {
+  return withLoc$1({ type: "Literal", value, raw: JSON.stringify(value) }, source);
+}
+
+function undefinedExpression(source) {
+  return withLoc$1(
+    { type: "UnaryExpression", operator: "void", prefix: true, argument: literal(0, source) },
+    source
+  );
+}
+
+function member(object, property, computed, source) {
+  return withLoc$1({ type: "MemberExpression", object, property, computed, optional: false }, source);
+}
+
+function call(callee, args, source) {
+  return withLoc$1({ type: "CallExpression", callee, arguments: args, optional: false }, source);
+}
+
+function assignment(operator, left, right, source) {
+  return withLoc$1({ type: "AssignmentExpression", operator, left, right }, source);
+}
+
+function sequence(expressions, source) {
+  return withLoc$1({ type: "SequenceExpression", expressions }, source);
+}
+
+function conditional(test, consequent, alternate, source) {
+  return withLoc$1({ type: "ConditionalExpression", test, consequent, alternate }, source);
+}
+
+function binary(operator, left, right, source) {
+  return withLoc$1({ type: "BinaryExpression", operator, left, right }, source);
+}
+
+function logical(operator, left, right, source) {
+  return withLoc$1({ type: "LogicalExpression", operator, left, right }, source);
+}
+
+function variableDeclaration(kind, names, init) {
+  return {
+    type: "VariableDeclaration",
+    kind,
+    declarations: names.map((name, index) => ({
+      type: "VariableDeclarator",
+      id: ident(name),
+      init: index === 0 && init ? init : null
+    }))
+  };
+}
+
+function fail(message, node) {
+  const start = node?.loc?.start;
+  throw new SyntaxError(start ? `${message} (${start.line}:${start.column})` : message);
+}
+
+const AUTHORED_LAZY_UNSUPPORTED =
+"Solid's TSRX frontend does not support authored lazy destructuring; keep property and accessor reads explicit";
+
+/**
+ * Reject parser-authored `&{}` / `&[]` before TSRX controls synthesize the
+ * deferred patterns Solid needs for accessor-backed `@for` and `@catch`
+ * callbacks.
+ */
+function rejectAuthoredLazyDestructuring(root) {
+  const visit = (value) => {
+    if (Array.isArray(value)) {
+      for (const child of value) visit(child);
+      return;
+    }
+    if (!isNode$1(value)) return;
+    if ((value.type === "ObjectPattern" || value.type === "ArrayPattern") && value.lazy === true) {
+      fail(AUTHORED_LAZY_UNSUPPORTED, value);
+    }
+    for (const key of Object.keys(value)) {
+      if (!SKIP_KEYS$1.has(key)) visit(value[key]);
+    }
+  };
+  visit(root);
+}
+
+class LazyState {
+  names = new Set();
+  next = new Map();
+  programTemps = [];
+  tempScopes = [this.programTemps];
+
+
+  usesArrayRest = false;
+  topLevelGlobalThisBinding = false;
+
+  constructor(root) {
+    this.collectNames(root);
+    this.topLevelGlobalThisBinding = programBindsName(root, "globalThis");
+  }
+
+  collectNames(value) {
+    if (Array.isArray(value)) {
+      for (const child of value) this.collectNames(child);
+      return;
+    }
+    if (!isNode$1(value)) return;
+    if (value.type === "Identifier" || value.type === "JSXIdentifier") {
+      this.names.add(value.name);
+    }
+    for (const key of Object.keys(value)) {
+      if (!SKIP_KEYS$1.has(key)) this.collectNames(value[key]);
+    }
+  }
+
+  name(prefix) {
+    let index = this.next.get(prefix) ?? 0;
+    let name;
+    do name = `${prefix}${index++}`; while (
+    this.names.has(name));
+    this.next.set(prefix, index);
+    this.names.add(name);
+    return name;
+  }
+
+  temp() {
+    const name = this.name("__lazyValue");
+    this.tempScopes[this.tempScopes.length - 1].push(name);
+    return name;
+  }
+
+  pushFunctionTemps() {
+    this.tempScopes.push([]);
+  }
+
+  popFunctionTemps() {
+    if (this.tempScopes.length === 1) {
+      return fail("Internal TSRX lazy-transform temporary-scope imbalance");
+    }
+    return this.tempScopes.pop();
+  }
+
+  defaultRead(
+  raw,
+  fallback,
+  bindings,
+  selfName,
+  source)
+  {
+    const tempName = this.temp();
+    const temp = () => ident(tempName, source);
+    const fallbackBindings = new Map(bindings);
+    fallbackBindings.delete(selfName);
+    return sequence(
+      [
+      assignment("=", temp(), raw, source),
+      conditional(
+        binary("===", temp(), undefinedExpression(source), source),
+        transform(cloneNode(fallback), fallbackBindings, this),
+        temp(),
+        source
+      )],
+
+      source
+    );
+  }
+
+  omitIdentifier() {
+    this.omitName ??= this.name("__lazyOmit");
+    return ident(this.omitName);
+  }
+
+  arrayIdentifier(node) {
+    if (this.topLevelGlobalThisBinding) {
+      fail(
+        "TSRX lazy array rest cannot safely access the intrinsic Array because this module binds `globalThis`; rename that top-level binding",
+        node
+      );
+    }
+    this.usesArrayRest = true;
+    this.arrayName ??= this.name("__lazyArray");
+    return ident(this.arrayName, node);
+  }
+
+  finalize(program) {
+    if (program.type !== "Program") {
+      if (this.omitName || this.usesArrayRest || this.programTemps.length) {
+        return fail("The TSRX lazy transform requires a Program root", program);
+      }
+      return program;
+    }
+
+    const generated = [];
+    if (this.arrayName) {
+      generated.push(
+        variableDeclaration(
+          "const",
+          [this.arrayName],
+          member(ident("globalThis"), ident("Array"), false)
+        )
+      );
+    }
+    if (this.programTemps.length) generated.push(variableDeclaration("let", this.programTemps));
+
+    const body = program.body;
+    let directiveEnd = 0;
+    while (
+    directiveEnd < body.length &&
+    body[directiveEnd].type === "ExpressionStatement" &&
+    typeof body[directiveEnd].directive === "string")
+    {
+      directiveEnd++;
+    }
+    let importEnd = directiveEnd;
+    while (importEnd < body.length && body[importEnd].type === "ImportDeclaration") importEnd++;
+
+    const additions = [];
+    if (this.omitName) {
+      additions.push({
+        type: "ImportDeclaration",
+        specifiers: [
+        {
+          type: "ImportSpecifier",
+          imported: ident("omit"),
+          local: ident(this.omitName)
+        }],
+
+        source: literal("solid-js")
+      });
+    }
+    additions.push(...generated);
+    if (additions.length) {
+      program.body = [...body.slice(0, importEnd), ...additions, ...body.slice(importEnd)];
+    }
+    return program;
+  }
+}
+
+function programBindsName(root, name) {
+  if (root.type !== "Program") return false;
+  for (const statement of root.body) {
+    const declaration =
+    (statement.type === "ExportNamedDeclaration" ||
+    statement.type === "ExportDefaultDeclaration") &&
+    isNode$1(statement.declaration) ?
+    statement.declaration :
+    statement;
+    if (declaration.type === "VariableDeclaration") {
+      for (const item of declaration.declarations) {
+        const names = new Set();
+        patternNames(item.id, names);
+        if (names.has(name)) return true;
+      }
+    } else if (
+    (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") &&
+    isNode$1(declaration.id) &&
+    declaration.id.name === name)
+    {
+      return true;
+    } else if (statement.type === "ImportDeclaration") {
+      for (const specifier of statement.specifiers) {
+        if (isNode$1(specifier.local) && specifier.local.name === name) return true;
+      }
+    }
+  }
+  return false;
+}
+
+function assertWritable(binding, node) {
+  if (binding.complexDefault) {
+    fail(
+      "A TSRX lazy binding nested beneath an ancestor default is read-only; assign to the source object explicitly",
+      node
+    );
+  }
+}
+
+function staticPropertyName(node) {
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "Literal") return String(node.value);
+  return null;
+}
+
+function typePropertyKeys(typeAnnotation) {
+  const keys = new Map();
+  const type = typeAnnotation?.typeAnnotation;
+  if (type?.type !== "TSTypeLiteral") return keys;
+  for (const item of type.members ?? []) {
+    if (item.type !== "TSPropertySignature" || !isNode$1(item.key)) continue;
+    const name = staticPropertyName(item.key);
+    if (name !== null && !keys.has(name)) keys.set(name, item.key);
+  }
+  return keys;
+}
+
+function patternRange(pattern) {
+  if (pattern.start === undefined || pattern.end === undefined || pattern.loc === undefined) {
+    return null;
+  }
+  const annotation = pattern.typeAnnotation;
+  return {
+    type: "Identifier",
+    start: pattern.start,
+    end: annotation?.start ?? pattern.end,
+    loc: {
+      start: pattern.loc.start,
+      end:
+      annotation?.loc?.start ??
+      pattern.loc.end
+    }
+  };
+}
+
+function generatedPatternIdentifier(pattern, name, isTop) {
+  const range = patternRange(pattern);
+  const id = ident(name, range);
+  if (range && range.start !== undefined && range.end !== undefined) {
+    metadata(id).source_length = range.end - range.start;
+  }
+  if (isTop && isNode$1(pattern.typeAnnotation)) id.typeAnnotation = pattern.typeAnnotation;
+  if (isTop) setParamTypeMappings(id, pattern);
+  return id;
+}
+
+function setParamTypeMappings(id, pattern) {
+  if (pattern.type !== "ObjectPattern") return;
+  const keys = typePropertyKeys(id.typeAnnotation);
+  if (!keys.size) return;
+  const mappings = [];
+  for (const property of pattern.properties) {
+    if (property.type === "RestElement" || property.computed) continue;
+    const value = property.value;
+    const actual = value.type === "AssignmentPattern" ? value.left : value;
+    if (actual.type !== "Identifier" || actual.start === undefined) continue;
+    const name = staticPropertyName(property.key);
+    const generated = name === null ? undefined : keys.get(name);
+    if (generated?.start !== undefined) {
+      metadata(generated).disable_verification = true;
+      mappings.push({ source: actual, generated });
+    }
+  }
+  if (mappings.length) metadata(id).lazy_param_binding_mappings = mappings;
+}
+
+function visitTopmostLazyPatterns(
+pattern,
+visit)
+{
+  if (!pattern) return;
+  if (pattern.type === "AssignmentPattern") {
+    visitTopmostLazyPatterns(pattern.left, visit);
+    return;
+  }
+  if (pattern.type === "RestElement") {
+    visitTopmostLazyPatterns(pattern.argument, visit);
+    return;
+  }
+  if (pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") return;
+  if (pattern.lazy) {
+    visit(pattern);
+    return;
+  }
+  if (pattern.type === "ObjectPattern") {
+    for (const property of pattern.properties) {
+      visitTopmostLazyPatterns(
+        property.type === "RestElement" ? property.argument : property.value,
+        visit
+      );
+    }
+  } else {
+    for (const element of pattern.elements) {
+      if (element) visitTopmostLazyPatterns(element, visit);
+    }
+  }
+}
+
+function preallocate(root, state) {
+  const assign = (pattern) => {
+    visitTopmostLazyPatterns(pattern, (lazy) => {
+      if (!metadata(lazy).lazy_id) metadata(lazy).lazy_id = state.name("__lazy");
+    });
+  };
+
+  const visit = (value) => {
+    if (Array.isArray(value)) {
+      let found = false;
+      for (const child of value) if (visit(child)) found = true;
+      return found;
+    }
+    if (!isNode$1(value)) return false;
+
+    const functionLike = FUNCTION_TYPES.has(value.type);
+    if (functionLike) {
+      for (const param of value.params) {
+        assign(param.type === "AssignmentPattern" ? param.left : param);
+      }
+    }
+    if (value.type === "VariableDeclarator") assign(value.id);
+    if (value.type === "CatchClause" && isNode$1(value.param)) assign(value.param);
+    if (
+    value.type === "ExpressionStatement" &&
+    isNode$1(value.expression) &&
+    value.expression.type === "AssignmentExpression" &&
+    value.expression.operator === "=")
+    {
+      assign(value.expression.left);
+    }
+
+    let found =
+    (value.type === "ObjectPattern" || value.type === "ArrayPattern") && value.lazy === true;
+    for (const key of Object.keys(value)) {
+      if (SKIP_KEYS$1.has(key)) continue;
+      if (visit(value[key])) found = true;
+    }
+    if (functionLike && found) metadata(value).has_lazy_descendants = true;
+    return found;
+  };
+  visit(root);
+}
+
+function transformedEmbedded(
+node,
+bindings,
+state,
+selfName)
+{
+  const effective = new Map(bindings);
+  effective.delete(selfName);
+  return transform(cloneNode(node), effective, state);
+}
+
+function rootAccess(sourceName, accessor) {
+  const source = (reference) => {
+    const identifier = ident(sourceName, reference);
+    return accessor ? call(identifier, [], reference) : identifier;
+  };
+  return {
+    raw: (reference) => source(reference),
+    value: (reference) => source(reference),
+    plain: true,
+    jsxCompatible: !accessor,
+    complexDefault: false
+  };
+}
+
+function propertyAccess(parent, key, computed, state) {
+  const property = (bindings, selfName, reference) =>
+  computed ?
+  transformedEmbedded(key, bindings, state, selfName) :
+  ident(key.name, reference);
+  return {
+    raw: (reference, bindings, selfName) =>
+    member(
+      parent.raw(reference, bindings, selfName),
+      property(bindings, selfName, reference),
+      computed,
+      reference
+    ),
+    value: (reference, bindings, selfName) =>
+    member(
+      parent.value(reference, bindings, selfName),
+      property(bindings, selfName, reference),
+      computed,
+      reference
+    ),
+    plain: parent.plain,
+    jsxCompatible: parent.jsxCompatible && !computed,
+    complexDefault: parent.complexDefault || parent.directDefault !== undefined
+  };
+}
+
+function defaultAccess(parent, fallback, state) {
+  return {
+    raw: parent.raw,
+    value: (reference, bindings, selfName) =>
+    state.defaultRead(
+      parent.value(reference, bindings, selfName),
+      fallback,
+      bindings,
+      selfName,
+      reference
+    ),
+    plain: false,
+    jsxCompatible: false,
+    directDefault: fallback,
+    complexDefault: parent.complexDefault || parent.directDefault !== undefined
+  };
+}
+
+function jsxNameFromMember(expression, source) {
+  if (expression.type === "Identifier") {
+    return withLoc$1({ type: "JSXIdentifier", name: expression.name }, source);
+  }
+  if (
+  expression.type === "MemberExpression" &&
+  !expression.computed &&
+  isNode$1(expression.property) &&
+  expression.property.type === "Identifier")
+  {
+    const object = jsxNameFromMember(expression.object, source);
+    if (object) {
+      return withLoc$1(
+        {
+          type: "JSXMemberExpression",
+          object,
+          property: withLoc$1(
+            { type: "JSXIdentifier", name: expression.property.name },
+            expression.property
+          )
+        },
+        source
+      );
+    }
+  }
+  return null;
+}
+
+function registerBinding(
+name,
+sourceName,
+access,
+bindings)
+{
+  bindings.set(name, {
+    sourceName,
+    read(reference, current) {
+      return access.value(reference, current, name);
+    },
+    target(reference, current) {
+      return access.raw(reference, current, name);
+    },
+    jsxName(reference, current) {
+      return access.jsxCompatible ?
+      jsxNameFromMember(access.raw(reference, current, name), reference) :
+      null;
+    },
+    directDefault: access.directDefault,
+    complexDefault: access.complexDefault
+  });
+}
+
+function collectBindingsAt(
+pattern,
+sourceName,
+access,
+bindings,
+state)
+{
+  if (pattern.type === "AssignmentPattern") {
+    collectBindingsAt(
+      pattern.left,
+      sourceName,
+      defaultAccess(access, pattern.right, state),
+      bindings,
+      state
+    );
+    return;
+  }
+  if (pattern.type === "Identifier") {
+    registerBinding(pattern.name, sourceName, access, bindings);
+    return;
+  }
+  if (pattern.type === "ObjectPattern") {
+    const properties = pattern.properties;
+    const sourceKeys = properties.
+    filter((property) => property.type !== "RestElement").
+    map((property) => {
+      const key = property.key;
+      return property.computed ? key : literal(staticPropertyName(key) ?? "", key);
+    });
+    for (const property of properties) {
+      if (property.type === "RestElement") {
+        const argument = property.argument;
+        if (argument.type !== "Identifier") {
+          fail("TSRX lazy object rest currently requires an identifier binding", argument);
+        }
+        const name = argument.name;
+        bindings.set(name, {
+          sourceName,
+          read(reference, current) {
+            const effective = new Map(current);
+            effective.delete(name);
+            return call(
+              state.omitIdentifier(),
+              [
+              access.value(reference, current, name),
+              ...sourceKeys.map((key) => transform(cloneNode(key), effective, state))],
+
+              reference
+            );
+          },
+          target() {
+            return null;
+          },
+          jsxName() {
+            return null;
+          },
+          complexDefault: access.complexDefault
+        });
+        continue;
+      }
+      const key = property.key;
+      const computed = !!property.computed || key.type !== "Identifier";
+      collectBindingsAt(
+        property.value,
+        sourceName,
+        propertyAccess(access, key, computed, state),
+        bindings,
+        state
+      );
+    }
+    return;
+  }
+  if (pattern.type === "ArrayPattern") {
+    const elements = pattern.elements;
+    for (let index = 0; index < elements.length; index++) {
+      const element = elements[index];
+      if (!element) continue;
+      if (element.type === "RestElement") {
+        const argument = element.argument;
+        if (argument.type !== "Identifier") {
+          fail("TSRX lazy array rest currently requires an identifier binding", argument);
+        }
+        const name = argument.name;
+        // Reserve and validate the intrinsic alias when the pattern is
+        // registered, even if the rest binding is never read. The native
+        // frontend plans helpers at binding time and must emit the same
+        // `globalThis` shadowing diagnostic.
+        state.arrayIdentifier(argument);
+        bindings.set(name, {
+          sourceName,
+          read(reference, current) {
+            const from = member(
+              state.arrayIdentifier(reference),
+              ident("from", reference),
+              false,
+              reference
+            );
+            const array = call(from, [access.value(reference, current, name)], reference);
+            return call(
+              member(array, ident("slice", reference), false, reference),
+              [literal(index, reference)],
+              reference
+            );
+          },
+          target() {
+            return null;
+          },
+          jsxName() {
+            return null;
+          },
+          complexDefault: access.complexDefault
+        });
+        continue;
+      }
+      collectBindingsAt(
+        element,
+        sourceName,
+        propertyAccess(access, literal(index, element), true, state),
+        bindings,
+        state
+      );
+    }
+  }
+}
+
+function collectBindings(
+pattern,
+sourceName,
+bindings,
+state)
+{
+  collectBindingsAt(
+    pattern,
+    sourceName,
+    rootAccess(sourceName, metadata(pattern).lazy_source_accessor === true),
+    bindings,
+    state
+  );
+}
+
+function collectBindingsFromStatements(
+statements,
+bindings,
+state)
+{
+  for (const statement of statements) {
+    const declaration =
+    (statement.type === "ExportNamedDeclaration" ||
+    statement.type === "ExportDefaultDeclaration") &&
+    isNode$1(statement.declaration) ?
+    statement.declaration :
+    statement;
+    if (declaration.type === "VariableDeclaration" && declaration.kind !== "var") {
+      for (const item of declaration.declarations) {
+        visitTopmostLazyPatterns(item.id, (lazy) => {
+          const sourceName = metadata(lazy).lazy_id;
+          if (sourceName) collectBindings(lazy, sourceName, bindings, state);
+        });
+      }
+    } else if (
+    statement.type === "ExpressionStatement" &&
+    isNode$1(statement.expression) &&
+    statement.expression.type === "AssignmentExpression" &&
+    statement.expression.operator === "=")
+    {
+      visitTopmostLazyPatterns(statement.expression.left, (lazy) => {
+        const sourceName = metadata(lazy).lazy_id;
+        if (sourceName) collectBindings(lazy, sourceName, bindings, state);
+      });
+    }
+  }
+}
+
+
+
+
+
+
+/**
+ * Collect function/program-scoped `var` declarations before rewriting any
+ * references in that scope. `var` crosses blocks, loops, switches, and catch
+ * bodies, but never crosses a nested function, class, or class static block.
+ */
+function collectVarScopeBindings(statements, state) {
+  const declared = new Set();
+  const lazy = new Map();
+
+  const visit = (value) => {
+    if (Array.isArray(value)) {
+      for (const child of value) visit(child);
+      return;
+    }
+    if (!isNode$1(value)) return;
+    if (
+    FUNCTION_TYPES.has(value.type) ||
+    value.type === "ClassDeclaration" ||
+    value.type === "ClassExpression" ||
+    value.type === "StaticBlock" ||
+    value.type === "ClassStaticBlock")
+    {
+      return;
+    }
+    if (value.type === "VariableDeclaration" && value.kind === "var") {
+      for (const declaration of value.declarations) {
+        patternNames(declaration.id, declared);
+        visitTopmostLazyPatterns(declaration.id, (pattern) => {
+          const sourceName = metadata(pattern).lazy_id;
+          if (sourceName) collectBindings(pattern, sourceName, lazy, state);
+        });
+      }
+    }
+    for (const key of Object.keys(value)) {
+      if (!SKIP_KEYS$1.has(key)) visit(value[key]);
+    }
+  };
+
+  visit(statements);
+  return { declared, lazy };
+}
+
+function replaceLazyInPattern(pattern, isTop = true) {
+  if (pattern.type === "AssignmentPattern") {
+    const left = replaceLazyInPattern(pattern.left, isTop);
+    return left === pattern.left ? pattern : { ...pattern, left };
+  }
+  if (pattern.type === "RestElement") {
+    const argument = replaceLazyInPattern(pattern.argument, false);
+    return argument === pattern.argument ? pattern : { ...pattern, argument };
+  }
+  if (pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") return pattern;
+  const sourceName = metadata(pattern).lazy_id;
+  if (pattern.lazy && sourceName) return generatedPatternIdentifier(pattern, sourceName, isTop);
+  if (pattern.type === "ObjectPattern") {
+    let changed = false;
+    const properties = pattern.properties.map((property) => {
+      const key = property.type === "RestElement" ? "argument" : "value";
+      const value = property[key];
+      const replacement = replaceLazyInPattern(value, false);
+      if (replacement === value) return property;
+      changed = true;
+      return { ...property, [key]: replacement };
+    });
+    return changed ? { ...pattern, properties } : pattern;
+  }
+  let changed = false;
+  const elements = pattern.elements.map((element) => {
+    if (!element) return element;
+    const replacement = replaceLazyInPattern(element, false);
+    if (replacement !== element) changed = true;
+    return replacement;
+  });
+  return changed ? { ...pattern, elements } : pattern;
+}
+
+function replaceLazyParams(params) {
+  return params.map((param) => replaceLazyInPattern(param));
+}
+
+function patternNames(pattern, names) {
+  switch (pattern.type) {
+    case "Identifier":
+      names.add(pattern.name);
+      return;
+    case "AssignmentPattern":
+      patternNames(pattern.left, names);
+      return;
+    case "RestElement":
+      patternNames(pattern.argument, names);
+      return;
+    case "ObjectPattern":
+      for (const property of pattern.properties) {
+        patternNames(
+          property.type === "RestElement" ? property.argument : property.value,
+          names
+        );
+      }
+      return;
+    case "ArrayPattern":
+      for (const element of pattern.elements) {
+        if (element) patternNames(element, names);
+      }
+  }
+}
+
+function collectShadowed(pattern, bindings, names) {
+  const all = new Set();
+  patternNames(pattern, all);
+  for (const name of all) if (bindings.has(name)) names.add(name);
+}
+
+function collectBlockShadowed(statements, bindings) {
+  const names = new Set();
+  for (const statement of statements) {
+    const declaration =
+    (statement.type === "ExportNamedDeclaration" ||
+    statement.type === "ExportDefaultDeclaration") &&
+    isNode$1(statement.declaration) ?
+    statement.declaration :
+    statement;
+    if (declaration.type === "VariableDeclaration" && declaration.kind !== "var") {
+      for (const item of declaration.declarations) {
+        collectShadowed(item.id, bindings, names);
+      }
+    } else if (
+    (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") &&
+    isNode$1(declaration.id) &&
+    bindings.has(declaration.id.name))
+    {
+      names.add(declaration.id.name);
+    } else if (statement.type === "ImportDeclaration") {
+      for (const specifier of statement.specifiers) {
+        if (isNode$1(specifier.local) && bindings.has(specifier.local.name)) {
+          names.add(specifier.local.name);
+        }
+      }
+    }
+  }
+  return names;
+}
+
+function without(bindings, names) {
+  const result = new Map(bindings);
+  for (const name of names) result.delete(name);
+  return result;
+}
+
+function transformValue(value, bindings, state) {
+  if (Array.isArray(value)) return value.map((item) => transformValue(item, bindings, state));
+  return isNode$1(value) ? transform(value, bindings, state) : value;
+}
+
+function targetParts(target, source) {
+  if (target.type !== "MemberExpression") {
+    return fail("A writable TSRX lazy binding did not resolve to a member expression", source);
+  }
+  const property = target.property;
+  return {
+    object: target.object,
+    key: target.computed ? property : literal(property.name, property)
+  };
+}
+
+function lowerDefaultedAssignment(
+node,
+binding,
+bindings,
+state)
+{
+  if (!binding.directDefault) return fail("Missing default for TSRX lazy assignment", node);
+  const left = node.left;
+  const target = binding.target(left, bindings);
+  if (!target) return fail("A TSRX lazy rest binding is read-only", left);
+  const { object, key } = targetParts(target, left);
+  const objectName = state.temp();
+  const keyName = state.temp();
+  const valueName = state.temp();
+  const objectId = () => ident(objectName, left);
+  const keyId = () => ident(keyName, left);
+  const valueId = () => ident(valueName, left);
+  const destination = () => member(objectId(), keyId(), true, left);
+  const effective = new Map(bindings);
+  effective.delete(left.name);
+  const fallback = transform(cloneNode(binding.directDefault), effective, state);
+  const right = transform(node.right, bindings, state);
+  const operator = node.operator;
+  const expressions = [
+  assignment("=", objectId(), object, left),
+  assignment("=", keyId(), key, left),
+  assignment("=", valueId(), destination(), left),
+  assignment(
+    "=",
+    valueId(),
+    conditional(
+      binary("===", valueId(), undefinedExpression(left), left),
+      fallback,
+      valueId(),
+      left
+    ),
+    left
+  )];
+
+
+  if (operator === "&&=" || operator === "||=" || operator === "??=") {
+    expressions.push(
+      logical(operator.slice(0, -1), valueId(), assignment("=", destination(), right, node), node)
+    );
+  } else {
+    expressions.push(
+      assignment("=", destination(), binary(operator.slice(0, -1), valueId(), right, node), node)
+    );
+  }
+  return sequence(expressions, node);
+}
+
+function lowerDefaultedUpdate(
+node,
+binding,
+bindings,
+state)
+{
+  if (!binding.directDefault) return fail("Missing default for TSRX lazy update", node);
+  const argument = node.argument;
+  const target = binding.target(argument, bindings);
+  if (!target) return fail("A TSRX lazy rest binding is read-only", argument);
+  const { object, key } = targetParts(target, argument);
+  const objectName = state.temp();
+  const keyName = state.temp();
+  const valueName = state.temp();
+  const objectId = () => ident(objectName, argument);
+  const keyId = () => ident(keyName, argument);
+  const valueId = () => ident(valueName, argument);
+  const destination = () => member(objectId(), keyId(), true, argument);
+  const effective = new Map(bindings);
+  effective.delete(argument.name);
+  const fallback = transform(cloneNode(binding.directDefault), effective, state);
+  const expressions = [
+  assignment("=", objectId(), object, argument),
+  assignment("=", keyId(), key, argument),
+  assignment("=", valueId(), destination(), argument),
+  assignment(
+    "=",
+    valueId(),
+    conditional(
+      binary("===", valueId(), undefinedExpression(argument), argument),
+      fallback,
+      valueId(),
+      argument
+    ),
+    argument
+  )];
+
+
+  if (node.prefix) {
+    expressions.push(
+      assignment(
+        "=",
+        destination(),
+        withLoc$1(
+          {
+            type: "UpdateExpression",
+            operator: node.operator,
+            prefix: true,
+            argument: valueId()
+          },
+          node
+        ),
+        node
+      )
+    );
+  } else {
+    const oldName = state.temp();
+    const oldId = () => ident(oldName, argument);
+    expressions.push(
+      assignment(
+        "=",
+        oldId(),
+        withLoc$1(
+          {
+            type: "UpdateExpression",
+            operator: node.operator,
+            prefix: false,
+            argument: valueId()
+          },
+          node
+        ),
+        node
+      ),
+      assignment("=", destination(), valueId(), node),
+      oldId()
+    );
+  }
+  return sequence(expressions, node);
+}
+
+function dynamicJsxElement(node, bindings, state) {
+  const opening = node.openingElement;
+  const name = opening.name;
+  let base = name;
+  const properties = [];
+  while (base.type === "JSXMemberExpression") {
+    properties.unshift(base.property);
+    base = base.object;
+  }
+  if (base.type !== "JSXIdentifier" || !/^[A-Z]/.test(base.name)) return null;
+  const binding = bindings.get(base.name);
+  if (!binding || binding.jsxName(base, bindings)) return null;
+
+  let expression = binding.read(base, bindings);
+  for (const property of properties) {
+    expression = member(expression, ident(property.name, property), false, property);
+  }
+  const dynamicName = withLoc$1({ type: "JSXIdentifier", name: "Dynamic" }, name);
+  const componentAttribute = {
+    type: "JSXAttribute",
+    name: withLoc$1({ type: "JSXIdentifier", name: "component" }, name),
+    value: withLoc$1({ type: "JSXExpressionContainer", expression }, name)
+  };
+  const nextOpening = {
+    ...opening,
+    name: dynamicName,
+    attributes: [
+    componentAttribute,
+    ...(opening.attributes ?? []).map((attribute) =>
+    transform(attribute, bindings, state)
+    )]
+
+  };
+  const closing = node.closingElement;
+  return {
+    ...node,
+    openingElement: nextOpening,
+    closingElement: closing ? { ...closing, name: cloneNode(dynamicName) } : null,
+    children: (node.children ?? []).map((child) => transform(child, bindings, state))
+  };
+}
+
+function addFunctionTemps(body, names) {
+  if (!names.length) return body;
+  const declaration = variableDeclaration("let", names);
+  if (body.type !== "BlockStatement") {
+    return {
+      type: "BlockStatement",
+      body: [declaration, withLoc$1({ type: "ReturnStatement", argument: body }, body)]
+    };
+  }
+  const statements = body.body;
+  let directiveEnd = 0;
+  while (
+  directiveEnd < statements.length &&
+  statements[directiveEnd].type === "ExpressionStatement" &&
+  typeof statements[directiveEnd].directive === "string")
+  {
+    directiveEnd++;
+  }
+  return {
+    ...body,
+    body: [...statements.slice(0, directiveEnd), declaration, ...statements.slice(directiveEnd)]
+  };
+}
+
+function transform(node, bindings, state) {
+  if (FUNCTION_TYPES.has(node.type)) {
+    const shadowed = new Set();
+    if (isNode$1(node.id)) collectShadowed(node.id, bindings, shadowed);
+    for (const param of node.params) collectShadowed(param, bindings, shadowed);
+    const outer = shadowed.size ? without(bindings, shadowed) : bindings;
+    const own = new Map();
+    let lazyParam = false;
+    for (const param of node.params) {
+      visitTopmostLazyPatterns(param, (lazy) => {
+        const sourceName = metadata(lazy).lazy_id;
+        if (!sourceName) return;
+        lazyParam = true;
+        collectBindings(lazy, sourceName, own, state);
+      });
+    }
+    const inner = own.size ? new Map([...outer, ...own]) : outer;
+    let paramsChanged = false;
+    const params = node.params.map((param) => {
+      if (param.type !== "AssignmentPattern") return param;
+      const right = transform(param.right, inner, state);
+      if (right === param.right) return param;
+      paramsChanged = true;
+      return { ...param, right };
+    });
+    if (!inner.size && !paramsChanged && !lazyParam && !metadata(node).has_lazy_descendants) {
+      return node;
+    }
+    state.pushFunctionTemps();
+    const functionBody = node.body;
+    let bodyBindings = inner;
+    if (functionBody.type === "BlockStatement") {
+      const varScope = collectVarScopeBindings(functionBody.body, state);
+      const unshadowed = varScope.declared.size ?
+      without(bodyBindings, varScope.declared) :
+      bodyBindings;
+      bodyBindings = new Map([...unshadowed, ...own, ...varScope.lazy]);
+    }
+    const transformedBody = transform(functionBody, bodyBindings, state);
+    const bodyTemps = state.popFunctionTemps();
+    const body = addFunctionTemps(transformedBody, bodyTemps);
+    const finalParams = lazyParam ? replaceLazyParams(params) : params;
+    return body !== node.body || finalParams !== node.params ?
+    {
+      ...node,
+      params: finalParams,
+      body,
+      ...(node.type === "ArrowFunctionExpression" && body.type === "BlockStatement" ?
+      { expression: false } :
+      {})
+    } :
+    node;
+  }
+
+  if (node.type === "Program") {
+    const body = node.body;
+    const varScope = collectVarScopeBindings(body, state);
+    const varOuter = varScope.declared.size ? without(bindings, varScope.declared) : bindings;
+    const withVar = varScope.lazy.size ? new Map([...varOuter, ...varScope.lazy]) : varOuter;
+    const shadowed = collectBlockShadowed(body, withVar);
+    const outer = shadowed.size ? without(withVar, shadowed) : withVar;
+    const own = new Map();
+    collectBindingsFromStatements(body, own, state);
+    const inner = own.size ? new Map([...outer, ...own]) : outer;
+    let changed = false;
+    const next = body.map((statement) => {
+      const result = transform(statement, inner, state);
+      if (result !== statement) changed = true;
+      return result;
+    });
+    return changed ? { ...node, body: next } : node;
+  }
+
+  if (node.type === "BlockStatement") {
+    const body = node.body;
+    const shadowed = collectBlockShadowed(body, bindings);
+    const outer = shadowed.size ? without(bindings, shadowed) : bindings;
+    const own = new Map();
+    collectBindingsFromStatements(body, own, state);
+    const inner = own.size ? new Map([...outer, ...own]) : outer;
+    let changed = false;
+    const next = body.map((statement) => {
+      const result = transform(statement, inner, state);
+      if (result !== statement) changed = true;
+      return result;
+    });
+    return changed ? { ...node, body: next } : node;
+  }
+
+  if (node.type === "StaticBlock" || node.type === "ClassStaticBlock") {
+    const body = node.body;
+    const varScope = collectVarScopeBindings(body, state);
+    const varOuter = varScope.declared.size ? without(bindings, varScope.declared) : bindings;
+    const withVar = varScope.lazy.size ? new Map([...varOuter, ...varScope.lazy]) : varOuter;
+    const shadowed = collectBlockShadowed(body, withVar);
+    const outer = shadowed.size ? without(withVar, shadowed) : withVar;
+    const own = new Map();
+    collectBindingsFromStatements(body, own, state);
+    const inner = own.size ? new Map([...outer, ...own]) : outer;
+    let changed = false;
+    const next = body.map((statement) => {
+      const result = transform(statement, inner, state);
+      if (result !== statement) changed = true;
+      return result;
+    });
+    return changed ? { ...node, body: next } : node;
+  }
+
+  if (node.type === "CatchClause") {
+    const own = new Map();
+    if (isNode$1(node.param)) {
+      visitTopmostLazyPatterns(node.param, (lazy) => {
+        const sourceName = metadata(lazy).lazy_id;
+        if (sourceName) collectBindings(lazy, sourceName, own, state);
+      });
+    }
+    const shadowed = new Set();
+    if (isNode$1(node.param)) collectShadowed(node.param, bindings, shadowed);
+    const outer = shadowed.size ? without(bindings, shadowed) : bindings;
+    const inner = own.size ? new Map([...outer, ...own]) : outer;
+    const param = isNode$1(node.param) ? replaceLazyInPattern(node.param, true) : node.param;
+    const body = transform(node.body, inner, state);
+    return param === node.param && body === node.body ? node : { ...node, param, body };
+  }
+
+  if (node.type === "ForStatement") {
+    const shadowed = new Set();
+    const own = new Map();
+    const init = node.init;
+    if (init?.type === "VariableDeclaration") {
+      for (const declaration of init.declarations) {
+        if (init.kind !== "var") {
+          visitTopmostLazyPatterns(declaration.id, (lazy) => {
+            const sourceName = metadata(lazy).lazy_id;
+            if (sourceName) collectBindings(lazy, sourceName, own, state);
+          });
+          collectShadowed(declaration.id, bindings, shadowed);
+        }
+      }
+    }
+    const outer = shadowed.size ? without(bindings, shadowed) : bindings;
+    const inner = own.size ? new Map([...outer, ...own]) : outer;
+    return {
+      ...node,
+      init: init ? transform(init, inner, state) : init,
+      test: isNode$1(node.test) ? transform(node.test, inner, state) : node.test,
+      update: isNode$1(node.update) ? transform(node.update, inner, state) : node.update,
+      body: transform(node.body, inner, state)
+    };
+  }
+
+  if (node.type === "ForOfStatement" || node.type === "ForInStatement") {
+    const shadowed = new Set();
+    const own = new Map();
+    const left = node.left;
+    if (left.type === "VariableDeclaration") {
+      for (const declaration of left.declarations) {
+        if (left.kind !== "var") {
+          visitTopmostLazyPatterns(declaration.id, (lazy) => {
+            const sourceName = metadata(lazy).lazy_id;
+            if (sourceName) collectBindings(lazy, sourceName, own, state);
+          });
+          collectShadowed(declaration.id, bindings, shadowed);
+        }
+      }
+    }
+    const outer = shadowed.size ? without(bindings, shadowed) : bindings;
+    const inner = own.size ? new Map([...outer, ...own]) : outer;
+    return {
+      ...node,
+      left: transform(left, inner, state),
+      right: transform(node.right, inner, state),
+      body: transform(node.body, inner, state)
+    };
+  }
+
+  if (node.type === "SwitchStatement") {
+    const cases = node.cases;
+    const statements = cases.flatMap((item) => item.consequent);
+    const shadowed = collectBlockShadowed(statements, bindings);
+    const outer = shadowed.size ? without(bindings, shadowed) : bindings;
+    const own = new Map();
+    collectBindingsFromStatements(statements, own, state);
+    const inner = own.size ? new Map([...outer, ...own]) : outer;
+    return {
+      ...node,
+      discriminant: transform(node.discriminant, outer, state),
+      cases: cases.map((item) => ({
+        ...item,
+        test: isNode$1(item.test) ? transform(item.test, inner, state) : item.test,
+        consequent: item.consequent.map((statement) =>
+        transform(statement, inner, state)
+        )
+      }))
+    };
+  }
+
+  if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+    const shadowed = new Set();
+    if (isNode$1(node.id)) collectShadowed(node.id, bindings, shadowed);
+    const inner = shadowed.size ? without(bindings, shadowed) : bindings;
+    return {
+      ...node,
+      superClass: isNode$1(node.superClass) ?
+      transform(node.superClass, bindings, state) :
+      node.superClass,
+      body: transform(node.body, inner, state)
+    };
+  }
+
+  if (
+  node.type === "ExportNamedDeclaration" &&
+  isNode$1(node.declaration) &&
+  node.declaration.type === "VariableDeclaration")
+  {
+    for (const declaration of node.declaration.declarations) {
+      visitTopmostLazyPatterns(declaration.id, (pattern) => {
+        fail(
+          "TSRX lazy bindings cannot be exported; export the source object or an explicit accessor instead",
+          pattern
+        );
+      });
+    }
+  }
+
+  if (
+  node.type === "ExportSpecifier" &&
+  isNode$1(node.local) &&
+  node.local.type === "Identifier" &&
+  bindings.has(node.local.name))
+  {
+    return fail(
+      "TSRX lazy bindings cannot be exported; export the source object or an explicit accessor instead",
+      node.local
+    );
+  }
+
+  if (node.type === "JSXElement") {
+    const dynamic = dynamicJsxElement(node, bindings, state);
+    if (dynamic) return dynamic;
+  }
+
+  if (
+  node.type === "ExpressionStatement" &&
+  isNode$1(node.expression) &&
+  node.expression.type === "AssignmentExpression" &&
+  node.expression.operator === "=" &&
+  isNode$1(node.expression.left) && (
+  node.expression.left.type === "ObjectPattern" ||
+  node.expression.left.type === "ArrayPattern") &&
+  node.expression.left.lazy)
+  {
+    const pattern = node.expression.left;
+    const sourceName = metadata(pattern).lazy_id;
+    if (sourceName) {
+      const id = generatedPatternIdentifier(pattern, sourceName, true);
+      return {
+        type: "VariableDeclaration",
+        kind: "const",
+        declarations: [
+        {
+          type: "VariableDeclarator",
+          id,
+          init: transform(node.expression.right, bindings, state)
+        }]
+
+      };
+    }
+  }
+
+  if (
+  node.type === "ExpressionStatement" &&
+  isNode$1(node.expression) &&
+  node.expression.type === "AssignmentExpression" &&
+  node.expression.operator === "=" &&
+  isNode$1(node.expression.left) && (
+  node.expression.left.type === "ObjectPattern" ||
+  node.expression.left.type === "ArrayPattern") &&
+  !node.expression.left.lazy)
+  {
+    const left = replaceLazyInPattern(node.expression.left);
+    if (left !== node.expression.left) {
+      return fail(
+        "A lazy pattern nested inside a standalone destructuring assignment is not supported because its generated source binding cannot be scoped correctly; use a lazy variable declaration",
+        node.expression.left
+      );
+    }
+  }
+
+  if (
+  node.type === "AssignmentExpression" &&
+  isNode$1(node.left) &&
+  node.left.type === "Identifier")
+  {
+    const binding = bindings.get(node.left.name);
+    if (binding) {
+      assertWritable(binding, node.left);
+      if (node.operator !== "=" && binding.directDefault) {
+        return lowerDefaultedAssignment(node, binding, bindings, state);
+      }
+      const target = binding.target(node.left, bindings);
+      if (!target) return fail("A TSRX lazy rest binding is read-only", node.left);
+      return {
+        ...node,
+        left: target,
+        right: transform(node.right, bindings, state)
+      };
+    }
+  }
+
+  if (
+  node.type === "UpdateExpression" &&
+  isNode$1(node.argument) &&
+  node.argument.type === "Identifier")
+  {
+    const binding = bindings.get(node.argument.name);
+    if (binding) {
+      assertWritable(binding, node.argument);
+      if (binding.directDefault) {
+        return lowerDefaultedUpdate(node, binding, bindings, state);
+      }
+      const target = binding.target(node.argument, bindings);
+      if (!target) return fail("A TSRX lazy rest binding is read-only", node.argument);
+      return { ...node, argument: target };
+    }
+  }
+
+  if (node.type === "VariableDeclarator" && isNode$1(node.id) && metadata(node.id).lazy_id) {
+    const sourceName = metadata(node.id).lazy_id;
+    return {
+      ...node,
+      id: generatedPatternIdentifier(node.id, sourceName, true),
+      init: isNode$1(node.init) ? transform(node.init, bindings, state) : node.init
+    };
+  }
+
+  if (
+  node.type === "VariableDeclarator" &&
+  isNode$1(node.id) && (
+  node.id.type === "ObjectPattern" || node.id.type === "ArrayPattern") &&
+  !node.id.lazy)
+  {
+    const id = replaceLazyInPattern(node.id);
+    if (id !== node.id) {
+      return {
+        ...node,
+        id,
+        init: isNode$1(node.init) ? transform(node.init, bindings, state) : node.init
+      };
+    }
+  }
+
+  if (
+  node.type === "Property" &&
+  node.shorthand &&
+  isNode$1(node.value) &&
+  node.value.type === "Identifier")
+  {
+    const binding = bindings.get(node.value.name);
+    if (binding) return { ...node, shorthand: false, value: binding.read(node.value, bindings) };
+  }
+
+  if (node.type === "Identifier") {
+    const binding = bindings.get(node.name);
+    return binding ? binding.read(node, bindings) : node;
+  }
+
+  if (node.type === "JSXIdentifier") return node;
+  if (node.type === "MetaProperty") return node;
+
+  let changed = false;
+  const clone = { ...node };
+  for (const key of Object.keys(node)) {
+    if (SKIP_KEYS$1.has(key) || TYPE_KEYS.has(key)) continue;
+    if (
+    key === "key" &&
+    !node.computed && (
+    node.type === "Property" ||
+    node.type === "MethodDefinition" ||
+    node.type === "PropertyDefinition"))
+    {
+      continue;
+    }
+    if (key === "property" && node.type === "MemberExpression" && !node.computed) continue;
+    if (key === "property" && node.type === "JSXMemberExpression") continue;
+    if (key === "name" && node.type === "JSXAttribute") continue;
+    if (key === "id" && node.type === "VariableDeclarator") continue;
+    if (
+    (key === "local" || key === "imported" || key === "exported") &&
+    /Specifier$/.test(node.type))
+    {
+      continue;
+    }
+    if (key === "label") continue;
+
+    if (
+    key === "name" && (
+    node.type === "JSXOpeningElement" || node.type === "JSXClosingElement") &&
+    isNode$1(node.name))
+    {
+      const jsxName = rewriteJsxName(node.name, bindings);
+      if (jsxName) {
+        clone[key] = jsxName;
+        changed = true;
+        continue;
+      }
+    }
+    const value = transformValue(node[key], bindings, state);
+    if (value !== node[key]) {
+      clone[key] = value;
+      changed = true;
+    }
+  }
+  return changed ? clone : node;
+}
+
+function rewriteJsxName(name, bindings) {
+  if (name.type === "JSXIdentifier") {
+    if (!/^[A-Z]/.test(name.name)) return null;
+    return bindings.get(name.name)?.jsxName(name, bindings) ?? null;
+  }
+  if (name.type === "JSXMemberExpression") {
+    const object = rewriteJsxName(name.object, bindings);
+    return object ? { ...name, object } : null;
+  }
+  return null;
+}
+
+/** Apply Solid's local lazy transform to a fully desugared TSRX program. */
+function applyLazyTransforms(root) {
+  const state = new LazyState(root);
+  preallocate(root, state);
+  return state.finalize(transform(root, new Map(), state));
+}
+
+const SKIP_KEYS = new Set([
+"type",
+"loc",
+"start",
+"end",
+"range",
+"metadata",
+"css",
+"leadingComments",
+"trailingComments",
+"innerComments"]
+);
+
+const FUNCTION_BOUNDARIES = new Set([
+"FunctionDeclaration",
+"FunctionExpression",
+"ArrowFunctionExpression",
+"ClassDeclaration",
+"ClassExpression"]
+);
+
+function isNode(value) {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof value.type === "string");
+
+}
+
+function isStyleElement(node) {
+  return node.type === "JSXStyleElement";
+}
+
+function isNativeRenderRoot(node) {
+  return (
+    (node.type === "JSXElement" || node.type === "JSXFragment") &&
+    !!node.metadata?.native_tsrx);
+
+}
+
+function isNativeTsrxNode(node) {
+  return (
+    node?.type === "JSXCodeBlock" ||
+    !!node && (
+    node.type === "JSXElement" ||
+    node.type === "JSXFragment" ||
+    node.type === "JSXStyleElement") &&
+    !!node.metadata?.native_tsrx);
+
+}
+
+function isStyleExpressionPosition(path) {
+  const parent = path[path.length - 1];
+  return !(
+  isNativeTsrxNode(parent) ||
+  parent?.type === "BlockStatement" ||
+  parent?.type === "Program" ||
+  parent?.type === "SwitchCase");
+
+}
+
+function structuralChildren(node) {
+  switch (node.type) {
+    case "JSXElement":
+    case "JSXFragment":
+      return (node.children ?? []).filter(isNode);
+    case "JSXCodeBlock":
+      return [
+      ...(node.body ?? []).filter(isNode),
+      ...(isNode(node.render) ? [node.render] : [])];
+
+    case "BlockStatement":
+      return (node.body ?? []).filter(isNode);
+    case "JSXIfExpression":
+    case "IfStatement":
+      return [node.consequent, node.alternate].filter(isNode);
+    case "JSXForExpression":
+      return [node.body, node.empty].filter(isNode);
+    case "JSXSwitchExpression":
+    case "SwitchStatement":
+      return (node.cases ?? []).flatMap((switchCase) =>
+      (switchCase.consequent ?? []).filter(isNode)
+      );
+    case "JSXTryExpression":
+    case "TryStatement":
+      return [node.block, node.pending, node.handler, node.finalizer].filter(isNode);
+    case "CatchClause":
+      return isNode(node.body) ? [node.body] : [];
+    default:
+      return [];
+  }
+}
+
+function collectRuntimeStyleElements(value, styles) {
+  if (Array.isArray(value)) {
+    for (const child of value) collectRuntimeStyleElements(child, styles);
+    return;
+  }
+  if (isStyleElement(value)) {
+    styles.push(value);
+    return;
+  }
+  if (FUNCTION_BOUNDARIES.has(value.type)) return;
+
+  if ((value.type === "JSXElement" || value.type === "JSXFragment") && isNativeRenderRoot(value)) {
+    collectRuntimeStyleElements(value.children ?? [], styles);
+    return;
+  }
+  if (value.type === "BlockStatement") {
+    collectRuntimeStyleElements(value.body ?? [], styles);
+    return;
+  }
+  if (value.type === "JSXIfExpression" || value.type === "IfStatement") {
+    if (isNode(value.consequent)) collectRuntimeStyleElements(value.consequent, styles);
+    if (isNode(value.alternate)) collectRuntimeStyleElements(value.alternate, styles);
+    return;
+  }
+  // This is an intentional ownership boundary in @tsrx/core: a style directly
+  // rendered by an @for body is visited later as an unowned statement style.
+  if (value.type === "JSXForExpression") return;
+  if (value.type === "JSXSwitchExpression" || value.type === "SwitchStatement") {
+    for (const switchCase of value.cases ?? []) {
+      collectRuntimeStyleElements(switchCase.consequent ?? [], styles);
+    }
+    return;
+  }
+  if (value.type === "JSXTryExpression" || value.type === "TryStatement") {
+    if (isNode(value.block)) collectRuntimeStyleElements(value.block, styles);
+    const handler = isNode(value.handler) ? value.handler : undefined;
+    if (handler && isNode(handler.body)) collectRuntimeStyleElements(handler.body, styles);
+    if (isNode(value.finalizer)) collectRuntimeStyleElements(value.finalizer, styles);
+    // `pending` is deliberately absent: core does not assign direct @pending
+    // statement styles to the surrounding fragment.
+  }
+}
+
+function collectPrunableElements(
+value,
+elements,
+path = [])
+{
+  if (Array.isArray(value)) {
+    for (const child of value) collectPrunableElements(child, elements, path);
+    return;
+  }
+  if (FUNCTION_BOUNDARIES.has(value.type) || isStyleElement(value)) return;
+
+  if (value.type === "JSXElement" && isNativeRenderRoot(value)) {
+    const metadata = value.metadata ??= {};
+    metadata.path = path;
+    elements.push(value);
+  }
+
+  const childPath = [...path, value];
+  for (const child of structuralChildren(value)) {
+    collectPrunableElements(child, elements, childPath);
+  }
+}
+
+function annotateRuntimeValue(value, hash, core) {
+  if (isStyleElement(value)) return null;
+  if (FUNCTION_BOUNDARIES.has(value.type)) return value;
+  if (value.type === "JSXElement") {
+    return core.annotateWithHash(value, hash, "class", false);
+  }
+  if (value.type === "JSXFragment") {
+    value.children = annotateRuntimeList(
+      value.children ?? [],
+      hash,
+      core
+    );
+    return value;
+  }
+
+  mutateStructuralChildren(value, (child) => annotateRuntimeValue(child, hash, core));
+  return value;
+}
+
+function annotateRuntimeList(values, hash, core) {
+  return values.
+  map((value) => annotateRuntimeValue(value, hash, core)).
+  filter((value) => value !== null);
+}
+
+function mutateStructuralChildren(node, transform) {
+  const mapList = (values) =>
+  (values ?? []).map(transform).filter((value) => value !== null);
+  const mapSlot = (key) => {
+    const value = node[key];
+    if (isNode(value)) node[key] = transform(value);
+  };
+
+  switch (node.type) {
+    case "JSXElement":
+    case "JSXFragment":
+      node.children = mapList(node.children);
+      break;
+    case "JSXCodeBlock":
+      node.body = mapList(node.body);
+      mapSlot("render");
+      break;
+    case "BlockStatement":
+      node.body = mapList(node.body);
+      break;
+    case "JSXIfExpression":
+    case "IfStatement":
+      mapSlot("consequent");
+      mapSlot("alternate");
+      break;
+    case "JSXForExpression":
+      mapSlot("body");
+      mapSlot("empty");
+      break;
+    case "JSXSwitchExpression":
+    case "SwitchStatement":
+      for (const switchCase of node.cases ?? []) {
+        switchCase.consequent = mapList(switchCase.consequent);
+      }
+      break;
+    case "JSXTryExpression":
+    case "TryStatement":
+      mapSlot("block");
+      mapSlot("pending");
+      mapSlot("handler");
+      mapSlot("finalizer");
+      break;
+    case "CatchClause":
+      mapSlot("body");
+      break;
+  }
+}
+
+function cleanRuntimeStyles(node) {
+  if (FUNCTION_BOUNDARIES.has(node.type)) return;
+  mutateStructuralChildren(node, (child) => {
+    if (isStyleElement(child)) return null;
+    cleanRuntimeStyles(child);
+    return child;
+  });
+}
+
+function withLoc(node, source) {
+  if (source.start !== undefined) node.start = source.start;
+  if (source.end !== undefined) node.end = source.end;
+  if (source.loc !== undefined) node.loc = source.loc;
+  return node;
+}
+
+function wrapWithSetup(expression, statements) {
+  const body = withLoc(
+    {
+      type: "BlockStatement",
+      body: [...statements, withLoc({ type: "ReturnStatement", argument: expression }, expression)]
+    },
+    expression
+  );
+  const fn = withLoc(
+    {
+      type: "ArrowFunctionExpression",
+      id: null,
+      params: [],
+      body,
+      expression: false,
+      async: false,
+      generator: false
+    },
+    expression
+  );
+  return withLoc(
+    { type: "CallExpression", callee: fn, arguments: [], optional: false },
+    expression
+  );
+}
+
+function collectIdentifierNames(node, names) {
+  if (node.type === "Identifier" && typeof node.name === "string") names.add(node.name);
+  for (const key of Object.keys(node)) {
+    if (SKIP_KEYS.has(key)) continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const child of value) if (isNode(child)) collectIdentifierNames(child, names);
+    } else if (isNode(value)) {
+      collectIdentifierNames(value, names);
+    }
+  }
+}
+
+function createTempIdentifierFactory(program) {
+  const names = new Set();
+  collectIdentifierNames(program, names);
+  let index = 0;
+  return () => {
+    let name;
+    do {
+      name = `_tsrx_style_ref_${++index}`;
+    } while (names.has(name));
+    names.add(name);
+    return { type: "Identifier", name };
+  };
+}
+
+function createEmptyStyleElement(node) {
+  const metadata = node.metadata ?? {};
+  const cloneElementPart = (part) => {
+    if (!isNode(part)) return part;
+    return {
+      ...part,
+      metadata: {
+        path: [...(metadata.path ?? [])]
+      }
+    };
+  };
+  return {
+    ...node,
+    type: "JSXElement",
+    openingElement: cloneElementPart(node.openingElement),
+    closingElement: cloneElementPart(node.closingElement),
+    children: []
+  };
+}
+
+function prepareRuntimeStyle(
+owner,
+style,
+core,
+createTempIdentifier)
+{
+  const stylesheet = core.getStyleElementStylesheet(style);
+  if (!stylesheet) {
+    throw new SyntaxError("A TSRX <style> element is missing its parsed stylesheet");
+  }
+
+  core.analyzeCss(stylesheet);
+  const metadata = owner.metadata ??= {};
+  const styleClasses = new Map();
+  const topScopedClasses = new Map();
+
+  const elements = [];
+  collectPrunableElements(owner.children ?? [], elements);
+  for (const element of elements) {
+    core.pruneCss(stylesheet, element, styleClasses, topScopedClasses, stylesheet.hash);
+  }
+
+  const refs = core.collectStyleRefAttributes(owner);
+  if (refs.length > 0) {
+    for (const [name, classInfo] of topScopedClasses) {
+      styleClasses.set(
+        name,
+        classInfo?.selector ?? classInfo
+      );
+    }
+    for (const element of elements) {
+      core.pruneCss(stylesheet, element, styleClasses, topScopedClasses, stylesheet.hash);
+    }
+  }
+  if (topScopedClasses.size > 0) metadata.topScopedClasses = topScopedClasses;
+
+  const setup =
+  refs.length === 0 ?
+  [] :
+  core.createStyleRefSetupStatements(refs, core.createStyleClassMap(owner, stylesheet), {
+    allowMutableRefTarget: true,
+    createTempIdentifier
+  });
+
+  mutateStructuralChildren(owner, (child) => annotateRuntimeValue(child, stylesheet.hash, core));
+  cleanRuntimeStyles(owner);
+  return { owner, stylesheet, setup };
+}
+
+function prepareStyleOwner(
+owner,
+core,
+createTempIdentifier)
+{
+  const styles = [];
+  collectRuntimeStyleElements(owner.children ?? [], styles);
+  if (styles.length > 1) {
+    throw new SyntaxError("TSRX fragments can only have one style tag");
+  }
+  return styles.length === 1 ?
+  prepareRuntimeStyle(owner, styles[0], core, createTempIdentifier) :
+  null;
+}
+
+function processTsrxStyles(program, core) {
+  const stylesheets = [];
+  const createTempIdentifier = createTempIdentifierFactory(program);
+
+  const visit = (node, path) => {
+    if (isStyleElement(node)) {
+      if (!isStyleExpressionPosition(path)) return createEmptyStyleElement(node);
+      const stylesheet = core.getStyleElementStylesheet(node);
+      if (!stylesheet) {
+        throw new SyntaxError("A TSRX <style> expression is missing its parsed stylesheet");
+      }
+      core.analyzeCss(stylesheet);
+      stylesheets.push(core.prepareStylesheetForRender(stylesheet, true));
+      return core.createStyleClassMapFromStylesheet(stylesheet);
+    }
+
+    if (node.type === "JSXCodeBlock" && isNode(node.render) && isNativeRenderRoot(node.render)) {
+      // Core gives a code block's native element/fragment render one style
+      // scope. A native element elsewhere is deliberately not an owner.
+      const prepared = prepareStyleOwner(node.render, core, createTempIdentifier);
+      if (prepared) {
+        stylesheets.push(prepared.stylesheet);
+        node.render = prepared.owner;
+        node.body = [...(node.body ?? []), ...prepared.setup];
+      }
+    } else if (node.type === "JSXFragment" && isNativeRenderRoot(node)) {
+      // Native fragments are owners in every expression/child position.
+      const prepared = prepareStyleOwner(node, core, createTempIdentifier);
+      if (prepared) {
+        stylesheets.push(prepared.stylesheet);
+        node = prepared.setup.length ?
+        wrapWithSetup(prepared.owner, prepared.setup) :
+        prepared.owner;
+      }
+    }
+
+    for (const key of Object.keys(node)) {
+      if (SKIP_KEYS.has(key)) continue;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        node[key] = value.map((child) => isNode(child) ? visit(child, [...path, node]) : child);
+      } else if (isNode(value)) {
+        node[key] = visit(value, [...path, node]);
+      }
+    }
+    return node;
+  };
+
+  visit(program, []);
+  return core.renderCssResult(stylesheets);
+}
+
+/**
+ * TSRX syntax frontend entry point.
+ *
+ * Routes `.tsrx` sources (or any source when `syntax: "tsrx"`) through
+ * `@tsrx/core`'s parser + semantic analysis, processes scoped styles with
+ * core's CSS helpers, desugars every TSRX construct to Solid builtIn JSX,
+ * applies Solid's local deferred-pattern transform for generated control-flow
+ * callbacks, and converts the result to a Babel `File` for the unchanged JSX
+ * pipeline. Authored lazy destructuring is rejected for the Solid target.
+ *
+ * `@tsrx/core` is an optional peer dependency loaded lazily on first TSRX
+ * routing, so plain JSX users never pay for it.
+ */
+
+
+
+// The plugin ships as CJS; `require` of the ESM-only `@tsrx/core` is
+// supported natively on Node >= 22.12. No @types/node in this package.
+
+
+
+
+
+
+
+
+
+
+
+let core;
+
+function loadTsrxCore() {
+  if (core) return core;
+  if (typeof require !== "function") {
+    throw new Error(
+      "@solidjs/babel-plugin: TSRX support requires a CommonJS environment with `require` available."
+    );
+  }
+  try {
+    core = require("@tsrx/core");
+  } catch (error) {
+    const err = error;
+    if (err.code === "MODULE_NOT_FOUND") {
+      throw new Error(
+        "@solidjs/babel-plugin: compiling .tsrx sources requires the optional peer dependency `@tsrx/core`. Install it with your package manager (e.g. `pnpm add -D @tsrx/core`)."
+      );
+    }
+    if (err.code === "ERR_REQUIRE_ESM" || err.code === "ERR_REQUIRE_ASYNC_MODULE") {
+      throw new Error(
+        "@solidjs/babel-plugin: loading `@tsrx/core` synchronously requires Node.js >= 22.12 (require(esm) support)."
+      );
+    }
+    throw error;
+  }
+  return core;
+}
+
+
+
+/** Whether the given file should be parsed as TSRX under the configured
+ * `syntax` option. */
+function isTsrxSource(syntax, filename) {
+  const mode = syntax ?? "auto";
+  if (mode === "tsrx") return true;
+  if (mode === "jsx") return false;
+  return typeof filename === "string" && filename.endsWith(".tsrx");
+}
+
+/** Parse TSRX source text into a Babel `File` with all TSRX constructs
+ * lowered to Solid builtIn JSX. */
+function parseTsrx(code, filename) {
+  const tsrx = loadTsrxCore();
+  const program = tsrx.parseModule(code, filename ?? "module.tsrx");
+  rejectAuthoredLazyDestructuring(program);
+  // Throws structured diagnostics (invalid returns, misplaced directives, …).
+  tsrx.analyzeTsrx(program, filename ?? null);
+  const styleResult = processTsrxStyles(program, tsrx);
+
+  // Desugar before the lazy transform: the lazy engine collects block-level
+  // `let &[…]`/`const &{…}` bindings in its BlockStatement/Program handlers,
+  // which only fire once `@{}` containers have become real blocks. Lazy
+  // patterns themselves pass through the desugarer untouched.
+  desugarProgram(program);
+
+  const transformed = applyLazyTransforms(program);
+  // Keep this compatibility repair in place for trees produced by older
+  // desugaring paths. The local engine itself never rewrites intrinsic names.
+  restoreIntrinsicJsxNames(transformed);
+
+  const file = toBabelFile(transformed);
+  // Babel's default AST clone preserves enumerable string keys. Program.enter
+  // lifts this temporary payload into transform metadata and removes it from
+  // the AST, avoiding mutable plugin-factory state (and concurrent-run races).
+  file.tsrxStyle = styleResult;
+  return file;
+}
+
+var index = (
+_api,
+options = {}) =>
+
+
+
+
+
+{
+  return {
+    name: "@solidjs/babel-plugin",
+    inherits: SyntaxJSX.default,
+    parserOverride(code, parserOpts, parse) {
+      if (isTsrxSource(options.syntax, parserOpts?.sourceFileName)) {
+        return parseTsrx(code, parserOpts?.sourceFileName);
+      }
+      return parse(code, parserOpts);
+    },
     visitor: {
       JSXElement: transformJSX,
       JSXFragment: transformJSX,