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

package/index.js

@@ -2172,7 +2172,7 @@ results)
                 t$1.expressionStatement(
                   t$1.assignmentExpression(
                     "=",
-                    t$1.memberExpression(elem, t$1.identifier(`$$${ev}Data`)),
+                    t$1.memberExpression(elem, t$1.identifier(`_$$${ev}Data`)),
                     handler.elements[1]
                   )
                 )
@@ -2183,7 +2183,7 @@ results)
               t$1.expressionStatement(
                 t$1.assignmentExpression(
                   "=",
-                  t$1.memberExpression(elem, t$1.identifier(`$$${ev}`)),
+                  t$1.memberExpression(elem, t$1.identifier(`_$$${ev}`)),
                   handler
                 )
               )
@@ -2193,7 +2193,7 @@ results)
               t$1.expressionStatement(
                 t$1.assignmentExpression(
                   "=",
-                  t$1.memberExpression(elem, t$1.identifier(`$$${ev}`)),
+                  t$1.memberExpression(elem, t$1.identifier(`_$$${ev}`)),
                   handler
                 )
               )
@@ -2781,7 +2781,7 @@ attributes,
             id,
             [],
             t$1.blockStatement([t$1.returnStatement(expression)]),
-            !t$1.isValidIdentifier(normalized)
+            false // never computed; see shared/component.ts (#3511)
           )
         );
       } else {
@@ -2804,11 +2804,12 @@ attributes,
   // A lone spread — reactive included — passes straight through: spread()
   // resolves a function source inside its own tracking scopes, and merging
   // one source would mint a memo that consumes a hydration id the SSR fast
-  // path never allocates (#3105).
-  const props =
-  spreadArgs.length === 1 ?
-  spreadArgs[0] :
-  t$1.callExpression(registerImportMethod(path, "mergeProps"), spreadArgs);
+  // path never allocates (#3105). Several sources go as an ARRAY, not a
+  // mergeProps() call: spread() reads the sources directly (later wins per
+  // key, only the winner read) with no merge proxy to build and walk, and a
+  // reactive source is called inside the tracking scope with no memo — so
+  // no hydration id here either, matching the ssrElement array form.
+  const props = spreadArgs.length === 1 ? spreadArgs[0] : t$1.arrayExpression(spreadArgs);
 
   return [
   filteredAttributes,
@@ -2952,6 +2953,32 @@ function registerTemplate(path, results) {
   results.decl = t__namespace.variableDeclaration("var", results.declarations);
 }
 
+/** A non-inline object-valued `style` / `class` binding is read in the TRACKED
+ * half of its effect through `readShallow()`: `style()`/`className()` enumerate
+ * their object in the untracked commit phase, so a proxy value (a store
+ * sub-object, merged props) would be identity-reactive only. Skipped when the
+ * expression is provably a string or a fresh literal (`readShallow` would pass
+ * those through anyway; the call is what's saved). */
+function wrapReadShallow(path, key, value) {
+  if (key !== "class" && key !== "style") return value;
+  if (
+  t__namespace.isStringLiteral(value) ||
+  t__namespace.isTemplateLiteral(value) ||
+  t__namespace.isBinaryExpression(value) ||
+  t__namespace.isObjectExpression(value) ||
+  // a class array of literals cannot hold a proxy either
+  t__namespace.isArrayExpression(value) &&
+  value.elements.every(
+    (e) => t__namespace.isStringLiteral(e) || t__namespace.isTemplateLiteral(e) || t__namespace.isObjectExpression(e)
+  ))
+
+  return value;
+  return t__namespace.callExpression(
+    registerImportMethod(path, "readShallow", getRendererConfig(path, "dom").moduleName),
+    [value]
+  );
+}
+
 function wrapDynamics$1(path, dynamics) {
   if (!dynamics.length) return;
   const config = getConfig(path);
@@ -2975,7 +3002,7 @@ function wrapDynamics$1(path, dynamics) {
     const newValue = t__namespace.identifier("_v$");
     return t__namespace.expressionStatement(
       t__namespace.callExpression(effectWrapperId, [
-      wrapForEffect(dynamics[0].value),
+      wrapForEffect(wrapReadShallow(path, dynamics[0].key, dynamics[0].value)),
       t__namespace.arrowFunctionExpression(
         prevValue ? [newValue, prevValue] : [newValue],
         t__namespace.blockStatement([
@@ -3010,7 +3037,7 @@ function wrapDynamics$1(path, dynamics) {
     }
 
     properties.push(propIdent);
-    values.push(t__namespace.objectProperty(propIdent, value));
+    values.push(t__namespace.objectProperty(propIdent, wrapReadShallow(path, key, value)));
 
     if (key === "class" || key === "style" || isStatefulDOMProperty(tagName, key)) {
       statements.push(
@@ -3465,9 +3492,8 @@ escapeLiterals)
     expression.wontEscape = true;
     return expression;
   } else if (t.isJSXFragment(expression) && fragmentWillSelfEscape(expression)) {
-    // The fragment will later be transformed into a runtime value the
-    // `escape` helper passes through unchanged — either a memoized
-    // accessor function or an `_$ssr(...)` SSRNode object (see
+    // The fragment will later be transformed into an `_$ssr(...)` SSRNode
+    // object the `escape` helper passes through unchanged (see
     // `fragmentWillSelfEscape`). Wrapping it in another `_$escape(...)`
     // here would be a guaranteed no-op, so leave the fragment in place
     // and let the later traversal emit the inner form directly.
@@ -3495,23 +3521,16 @@ function escapeTemplateQuasis(expression, attr) {
 // Predicts whether a JSXFragment AST will compile to a single runtime
 // value for which the outer `_$escape(...)` wrap is a no-op. Must stay
 // conservative: any shape this returns `true` for must, when later
-// transformed, produce a self-escaping (or escape-immune) runtime value.
-// When in doubt, return false so the outer `_$escape` wrap is kept.
+// transformed, produce an escape-immune runtime value. When in doubt,
+// return false so the outer `_$escape` wrap is kept.
+//
+// The one recognized shape is `<><native /></>` — a single native
+// (non-component) JSXElement, whose `createTemplate` output is
+// `_$ssr(_tmpl$N, …)`: an SSRNode object `escape` passes through.
 //
-// Recognized single-significant-child shapes:
-//   A. `<>{memberOrCall}</>` — a `JSXExpressionContainer` whose
-//      expression matches the top-level subset of
-//      `isDynamic({ checkMember: true })` (member access, call, tagged
-//      template, optional variants, `in` checks). `createTemplate`
-//      emits `_$memo(() => _$escape(expr))`; the memo returns a
-//      function accessor at runtime and `escape(fn)` is a pass-through.
-//      Nested-dynamic shapes (conditional/logical carrying dynamic
-//      sub-expressions) are excluded — confirming them needs the full
-//      `isDynamic` traversal and a missed optimization costs only one
-//      runtime no-op call.
-//   B. `<><native /></>` — a single native (non-component) JSXElement.
-//      `createTemplate` emits `_$ssr(_tmpl$N, …)`, which returns an
-//      SSRNode object; `escape(object)` is a pass-through.
+// A single expression child (`<>{x()}</>`) is NOT immune: it compiles to a
+// memo the runtime's `escape` defers into (a function's yield is content
+// like any other), so the hole must keep its wrap.
 function fragmentWillSelfEscape(fragment) {
   let only = null;
   for (const c of fragment.children) {
@@ -3521,25 +3540,10 @@ function fragmentWillSelfEscape(fragment) {
     }
     if (t__namespace.isJSXExpressionContainer(c) && t__namespace.isJSXEmptyExpression(c.expression))
     continue;
-    if (only !== null) return false;
-    if (t__namespace.isJSXElement(c) || t__namespace.isJSXExpressionContainer(c)) only = c;else
-    return false;
-  }
-  if (!only) return false;
-  if (t__namespace.isJSXExpressionContainer(only)) {
-    const expr = only.expression;
-    if (t__namespace.isJSXEmptyExpression(expr)) return false;
-    return (
-      t.isCallExpression(expr) ||
-      t.isOptionalCallExpression(expr) ||
-      t.isTaggedTemplateExpression(expr) ||
-      t.isMemberExpression(expr) ||
-      t.isOptionalMemberExpression(expr) ||
-      t__namespace.isBinaryExpression(expr) && expr.operator === "in");
-
+    if (only !== null || !t__namespace.isJSXElement(c)) return false;
+    only = c;
   }
-  if (t__namespace.isJSXElement(only)) return !isComponent(getTagName(only));
-  return false;
+  return only !== null && !isComponent(getTagName(only));
 }
 
 function normalizeAttributes(path) {
@@ -4050,7 +4054,6 @@ path,
   } else {
     props = [];
     let runningObject = [],
-      dynamicSpread = false,
       hasChildren = path.node.children.length > 0;
 
     attributes.forEach((attribute) => {
@@ -4060,10 +4063,16 @@ path,
           props.push(t.objectExpression(runningObject));
           runningObject = [];
         }
+        // A dynamic spread defers behind a thunk: evaluated in argument
+        // position it would run before `ssrElement` allocates the element's
+        // own hydration id, while the client claims the element
+        // (getNextElement) before applying the spread — shifting the
+        // element's id by one and leaving it unclaimed. `ssrElement` calls
+        // function sources after allocating the key, matching that order.
         props.push(
           isDynamic(attribute.get("argument"), {
             checkMember: true
-          }) && (dynamicSpread = true) ?
+          }) ?
           inlineCallExpression(node.argument) :
           node.argument
         );
@@ -4092,7 +4101,7 @@ path,
                 id,
                 [],
                 t.blockStatement([t.returnStatement(expression)]),
-                !t.isValidIdentifier(key)
+                false // never computed; see shared/component.ts (#3511)
               )
             );
           } else runningObject.push(t.objectProperty(id, expression));
@@ -4102,21 +4111,13 @@ path,
 
     if (runningObject.length || !props.length) props.push(t.objectExpression(runningObject));
 
-    if (props.length > 1 || dynamicSpread) {
-      let merged = t.callExpression(
-        registerImportMethod(path, "mergeProps"),
-        props
-      );
-      // Defer the merge behind a thunk when hydratable: `mergeProps` with a
-      // function source creates a memo, which consumes a hydration child id.
-      // Evaluated in argument position it would run before `ssrElement`
-      // allocates the element's own id, while the client claims the element
-      // (getNextElement) before applying the spread — shifting the element's
-      // id by one and leaving it unclaimed. `ssrElement` resolves function
-      // props after allocating the hydration key, matching the client order.
-      if (hydratable) merged = t.arrowFunctionExpression([], merged);
-      props = [merged];
-    }
+    // Several sources go as an ARRAY, not a mergeProps() call: ssrElement
+    // serializes straight from the sources (later wins per key, only the
+    // winner read) with no merged object to build and walk once, and a
+    // function source is a plain thunk called after the key — no memo, so no
+    // hydration id, matching the client spread() array form. A single
+    // source, thunk included, passes through as the props argument itself.
+    if (props.length > 1) props = [t.arrayExpression(props)];
   }
 
   const exprs = [
@@ -4139,31 +4140,6 @@ path,
   return { exprs, template: "", declarations: [], dynamics: [], spreadElement: true };
 }
 
-// Wrap the *inner* value of a fragment-child accessor with `_$escape` so that
-// hostile string values returned from reactive accessors cannot be
-// concatenated raw into the SSR output. Element-child expressions already get
-// this treatment via `escapeExpression` in `ssr/element.js`; fragment
-// children reach SSR via a different code path and would otherwise skip the
-// escape step.
-//
-// `expr` is the first entry of `result.exprs` produced by `transformNode`
-// for a `JSXExpressionContainer`. It is either:
-//   - an arrow function `() => X` (default case)
-//   - a bare callee (`fnRef`, emitted when the expression is `fnRef()` with
-//     no args — see the JSXExpressionContainer branch in shared/transform.js)
-//   - the result of `transformCondition(..., inline=true)`, which also
-//     returns an arrow function
-// For arrows with an expression body we rewrite in place; for anything else
-// we conservatively wrap in a new arrow that calls and escapes.
-function wrapFragmentChildWithEscape(path, expr) {
-  const escape = registerImportMethod(path, "escape", undefined);
-  if (t__namespace.isArrowFunctionExpression(expr) && !t__namespace.isBlockStatement(expr.body)) {
-    expr.body = t__namespace.callExpression(escape, [expr.body]);
-    return expr;
-  }
-  return t__namespace.arrowFunctionExpression([], t__namespace.callExpression(escape, [t__namespace.callExpression(expr, [])]));
-}
-
 function createTemplate$1(
 path,
 result,
@@ -4171,19 +4147,16 @@ wrap)
 {
   if (!result.template) {
     // `wrap` is true for fragment children and for mixed component children.
-    // A sole component child (`wrap === false`) is a value passed to the
-    // callee — do not `_$escape` it here; the callee's insert/SSR sites
-    // escape when interpolating into HTML. Escaping both layers double-escapes.
+    // Both are VALUES — they flow to whatever hole eventually inserts them,
+    // and that hole's `_$escape` covers everything reachable from the value:
+    // strings, array items, and what a function (this memo) yields when the
+    // resolver calls it. Escaping here as well double-escapes through
+    // `<Comp>{props.children}</Comp>`. The memo exists for hydration-id
+    // alignment with the client, not for escaping.
     if (wrap && result.dynamic && getConfig(path).memoWrapper) {
-      // wontEscape is set on JSXElement children whose compiled form is
-      // already a safe SSR node (e.g. `_$ssr(...)` call). Wrapping those in
-      // escape would be a no-op at runtime but obscures intent — skip it.
-      const inner = result.wontEscape ?
-      result.exprs[0] :
-      wrapFragmentChildWithEscape(path, result.exprs[0]);
       return t__namespace.callExpression(
         registerImportMethod(path, getConfig(path).memoWrapper, undefined),
-        [inner]
+        [result.exprs[0]]
       );
     }
     return result.exprs[0];
@@ -4694,7 +4667,6 @@ attributes,
   const filteredAttributes = [];
   const spreadArgs = [];
   let runningObject = [];
-  let dynamicSpread = false;
   let firstSpread = false;
   attributes.forEach((attribute) => {
     const node = attribute.node;
@@ -4712,7 +4684,7 @@ attributes,
       spreadArgs.push(
         isDynamic(attribute.get("argument"), {
           checkMember: true
-        }) && (dynamicSpread = true) ?
+        }) ?
         t__namespace.isCallExpression(node.argument) &&
         !node.argument.arguments.length &&
         !t__namespace.isCallExpression(node.argument.callee) &&
@@ -4750,7 +4722,7 @@ attributes,
             id,
             [],
             t__namespace.blockStatement([t__namespace.returnStatement(expr.body)]),
-            !t__namespace.isValidIdentifier(key)
+            false // never computed; see shared/component.ts (#3511)
           )
         );
       } else {
@@ -4770,10 +4742,13 @@ attributes,
     spreadArgs.push(t__namespace.objectExpression(runningObject));
   }
 
-  const props =
-  spreadArgs.length === 1 && !dynamicSpread ?
-  spreadArgs[0] :
-  t__namespace.callExpression(registerImportMethod(path, "mergeProps"), spreadArgs);
+  // A lone spread — reactive included — passes straight through: the
+  // renderer's spread() resolves a function source inside its own tracking
+  // scopes. Several sources go as an ARRAY, not a mergeProps() call: spread()
+  // reads the sources directly (later wins per key, only the winner read)
+  // with no merge proxy to build and walk, and a reactive source is called
+  // inline with no memo. Same contract as the dom generate.
+  const props = spreadArgs.length === 1 ? spreadArgs[0] : t__namespace.arrayExpression(spreadArgs);
 
   return [
   filteredAttributes,
@@ -4940,11 +4915,24 @@ node)
   return t__namespace.stringLiteral(`${node.namespace.name}:${node.name.name}`);
 }
 
+/**
+ * The tag as written in source (`Home`, `Ui.Button`, `this.Row`) — the label
+ * `componentNames` emits. Read before `convertComponentIdentifier` since that
+ * retypes the JSX identifier nodes in place.
+ */
+function jsxTagName(node) {
+  if (t__namespace.isJSXIdentifier(node)) return thisTagIdentifiers.has(node) ? "this" : node.name;
+  if (t__namespace.isJSXMemberExpression(node))
+  return `${jsxTagName(node.object)}.${jsxTagName(node.property)}`;
+  return `${node.namespace.name}:${node.name.name}`;
+}
+
 function transformComponent(
 path)
 {
   let exprs = [],
     config = getConfig(path),
+    tagName = jsxTagName(path.node.openingElement.name),
     tagId = convertComponentIdentifier(path.node.openingElement.name),
     props = [],
     runningObject = [],
@@ -5152,13 +5140,19 @@ path)
           {
             const expr = transformCondition(attribute.get("value").get("expression"), true);
 
+            // Getter keys are never computed: `id` is an identifier or a
+            // string literal (`get "aria-label"()`), the same property as
+            // `get ["aria-label"]()` but on V8's object-literal boilerplate
+            // path — a computed key drops the whole literal to per-property
+            // runtime definition (#3511). Same at every getter site below
+            // and in dom/ssr/universal element.ts.
             runningObject.push(
               t__namespace.objectMethod(
                 "get",
                 id,
                 [],
                 t__namespace.blockStatement([t__namespace.returnStatement(expr.body)]),
-                !t__namespace.isValidIdentifier(key)
+                false
               )
             );
           } else if (
@@ -5171,7 +5165,7 @@ path)
             callee.body :
             t__namespace.blockStatement([t__namespace.returnStatement(callee.body)]);
 
-            runningObject.push(t__namespace.objectMethod("get", id, [], body, !t__namespace.isValidIdentifier(key)));
+            runningObject.push(t__namespace.objectMethod("get", id, [], body, false));
           } else {
             runningObject.push(
               t__namespace.objectMethod(
@@ -5179,7 +5173,7 @@ path)
                 id,
                 [],
                 t__namespace.blockStatement([t__namespace.returnStatement(value.expression)]),
-                !t__namespace.isValidIdentifier(key)
+                false
               )
             );
           }
@@ -5213,13 +5207,29 @@ path)
     props = [t__namespace.callExpression(registerImportMethod(path, "mergeProps"), props)];
   }
   const componentArgs = [tagId, props[0]];
-  // SSR's `createComponent` is literally `Comp(props || {})`. Since the
+  // `componentNames` carries the source tag name into the call so the
+  // dev/observe runtimes can label the owner after minification renames the
+  // function — on the client (`createComponent` in solid-js's client entry)
+  // and on the server (its server entry's, which runs the body under a
+  // transparent `<Name>` owner in observe/dev so a server finding's
+  // `ownerPath` reads like the client's). Not for the universal renderer,
+  // whose `createComponent` is user code with a two-argument contract, nor
+  // the dynamic renderer's subtrees.
+  const labelled =
+  config.componentNames && (config.generate === "dom" || config.generate === "ssr");
+  if (labelled) {
+    componentArgs.push(t__namespace.stringLiteral(tagName));
+  }
+  // SSR's prod `createComponent` is literally `Comp(props || {})`. Since the
   // compiler always emits a real `props[0]` object expression above (see the
   // `props.push(t.objectExpression(runningObject))` line), the `|| {}` fallback
   // never fires in compiled output. Inline to a direct `Comp(props)` call to
   // drop one function-call frame per component invocation. (DOM/dev modes
   // keep the wrapper since it does real work — `untrack`, dev metadata.)
-  if (getConfig(path).generate === "ssr") {
+  // With `componentNames` the wrapper IS the work — the label has nowhere
+  // else to go — so SSR output keeps the call; the vite-plugin turns the
+  // option on for dev and observe builds only, so prod output stays inlined.
+  if (config.generate === "ssr" && !labelled) {
     exprs.push(t__namespace.callExpression(tagId, [props[0]]));
   } else {
     exprs.push(t__namespace.callExpression(registerImportMethod(path, "createComponent"), componentArgs));
@@ -5411,6 +5421,13 @@ function getTargetFunctionParent(path, parent) {
   return current;
 }
 
+/**
+ * JSX tag identifiers `transformThis` rewrote from `this` to the `_self$`
+ * capture, so `componentNames` can label `<this.Row />` by its source text
+ * rather than the generated uid.
+ */
+const thisTagIdentifiers = new WeakSet();
+
 function transformThis(path) {
   const parent = path.scope.getFunctionParent();
   let thisId, inserted;
@@ -5431,7 +5448,9 @@ function transformThis(path) {
         const current = getTargetFunctionParent(path, parent);
         if (current === parent) {
           thisId || (thisId = path.scope.generateUidIdentifier("self$"));
-          source.replaceWith(t__namespace.jsxIdentifier(thisId.name));
+          const selfTag = t__namespace.jsxIdentifier(thisId.name);
+          thisTagIdentifiers.add(selfTag);
+          source.replaceWith(selfTag);
 
           if (path.node.closingElement) {
             path.node.closingElement.name = path.node.openingElement.name;
@@ -14264,6 +14283,7 @@ const config = {
   generate: "dom",
   hydratable: false,
   dev: false,
+  componentNames: false,
   delegateEvents: true,
   delegatedEvents: [],
   builtIns: [
@@ -14324,9 +14344,8 @@ var preprocess = (path, state) => {
 /**
  * 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
+ * Walks the ESTree AST produced by `@tsrx/core` 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`.
@@ -14339,14 +14358,17 @@ var preprocess = (path, state) => {
  *   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.
+ *   `@empty` becomes `fallback`. The bindings pass through as authored:
+ *   `For` hands the callback an item accessor in custom-key and non-keyed
+ *   modes (and an index accessor only with a custom key), and the author
+ *   reads it as `x()` exactly as in JSX. Destructuring `x` where it is an
+ *   accessor is rejected (#3474).
  * - `@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.
+ *   …}><Loading fallback={pending}>{content}</Loading></Errored>`; `Errored`
+ *   passes an `ErrorAccessor`, which the author reads as `e()`. Destructuring
+ *   `e` is rejected.
  * - `<{expr}>` — `<Dynamic component={expr} …>` (deliberate adaptation from
  *   `@tsrx/solid`'s hoisted `dynamic()` factory; semantically equivalent).
  *
@@ -14400,7 +14422,7 @@ const VALID_JSX_CHILD_TYPES = new Set([
 "JSXSpreadChild"]
 );
 
-const FUNCTION_TYPES$1 = new Set([
+const FUNCTION_TYPES = new Set([
 "FunctionDeclaration",
 "FunctionExpression",
 "ArrowFunctionExpression"]
@@ -14419,11 +14441,21 @@ function fail$2(message, node) {
   throw new SyntaxError(start ? `${message} (${start.line}:${start.column})` : message);
 }
 
+/** Diagnostic for a destructured `@for` item where Solid passes an accessor.
+ * Shared text with the Oxc frontend (`tsrx/semantic.rs`). */
+const FOR_ACCESSOR_DESTRUCTURING_MESSAGE =
+"A destructured `@for` item binding is not supported together with `index` or `key`: Solid passes the item as an accessor. Bind a name and read it as a call (`item().name`)";
+
+/** Diagnostic for a destructured `@catch` error binding. Shared text with the
+ * Oxc frontend (`tsrx/semantic.rs`). */
+const CATCH_ACCESSOR_DESTRUCTURING_MESSAGE =
+"A destructured `@catch` error binding is not supported: Solid passes the error as an accessor. Bind a name and read it as a call (`err().message`)";
+
 // ---------------------------------------------------------------------------
 // ESTree builders (converted to Babel shapes later by estree-to-babel)
 // ---------------------------------------------------------------------------
 
-function withLoc$2(node, src) {
+function withLoc$1(node, src) {
   if (src) {
     if (src.start !== undefined) node.start = src.start;
     if (src.end !== undefined) node.end = src.end;
@@ -14432,20 +14464,20 @@ function withLoc$2(node, src) {
   return node;
 }
 
-function ident$1(name, src) {
-  return withLoc$2({ type: "Identifier", name }, src);
+function ident(name, src) {
+  return withLoc$1({ type: "Identifier", name }, src);
 }
 
 function jsxIdent(name, src) {
-  return withLoc$2({ type: "JSXIdentifier", name }, src);
+  return withLoc$1({ type: "JSXIdentifier", name }, src);
 }
 
 function jsxContainer(expression, src) {
-  return withLoc$2({ type: "JSXExpressionContainer", expression }, src ?? expression);
+  return withLoc$1({ type: "JSXExpressionContainer", expression }, src ?? expression);
 }
 
 function jsxAttr(name, expression, src) {
-  return withLoc$2(
+  return withLoc$1(
     {
       type: "JSXAttribute",
       name: jsxIdent(name, src),
@@ -14457,16 +14489,16 @@ function jsxAttr(name, expression, src) {
 
 function jsxElement(name, attributes, children, src) {
   const selfClosing = children.length === 0;
-  return withLoc$2(
+  return withLoc$1(
     {
       type: "JSXElement",
-      openingElement: withLoc$2(
+      openingElement: withLoc$1(
         { type: "JSXOpeningElement", name: jsxIdent(name, src), attributes, selfClosing },
         src
       ),
       closingElement: selfClosing ?
       null :
-      withLoc$2({ type: "JSXClosingElement", name: jsxIdent(name, src) }, src),
+      withLoc$1({ type: "JSXClosingElement", name: jsxIdent(name, src) }, src),
       children
     },
     src
@@ -14474,11 +14506,11 @@ function jsxElement(name, attributes, children, src) {
 }
 
 function jsxFragment(children, src) {
-  return withLoc$2(
+  return withLoc$1(
     {
       type: "JSXFragment",
-      openingFragment: withLoc$2({ type: "JSXOpeningFragment" }, src),
-      closingFragment: withLoc$2({ type: "JSXClosingFragment" }, src),
+      openingFragment: withLoc$1({ type: "JSXOpeningFragment" }, src),
+      closingFragment: withLoc$1({ type: "JSXClosingFragment" }, src),
       children
     },
     src
@@ -14486,7 +14518,7 @@ function jsxFragment(children, src) {
 }
 
 function arrow(params, body, src) {
-  return withLoc$2(
+  return withLoc$1(
     {
       type: "ArrowFunctionExpression",
       id: null,
@@ -14501,15 +14533,15 @@ function arrow(params, body, src) {
 }
 
 function blockStatement(body, src) {
-  return withLoc$2({ type: "BlockStatement", body }, src);
+  return withLoc$1({ type: "BlockStatement", body }, src);
 }
 
 function returnStatement(argument, src) {
-  return withLoc$2({ type: "ReturnStatement", argument }, src);
+  return withLoc$1({ type: "ReturnStatement", argument }, src);
 }
 
 function iife(statements, src) {
-  return withLoc$2(
+  return withLoc$1(
     {
       type: "CallExpression",
       callee: arrow([], blockStatement(statements, src), src),
@@ -14520,58 +14552,26 @@ function iife(statements, 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);
+  return withLoc$1({ type: "BinaryExpression", operator: "===", left, right }, src);
 }
 
 function stringLiteral(value, src) {
-  return withLoc$2({ type: "Literal", value, raw: JSON.stringify(value) }, src);
+  return withLoc$1({ type: "Literal", value, raw: JSON.stringify(value) }, src);
 }
 
-function cloneNode$1(value) {
-  if (Array.isArray(value)) return value.map(cloneNode$1);
+function cloneNode(value) {
+  if (Array.isArray(value)) return value.map(cloneNode);
   if (typeof value === "object" && value !== null) {
     const out = {};
     for (const key of Object.keys(value)) {
-      out[key] = cloneNode$1(value[key]);
+      out[key] = cloneNode(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
 // ---------------------------------------------------------------------------
@@ -14582,7 +14582,7 @@ function desugarProgram(program) {
 }
 
 /** Desugars `node`, returning its replacement for expression-shaped slots. */
-function transform$1(node) {
+function transform(node) {
   switch (node.type) {
     case "JSXCodeBlock":
       return codeBlockToExpression(node);
@@ -14602,7 +14602,7 @@ function transform$1(node) {
       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") {
+      if (FUNCTION_TYPES.has(node.type) && isNode$3(node.body) && node.body.type === "JSXCodeBlock") {
         const body = node.body;
         genericVisit(node, "body");
         node.body = codeBlockToFunctionBody(body);
@@ -14620,10 +14620,10 @@ function genericVisit(node, skipKey) {
     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]);
+        if (isNode$3(value[i])) value[i] = transform(value[i]);
       }
     } else if (isNode$3(value)) {
-      node[key] = transform$1(value);
+      node[key] = transform(value);
     }
   }
 }
@@ -14652,7 +14652,7 @@ function desugarElement(el) {
 
 function desugarChildren(children) {
   return children.map((child) => {
-    const result = transform$1(child);
+    const result = transform(child);
     if (!VALID_JSX_CHILD_TYPES.has(result.type)) return jsxContainer(result, child);
     return result;
   });
@@ -14720,7 +14720,7 @@ 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;
+    if (FUNCTION_TYPES.has(node.type) || ESCAPE_BOUNDARY_TYPES.has(node.type)) return;
     switch (node.type) {
       case "ReturnStatement":
         fail$2(escapeMessage("return", construct), node);
@@ -14787,14 +14787,14 @@ function blockToParts(entries, construct) {
       if (renders.length > 0) {
         fail$2("Statements may not follow the rendered output inside a TSRX template block", entry);
       }
-      setup.push(transform$1(entry));
+      setup.push(transform(entry));
     }
   }
   return { setup, renders };
 }
 
 function renderNodeToExpression(node) {
-  const result = transform$1(node);
+  const result = transform(node);
   if (result.type === "JSXText") return stringLiteral(String(result.value), result);
   return result;
 }
@@ -14806,7 +14806,7 @@ function rendersToExpression(renders, src) {
   if (renders.length === 1) return renderNodeToExpression(renders[0]);
   return jsxFragment(
     renders.map((render) => {
-      const result = transform$1(render);
+      const result = transform(render);
       if (!VALID_JSX_CHILD_TYPES.has(result.type)) return jsxContainer(result, render);
       return result;
     }),
@@ -14831,7 +14831,7 @@ function blockToExpression(blockNode, context) {
 // ---------------------------------------------------------------------------
 
 function codeBlockToExpression(cb) {
-  const setup = cb.body.map(transform$1);
+  const setup = cb.body.map(transform);
   if (!isNode$3(cb.render)) {
     fail$2("A TSRX statement container is missing its rendered output node", cb);
   }
@@ -14841,7 +14841,7 @@ function codeBlockToExpression(cb) {
 }
 
 function codeBlockToFunctionBody(cb) {
-  const setup = cb.body.map(transform$1);
+  const setup = cb.body.map(transform);
   if (!isNode$3(cb.render)) {
     fail$2("A TSRX statement container is missing its rendered output node", cb);
   }
@@ -14859,7 +14859,7 @@ function ifToJsx(node) {
   let elseBlock = null;
   for (;;) {
     branches.push({
-      test: transform$1(current.test),
+      test: transform(current.test),
       block: current.consequent,
       src: current
     });
@@ -14913,7 +14913,7 @@ function forToJsx(node) {
   const left = node.left;
   const pattern =
   left.type === "VariableDeclaration" ? left.declarations[0].id : left;
-  const each = transform$1(node.right);
+  const each = transform(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;
@@ -14931,25 +14931,22 @@ function forToJsx(node) {
   ) :
   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];
+  // The callback bindings pass through as authored (#3474): where `For` hands
+  // the callback an accessor (the item in every non-default mode, the index
+  // under a custom key), the author reads it as one — `item()`, `i()` — exactly
+  // as in JSX. Destructuring an accessor has nothing to destructure.
+  if (itemIsAccessor && pattern.type !== "Identifier") {
+    fail$2(FOR_ACCESSOR_DESTRUCTURING_MESSAGE, pattern);
+  }
+  const params = [pattern];
   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));
+    attributes.push(jsxAttr("keyed", arrow([cloneNode(pattern)], transform(key), key), key));
   } else if (usesIndexOnlyMode) {
     attributes.push(
-      jsxAttr("keyed", withLoc$2({ type: "Literal", value: false, raw: "false" }, index), index)
+      jsxAttr("keyed", withLoc$1({ type: "Literal", value: false, raw: "false" }, index), index)
     );
   }
   if (isNode$3(node.empty)) {
@@ -14970,7 +14967,7 @@ function forToJsx(node) {
 // ---------------------------------------------------------------------------
 
 function switchToJsx(node) {
-  const discriminant = transform$1(node.discriminant);
+  const discriminant = transform(node.discriminant);
   const matches = [];
   let fallbackExpr = null;
   let fallbackSrc = null;
@@ -14998,8 +14995,8 @@ function switchToJsx(node) {
       fallbackSrc = switchCase;
     } else {
       const when = strictEquals(
-        cloneNode$1(discriminant),
-        transform$1(switchCase.test),
+        cloneNode(discriminant),
+        transform(switchCase.test),
         switchCase
       );
       matches.push(
@@ -15040,30 +15037,23 @@ function tryToJsx(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
-      );
+    // `Errored` passes an `ErrorAccessor`; the binding passes through as
+    // authored and the author reads it as `err()` (#3474).
+    if (param && (param.type === "ObjectPattern" || param.type === "ArrayPattern")) {
+      fail$2(CATCH_ACCESSOR_DESTRUCTURING_MESSAGE, param);
+    }
+    if (param && param.type !== "Identifier") {
+      fail$2("The @catch error binding must be an identifier", 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)];
 
+    const params = [ident(errorName, param)];
     if (resetParam)
-    params.push(ident$1(resetParam.name, resetParam));
+    params.push(ident(resetParam.name, resetParam));
 
     result = jsxElement(
       "Errored",
@@ -15076,184 +15066,6 @@ function tryToJsx(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.
@@ -15605,63 +15417,16 @@ function toBabelFile(program) {
 }
 
 /**
- * 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`.
+ * Authored lazy destructuring (`&{ … }` / `&[ … ]`) is not part of the Solid
+ * TSRX target. TSRX removed the sigil from the language, and Solid never
+ * lowered it: a binding that reads like a value but compiles to a property
+ * read is the hazard Solid keeps explicit with accessor calls. Parsers that
+ * still produce the pattern are rejected here, before any desugaring, so the
+ * failure is one clear message rather than a downstream type error.
  */
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-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",
@@ -15682,86 +15447,6 @@ function isNode$1(value) {
 
 }
 
-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);
@@ -15770,11 +15455,7 @@ function fail(message, node) {
 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.
- */
+/** Reject parser-authored `&{}` / `&[]` anywhere in the module. */
 function rejectAuthoredLazyDestructuring(root) {
   const visit = (value) => {
     if (Array.isArray(value)) {
@@ -15792,1468 +15473,38 @@ function rejectAuthoredLazyDestructuring(root) {
   visit(root);
 }
 
-class LazyState {
-  names = new Set();
-  next = new Map();
-  programTemps = [];
-  tempScopes = [this.programTemps];
-
+const SKIP_KEYS = new Set([
+"type",
+"loc",
+"start",
+"end",
+"range",
+"metadata",
+"css",
+"leadingComments",
+"trailingComments",
+"innerComments"]
+);
 
-  usesArrayRest = false;
-  topLevelGlobalThisBinding = false;
+const FUNCTION_BOUNDARIES = new Set([
+"FunctionDeclaration",
+"FunctionExpression",
+"ArrowFunctionExpression",
+"ClassDeclaration",
+"ClassExpression"]
+);
 
-  constructor(root) {
-    this.collectNames(root);
-    this.topLevelGlobalThisBinding = programBindsName(root, "globalThis");
-  }
+function isNode(value) {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof value.type === "string");
 
-  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 isStyleElement(node) {
+  return node.type === "JSXStyleElement";
+}
 
 function isNativeRenderRoot(node) {
   return (
@@ -17664,10 +15915,10 @@ function processTsrxStyles(program, core) {
  *
  * 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.
+ * core's CSS helpers, desugars every TSRX construct to Solid builtIn JSX, and
+ * converts the result to a Babel `File` for the unchanged JSX pipeline.
+ * Bindings pass through as authored; 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.
@@ -17737,18 +15988,9 @@ function parseTsrx(code, filename) {
   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);
+  const file = toBabelFile(program);
   // 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).