@solidjs/babel-plugin 2.0.0-rc.3 → 2.0.0-rc.4

package/.turbo/turbo-build.log

@@ -7,4 +7,4 @@ src/shared/transform.ts -> src/ssr/element.ts -> src/shared/transform.ts
 src/shared/transform.ts -> src/universal/element.ts -> src/shared/transform.ts
 src/shared/transform.ts -> src/shared/component.ts -> src/shared/transform.ts
 src/shared/transform.ts -> src/shared/fragment.ts -> src/shared/transform.ts
-created index.js in 2.1s
+created index.js in 2.9s

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @solidjs/babel-plugin
 
+## 2.0.0-rc.4
+
+### Patch Changes
+
+- 8d249c7: Patch-channel contract hardening from the stage-2 re-audit: ordinary `patchDriver` registrations unbind with their owner (entries no longer leak past unmount); merged transitions move their held-patch stash so no patch strands; the optimistic drain shares the normal drain's per-entry error isolation and boundary routing; accessor-bearing records are excluded at admission (scan-before-trust) and records that acquire accessors demote their patches to tracked effect fallbacks; writable projection arrays emit setter row ops at their fold-commit visibility moment; row-ops/slot registrations resolve chained backings to the ultimate owner; duplicate keys match occurrence-aware instead of first-wins; the production dev-token typo (`_DX_DEV_`) is fixed; `patchDriver: true` normalizes identically in Babel and the native loader, the option is typed in `TransformOptions`, and a `dom-patch` parity tier ratchets patch-mode output across both compilers (currently byte-identical on all fixtures).
+- b534733: Scope-wrap bare function children in hydratable mode. A function child (`<main>{() => <App/>}</main>`, including via the `children` attribute) is a deferred hole at runtime, but it never classified as `dynamic`, so neither generate reserved an id scope for it — its owner ids drifted across async retry passes on the server and desynced from the client (the #2900 hydration-id-parity class). Both compilers now treat syntactic function expressions as scope-eligible alongside dynamic values, emitting `_$scope(...)` in the ssr generate and around the matching insert accessor in the dom generate. The native compiler also unwraps TS casts in the allocate-ids predicate, matching Babel (fixes a scope-emission desync for `{call() as any}` children).
+
 ## 2.0.0-rc.3
 
 ### Minor Changes

package/index.js

@@ -478,6 +478,9 @@ function canReturnHydratableChild(node) {
   if (t__namespace.isTSNonNullExpression(node) || t__namespace.isTSAsExpression(node) || t__namespace.isTSSatisfiesExpression(node))
   return canReturnHydratableChild(node.expression);
   if (t__namespace.isJSXElement(node) || t__namespace.isJSXFragment(node) || t__namespace.isCallExpression(node)) return true;
+  // A function child is a deferred hole: whatever it returns renders inside
+  // the hole, so it can always mint hydratable content.
+  if (t__namespace.isFunction(node)) return true;
   if (t__namespace.isMemberExpression(node) || t__namespace.isOptionalMemberExpression(node)) {
     return !node.computed && t__namespace.isIdentifier(node.property, { name: "children" });
   }
@@ -493,6 +496,23 @@ function canChildSlotAllocateIds(node) {
   return node.isJSXExpressionContainer() && canReturnHydratableChild(node.node.expression);
 }
 
+// A syntactic function-expression hole (`{() => ...}` / `{function () {}}`,
+// TS casts unwrapped). Function children never classify as `dynamic` — the
+// literal reads nothing at template time — yet at runtime they are deferred
+// holes exactly like call-shaped values, so the scope gates treat them as
+// scope-eligible alongside `dynamic` (solidjs/solid#3068 follow-up).
+function isFunctionShapedHole(node) {
+  if (!node.isJSXExpressionContainer()) return false;
+  let expression = node.node.expression;
+  while (
+  t__namespace.isTSNonNullExpression(expression) ||
+  t__namespace.isTSAsExpression(expression) ||
+  t__namespace.isTSSatisfiesExpression(expression))
+
+  expression = expression.expression;
+  return t__namespace.isFunction(expression);
+}
+
 function wrappedByText(list, startIndex) {
   let index = startIndex,
     wrapped;
@@ -2408,6 +2428,8 @@ config)
         if (!transformed) return memo;
         transformed.allocatesIds =
         config.hydratable && canChildSlotAllocateIds(child);
+        transformed.functionHole =
+        isFunctionShapedHole(child);
         const i = memo.length;
         if (transformed.text && i && memo[i - 1].text) {
           memo[i - 1].template =
@@ -2493,7 +2515,12 @@ config)
       // allocate hydration ids get their own owner scope (insert makes the
       // outer render effect non-transparent for tagged accessors). Keyed off
       // `dynamic` so both generates decide identically for the same source.
-      if (child.allocatesIds && child.dynamic) {
+      // Function children never classify as dynamic but are deferred holes
+      // all the same, so they take the scope too.
+      if (
+      child.allocatesIds && (
+      child.dynamic || child.functionHole))
+      {
         let expr = child.exprs[0];
         // The shared transform simplifies `{sig()}` to the bare getter `sig`;
         // rewrap so tagging the scope doesn't mutate the user's function.
@@ -4270,9 +4297,11 @@ results,
       // Deferred holes that can allocate hydration ids evaluate under their
       // own owner scope so retry timing can't skew sibling ids (mirrors the
       // dom generate's `scope()` wrap around the matching insert accessor).
-      // Keyed off `dynamic` so both generates decide identically.
+      // Keyed off `dynamic` so both generates decide identically. Function
+      // children never classify as dynamic but are deferred holes all the
+      // same, so they take the scope too.
       let expr = child.exprs[0];
-      if (allocatesIds && child.dynamic) {
+      if (allocatesIds && (child.dynamic || isFunctionShapedHole(node))) {
         expr = t.callExpression(registerImportMethod(path, "scope"), [expr]);
       }
 
@@ -4326,7 +4355,7 @@ path,
         // dom generate scope()s the matching insert accessor regardless of
         // spread, so skipping it here desyncs every hydration id that follows
         // the hole.
-        if (child.exprs.length && allocatesIds && child.dynamic) {
+        if (child.exprs.length && allocatesIds && (child.dynamic || isFunctionShapedHole(path))) {
           child.exprs[0] = t.callExpression(registerImportMethod(path, "scope"), [
           child.exprs[0]]
           );
@@ -14526,6 +14555,9 @@ const config = {
 var preprocess = (path, state) => {
   const file = path.hub.file;
   const merged = file.metadata.config = Object.assign({}, config, state.opts);
+  // Boolean opt-in parity with the native loader: `patchDriver: true` means
+  // the default import name (downstream code uses the value AS the name).
+  if (merged.patchDriver === true) merged.patchDriver = "patchDriver";
   const lib = merged.requireImportSource;
   if (lib) {
     const comments = file.ast.comments ?? [];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@solidjs/babel-plugin",
   "description": "Babel compiler plugin for Solid templates",
-  "version": "2.0.0-rc.3",
+  "version": "2.0.0-rc.4",
   "author": "Ryan Carniato",
   "license": "MIT",
   "repository": {