octane 0.16.3 → 0.16.4

package/README.md

@@ -21,7 +21,7 @@ To use the compiler in Node, including through the Vite, Rspack, or Rsbuild
 integrations, install its optional parser peer in your project:
 
 ```bash
-pnpm add @tsrx/oxc@0.20.0
+pnpm add @tsrx/oxc@0.23.0
 ```
 
 Applications that use only the Octane runtime do not need this peer.

package/dist/cjs/dom-focused-move.cjs

@@ -19,7 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var dom_focused_move_exports = {};
 __export(dom_focused_move_exports, {
   isChildOf: () => isChildOf,
-  moveNativeNodeBefore: () => moveNativeNodeBefore
+  moveNativeNodeBefore: () => moveNativeNodeBefore,
+  nodeProto: () => nodeProto
 });
 module.exports = __toCommonJS(dom_focused_move_exports);
 function moveNativeNodeBefore(parent, node, anchor, focused, contentEditable) {
@@ -96,5 +97,6 @@ function containsFocus(node, focused) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   isChildOf,
-  moveNativeNodeBefore
+  moveNativeNodeBefore,
+  nodeProto
 });

package/dist/cjs/error-codes.client.generated.cjs

@@ -1128,6 +1128,11 @@ function formatClientError(code, ...args) {
           "This container already has a behavior root; pass replace: true to replace it.",
           args
         );
+      case 362:
+        return (0, import_error_message.formatDevErrorMessage)(
+          "A hook was called outside a component render. If the call is inside a component, the app probably loads more than one copy of Octane, possibly with the same version. Check that the renderer (`createRoot`), the hooks, and `octane/internal/client` all resolve to one installed `octane` package; a custom bundler may need to deduplicate `octane` and its subpaths.",
+          args
+        );
       default:
         return (0, import_error_message.formatUnknownDevErrorMessage)(code);
     }

package/dist/cjs/runtime/drivers.cjs

@@ -100,7 +100,7 @@ module.exports = __toCommonJS(drivers_exports);
 var import_hydration_flag = require("../hydration-flag.cjs");
 var import_event_names = require("../event-names.cjs");
 var import_devtools_hook = require("../devtools-hook.cjs");
-var import_error_message_no_arguments = require("../error-message-no-arguments.cjs");
+var import_error_codes_client_generated = require("../error-codes.client.generated.cjs");
 var import_native_read_client = require("../signals/native-read-client.cjs");
 var import_read_protocol = require("../signals/read-protocol.cjs");
 var import_owner_context = require("../signals/owner-context.cjs");
@@ -232,7 +232,10 @@ function installEffectDrivers() {
   schedulePassiveFlush = import_effects.scheduleRegisteredPassiveFlush;
 }
 let NATIVE_READ_DRIVER = null;
-let resolveSlot = (slot) => slot;
+let resolveSlot = (slot) => {
+  if (__octaneDev && slot !== void 0) (0, import_hooks.checkHookOwner)();
+  return slot;
+};
 let CONTROLLED_RESTORE_DRIVER = null;
 let drainControlledSyncs = noop;
 let publishManualFormPending = noop;
@@ -277,7 +280,7 @@ let reportUncaughtError = () => false;
 let publishInlineCaughtErrorReports = noop;
 let SIGNAL_BINDINGS_ENABLED = false;
 function enableSignalBindings(abi = 1, potentialOnly = false) {
-  if (abi !== 1) throw new TypeError(__octaneDev ? "Unsupported Octane signal binding ABI." : (0, import_error_message_no_arguments.formatNoArgumentErrorMessage)(74));
+  if (abi !== 1) throw new TypeError((0, import_error_codes_client_generated.formatClientError)(74));
   SIGNAL_BINDINGS_ENABLED = true;
   import_owner_context.signalOwnerUse.active = true;
   SIGNAL_CHILD = import_signal_bindings.bindImplicitSignalChild;
@@ -448,7 +451,7 @@ function useEffectEvent(fn, slot) {
   const cell = s;
   return ((...args) => {
     if (import_render.CURRENT_SCOPE !== null && import_engine.EFFECT_EVENT_LIFECYCLE_DEPTH === 0) {
-      throw new Error(__octaneDev ? "A function wrapped in useEffectEvent can't be called during rendering." : (0, import_error_message_no_arguments.formatNoArgumentErrorMessage)(11));
+      throw new Error((0, import_error_codes_client_generated.formatClientError)(11));
     }
     EFFECT_EVENT_INVOCATION_DEPTH++;
     try {

package/dist/cjs/runtime/effects.cjs

@@ -41,6 +41,7 @@ __export(effects_exports, {
   nativeEffectPublicationCurrent: () => nativeEffectPublicationCurrent,
   passiveScheduled: () => passiveScheduled,
   pendingPassiveUnmounts: () => pendingPassiveUnmounts,
+  postOrderHostRefs: () => postOrderHostRefs,
   releaseDeferredPassives: () => releaseDeferredPassives,
   renderWritesForbidden: () => renderWritesForbidden,
   restoreDeferredPassives: () => restoreDeferredPassives,
@@ -49,6 +50,7 @@ __export(effects_exports, {
 });
 module.exports = __toCommonJS(effects_exports);
 var import_engine = require("./engine.cjs");
+var import_dom_focused_move = require("../dom-focused-move.cjs");
 var import_hydration_flag = require("../hydration-flag.cjs");
 var import_profiling = require("../profiling.cjs");
 var import_drivers = require("./drivers.cjs");
@@ -169,6 +171,25 @@ function compareEffectPostOrder(a, b) {
 function compareRefPostOrder(a, b) {
   return comparePostOrder(a.block, 0, b.block, 0);
 }
+function postOrderHostRefs(q) {
+  for (let i = 1; i < q.length; i++) {
+    const entry = q[i];
+    let j = i;
+    while (j > 0 && q[j - 1].block === entry.block && compareHostRefs(q[j - 1], entry) > 0) {
+      q[j] = q[j - 1];
+      j--;
+    }
+    q[j] = entry;
+  }
+}
+function compareHostRefs(a, b) {
+  const from = refPosition(a);
+  const position = (0, import_dom_focused_move.nodeProto)(from).compareDocumentPosition.call(from, refPosition(b));
+  return position & 16 || (position & 10) === 2 ? 1 : position === 0 ? 0 : -1;
+}
+function refPosition(entry) {
+  return entry.el._startMarker ?? entry.el;
+}
 function fireEffectCleanup(e) {
   const slot = e.scope.hooks?.get(e.slot);
   if (slot === void 0 || slot.revision !== e.revision) return;
@@ -369,6 +390,7 @@ function schedulePostPaint(cb) {
   nativeEffectPublicationCurrent,
   passiveScheduled,
   pendingPassiveUnmounts,
+  postOrderHostRefs,
   releaseDeferredPassives,
   renderWritesForbidden,
   restoreDeferredPassives,

package/dist/cjs/runtime/engine.cjs

@@ -126,6 +126,7 @@ __export(engine_exports, {
   retireRendererSignalOwner: () => retireRendererSignalOwner,
   retireRootBlock: () => retireRootBlock,
   retiringHostsSince: () => retiringHostsSince,
+  retryRootRequest: () => retryRootRequest,
   retryTransitionBatch: () => retryTransitionBatch,
   retryTransitionHolder: () => retryTransitionHolder,
   rollbackRootRender: () => rollbackRootRender,
@@ -145,6 +146,7 @@ __export(engine_exports, {
   setIsOctaneActEnvironment: () => setIsOctaneActEnvironment,
   settleTransitionFalls: () => settleTransitionFalls,
   spawnDeferredSwap: () => spawnDeferredSwap,
+  suspendingTransitionHold: () => suspendingTransitionHold,
   syncFlush: () => syncFlush,
   tickTransitionCount: () => tickTransitionCount,
   undoCreatedInRootRender: () => undoCreatedInRootRender,
@@ -383,20 +385,41 @@ let TRANSITION_PENDING_COUNT = 0;
 let TRANSITION_HOLDERS = null;
 let WOKEN_TRANSITION_HOLDERS = null;
 let RETRIED_TRANSITION_BATCHES = null;
-function holdTransitionBatch(holder, batch) {
+let RETRIED_ROOT_REQUESTS = null;
+function suspendingTransitionHold(holder) {
   const holders = TRANSITION_HOLDERS ??= /* @__PURE__ */ new Map();
   let hold = holders.get(holder);
-  if (hold === void 0) holders.set(holder, hold = { batches: /* @__PURE__ */ new Set(), suspends: true });
+  if (hold === void 0)
+    holders.set(holder, hold = { batches: /* @__PURE__ */ new Set(), suspends: true, request: -1 });
   else if (!hold.suspends) {
     hold.suspends = true;
     for (const held of hold.batches) held.suspended++;
   }
+  return hold;
+}
+function holdTransitionBatch(holder, batch) {
+  const hold = suspendingTransitionHold(holder);
   if (hold.batches.has(batch)) return;
   hold.batches.add(batch);
   batch.pendingHolds = (batch.pendingHolds ?? 0) + 1;
   if (hold.suspends) batch.suspended++;
   (0, import_transitions.raiseHeldTransitionBatch)(batch);
 }
+function retryRootRequest(owner, generation) {
+  if (owner.disposed || owner.generation !== generation) return false;
+  if (inFlush || import_render.CURRENT_BLOCK !== null) {
+    (RETRIED_ROOT_REQUESTS ??= []).push(owner, generation);
+    scheduleTransitionTask();
+    return true;
+  }
+  TRANSITION_DEPTH++;
+  try {
+    owner.retry();
+  } finally {
+    TRANSITION_DEPTH--;
+  }
+  return true;
+}
 function retryTransitionBatch(batch, render, fall) {
   if (inFlush || import_render.CURRENT_BLOCK !== null) {
     (RETRIED_TRANSITION_BATCHES ??= []).push(batch, render, fall);
@@ -423,6 +446,13 @@ function unsuspendTransitionHolder(holder) {
       (RETRIED_TRANSITION_BATCHES ??= []).push(batch, true, false);
       scheduleTransitionTask();
     }
+  if (hold.request !== -1) {
+    (RETRIED_ROOT_REQUESTS ??= []).push(
+      holder.parentBlock.idState.renderOwner,
+      hold.request
+    );
+    scheduleTransitionTask();
+  }
 }
 let TRANSITION_HOOK_PUBLISH_DEPTH = 0;
 function scheduleHookPublication(block) {
@@ -552,6 +582,11 @@ function retryWokenTransitions() {
         retried[i + 2]
       );
   }
+  const requests = RETRIED_ROOT_REQUESTS;
+  RETRIED_ROOT_REQUESTS = null;
+  if (requests !== null)
+    for (let i = 0; i < requests.length; i += 2)
+      retryRootRequest(requests[i], requests[i + 1]);
 }
 let COMMITTING_OWNER = null;
 let COMMITTING_GENERATION = 0;
@@ -1259,7 +1294,8 @@ function scheduleTransitionTask() {
     if (transitionTask !== id) return;
     TRANSITION_TASK_ACTIVE = true;
     try {
-      if (WOKEN_TRANSITION_HOLDERS || RETRIED_TRANSITION_BATCHES) retryWokenTransitions();
+      if (WOKEN_TRANSITION_HOLDERS || RETRIED_TRANSITION_BATCHES || RETRIED_ROOT_REQUESTS)
+        retryWokenTransitions();
       adoptTransitionQueue(true);
       flush();
     } finally {
@@ -1276,7 +1312,8 @@ function adoptTransitionQueue(drain) {
     if (drain === true) import_drivers.TRANSITION_ROOT_DRIVER.armFalls();
     else scheduleTransitionTask();
   }
-  if (WOKEN_TRANSITION_HOLDERS || RETRIED_TRANSITION_BATCHES) scheduleTransitionTask();
+  if (WOKEN_TRANSITION_HOLDERS || RETRIED_TRANSITION_BATCHES || RETRIED_ROOT_REQUESTS)
+    scheduleTransitionTask();
 }
 function settleTransitionFalls() {
   const armed = ARMED_TRANSITION_FALLS;
@@ -2288,6 +2325,7 @@ function drainQueuedRefAttaches() {
         break;
       }
     }
+    (0, import_effects.postOrderHostRefs)(q);
   }
   for (const r of q) {
     if ((0, import_refs.blockSubtreeDisposed)(r.block)) continue;
@@ -2965,10 +3003,10 @@ function countLayoutSnapshotChange(cell, block) {
 let DID_WARN_UNCACHED_SNAPSHOT = false;
 function useSyncExternalStore(subscribe, getSnapshot, serverSnapshotOrSlot = void 0, lastSlot) {
   const count = arguments.length;
-  let slot = count > 4 ? arguments[count - 1] : count === 4 ? lastSlot : serverSnapshotOrSlot;
+  const getServerSnapshot = typeof serverSnapshotOrSlot === "function" ? serverSnapshotOrSlot : void 0;
+  let slot = count > 4 ? arguments[count - 1] : count === 4 ? lastSlot : getServerSnapshot ? void 0 : serverSnapshotOrSlot;
   slot = (0, import_drivers.resolveSlot)(slot);
   if (slot === void 0) (0, import_hooks.missingSlot)("useSyncExternalStore");
-  const getServerSnapshot = count >= 4 ? serverSnapshotOrSlot : void 0;
   const subs = (0, import_hooks.usesSubslots)(slot);
   const readSnapshot = import_hydration_flag.hydrating && import_hydration.CURSOR !== null && getServerSnapshot !== void 0 ? getServerSnapshot : getSnapshot;
   const value = readSnapshot();
@@ -3008,7 +3046,10 @@ function useSyncExternalStore(subscribe, getSnapshot, serverSnapshotOrSlot = voi
     (0, import_hooks.ensureHooks)(scope).set(subs.inst, inst);
     (0, import_hooks.enqueueStoreSync)(inst, value, subscribe);
   } else {
-    inst.getSnapshot = getSnapshot;
+    if (inst.getSnapshot !== getSnapshot) {
+      journalRootProperty(inst, "getSnapshot", inst.getSnapshot);
+      inst.getSnapshot = getSnapshot;
+    }
     if (!Object.is(value, inst.value) || subscribe !== inst.subscribe) {
       (0, import_hooks.enqueueStoreSync)(inst, value, subscribe);
     }
@@ -3819,6 +3860,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
   retireRendererSignalOwner,
   retireRootBlock,
   retiringHostsSince,
+  retryRootRequest,
   retryTransitionBatch,
   retryTransitionHolder,
   rollbackRootRender,
@@ -3838,6 +3880,7 @@ function makeRoot(container, rootBlock, currentBody, currentKey, idState, output
   setIsOctaneActEnvironment,
   settleTransitionFalls,
   spawnDeferredSwap,
+  suspendingTransitionHold,
   syncFlush,
   tickTransitionCount,
   undoCreatedInRootRender,

package/dist/cjs/runtime/hooks.cjs

@@ -26,6 +26,7 @@ __export(hooks_exports, {
   adoptMemoEntry: () => adoptMemoEntry,
   callWithReceiver: () => callWithReceiver,
   cancelHiddenRevealAction: () => cancelHiddenRevealAction,
+  checkHookOwner: () => checkHookOwner,
   commitHookCells: () => commitHookCells,
   compilerMemoRegion: () => compilerMemoRegion,
   compilerMemoWitness: () => compilerMemoWitness,
@@ -120,6 +121,9 @@ function hookSlots(count) {
 function missingSlot(name) {
   throw new Error((0, import_error_codes_client_generated.formatClientError)(15, name));
 }
+function checkHookOwner() {
+  if (import_render.CURRENT_SCOPE === null) throw new Error((0, import_error_codes_client_generated.formatClientError)(362));
+}
 const slotStack = [];
 function manualHook(fn, name) {
   function provider() {
@@ -139,6 +143,7 @@ function appendSlotKey(key, slot) {
 }
 function resolveCustomSlot(slot) {
   const n = slotStack.length;
+  if (__octaneDev && (slot !== void 0 || n !== 0)) checkHookOwner();
   if (n === 0) return slot;
   if (slot === void 0 && n === 1) return slotStack[0];
   const resolved = (0, import_hook_slot_cache.resolveHookPath)(slotStack, slot, false);
@@ -911,6 +916,7 @@ function useId(slot) {
   adoptMemoEntry,
   callWithReceiver,
   cancelHiddenRevealAction,
+  checkHookOwner,
   commitHookCells,
   compilerMemoRegion,
   compilerMemoWitness,

package/dist/cjs/runtime/suspense.cjs

@@ -787,9 +787,12 @@ function mountErrorBoundary(state, hydration) {
     return state.block;
   };
   state.block = body;
+  if (freshBoundary) hydration.suspend(() => renderErrorBody(state, body, hydration));
+  else renderErrorBody(state, body, hydration);
+}
+function renderErrorBody(state, body, hydration) {
   try {
-    if (freshBoundary) hydration.suspend(() => hydration.renderTryBody(body, true));
-    else if (hydration !== null) hydration.renderTryBody(body, true);
+    if (hydration !== null) hydration.renderTryBody(body, true);
     else (0, import_signal_owners.renderBlock)(body);
     state.hasResolved = true;
   } catch (error) {
@@ -815,6 +818,8 @@ function switchErrorToCatchInner(state, error, reportInline) {
   const previous = state.block;
   if (previous !== null) {
     state.block = null;
+    const transaction = import_render.ROOT_RENDER_TRANSACTION;
+    if (transaction !== null && !transaction.aborted) dropBodyOps(transaction, previous);
     (0, import_block.unmountBlock)(previous, hydration === null);
     if (state.parentBlock.disposed || state.block !== null) return;
   }

package/dist/cjs/runtime/transitions.cjs

@@ -287,6 +287,8 @@ function releaseTransitionHookHolder(holder, retry = true) {
       if (unblocked || settled) (0, import_engine.retryTransitionBatch)(batch, unblocked, settled);
     } else if (settled) finishTransitionHookBatch(batch);
   }
+  if (hold.request !== -1 && hold.suspends && retry)
+    return (0, import_engine.retryRootRequest)(holder.parentBlock.idState.renderOwner, hold.request) || hold.batches.size !== 0;
   return true;
 }
 const HELD_TRANSITIONS = /* @__PURE__ */ new Set();
@@ -379,12 +381,14 @@ function noteTransitionBatch(transaction, batch) {
 function dropTransitionRender(transaction) {
   const holders = transaction.holders;
   transaction.holders = null;
+  const owner = transaction.owner;
   const origin = import_engine.TRANSITION_ORIGIN;
-  const batches = origin === null ? transaction.batches : transaction.batches?.filter((batch) => batch.origin === origin) ?? null;
-  if (batches === null || batches.length === 0 || transaction.owner.disposed) return false;
+  const batches = (origin === null ? transaction.batches : transaction.batches?.filter((batch) => batch.origin === origin)) ?? [];
+  const request = transaction.rootRequest && origin !== null && origin === owner.current && origin.currentRenderMode === "transition";
+  if (batches.length === 0 && !request || owner.disposed) return false;
   let live = false;
   for (const holder of holders)
-    if (holder.__kind !== "trySlotSlot" || holder.transitionHeld)
+    if (holder.__kind === "trySlotSlot" ? holder.transitionHeld : batches.length !== 0)
       live = true;
   if (!live) return false;
   if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__)
@@ -399,7 +403,11 @@ function dropTransitionRender(transaction) {
   for (const holder of holders) {
     if (holder.__kind === "trySlotSlot") {
       if (!holder.transitionHeld) continue;
-    } else if (import_engine.TRANSITION_HOLDERS?.has(holder) !== true) (0, import_engine.tickTransitionCount)(1);
+      if (request) (0, import_engine.suspendingTransitionHold)(holder).request = owner.generation;
+    } else {
+      if (batches.length === 0) continue;
+      if (import_engine.TRANSITION_HOLDERS?.has(holder) !== true) (0, import_engine.tickTransitionCount)(1);
+    }
     for (const batch of batches) (0, import_engine.holdTransitionBatch)(holder, batch);
   }
   for (const other of import_engine.ROOT_RENDER_TRANSACTIONS)
@@ -425,6 +433,8 @@ function holdsUnrenderedTransition(state) {
   const hold = import_engine.TRANSITION_HOLDERS.get(state);
   if (hold === void 0) return false;
   const transaction = import_render.ROOT_RENDER_TRANSACTION;
+  if (hold.request !== -1 && (transaction === null || !transaction.rootRequest) && state.parentBlock.idState.renderOwner.generation === hold.request)
+    return true;
   for (const batch of hold.batches)
     if (transaction === null || batch.stamp !== transaction.createdStamp) return true;
   return false;

package/dist/cjs/runtime.server.cjs

@@ -4894,8 +4894,7 @@ function useDeferredValue(value, initialValueOrSlot = void 0, _slot) {
 function useSyncExternalStore(_subscribe, getSnapshot, serverSnapshotOrSlot = void 0, _slot) {
   if (SHELL_WITNESS !== null && __octaneDev)
     witnessShellHook("useSyncExternalStore", useSyncExternalStore);
-  const getServerSnapshot = arguments.length >= 4 ? serverSnapshotOrSlot : void 0;
-  return getServerSnapshot ? getServerSnapshot() : getSnapshot();
+  return typeof serverSnapshotOrSlot === "function" ? serverSnapshotOrSlot() : getSnapshot();
 }
 function useActionState(_action, initialState) {
   return [initialState, NOOP, false];

package/dist/cjs/version.cjs

@@ -21,7 +21,7 @@ __export(version_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(version_exports);
-const version = "0.16.3";
+const version = "0.16.4";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version

package/dist/compiler/arm-exits.js

@@ -82,6 +82,50 @@ const LOOP_TYPES = new Set([
 	'DoWhileStatement',
 ]);
 
+/**
+ * Replace each exit that a directive arm's setup owns, anywhere in `ast`, with
+ * `exit(node)`, copy-on-write. Nested functions and `@{ … }` blocks own their
+ * jumps, and a nested directive's arms are arms of their own. The type-only
+ * view uses this; each compiler walks its arms itself.
+ */
+export function mapArmExits(ast, exit) {
+	const visit = (node, arm, loop, breakable) => {
+		if (Array.isArray(node)) {
+			let out = null;
+			for (let i = 0; i < node.length; i++) {
+				const child = node[i];
+				const mapped =
+					child !== null && typeof child === 'object' ? visit(child, arm, loop, breakable) : child;
+				if (out === null && mapped !== child) out = node.slice(0, i);
+				if (out !== null) out.push(mapped);
+			}
+			return out ?? node;
+		}
+		const type = node.type;
+		if (arm && armJump(node, loop, breakable) === 'exit') return exit(node);
+		if (DIRECTIVE_TYPES.has(type)) {
+			arm = true;
+			loop = breakable = false;
+		} else if (FUNCTION_TYPES.has(type) || type === 'JSXCodeBlock') {
+			arm = false;
+		} else if (LOOP_TYPES.has(type)) {
+			loop = breakable = true;
+		} else if (type === 'SwitchStatement') {
+			breakable = true;
+		}
+		let out = null;
+		for (const key in node) {
+			if (WALK_SKIP_KEYS.has(key)) continue;
+			const child = node[key];
+			if (child === null || typeof child !== 'object') continue;
+			const mapped = visit(child, arm, loop, breakable);
+			if (mapped !== child) (out ??= { ...node })[key] = mapped;
+		}
+		return out ?? node;
+	};
+	return visit(ast, false, false, false);
+}
+
 // The template region a statement sits in. Outside every template, jumps are
 // ordinary JavaScript and the parser resolves them.
 const OUTSIDE = 0;
@@ -125,7 +169,10 @@ export function assertTemplateJumps(ast, source, filename) {
 					: region === BLOCK && !(type === 'ContinueStatement' ? loop : breakable);
 			if (leaves) {
 				const at = node.loc ? ` (${file}:${node.loc.start.line}:${node.loc.start.column})` : '';
-				throw new Error((region === BLOCK ? BLOCK_JUMP_MESSAGE : ARM_LABEL_MESSAGE) + at);
+				throw Object.assign(
+					new Error((region === BLOCK ? BLOCK_JUMP_MESSAGE : ARM_LABEL_MESSAGE) + at),
+					{ code: region === BLOCK ? 'OCTANE_BLOCK_JUMP' : 'OCTANE_ARM_LABELED_JUMP' },
+				);
 			}
 			return;
 		}

package/dist/compiler/bare-holes.js

@@ -0,0 +1,84 @@
+/**
+ * A `@{ … }` body and every directive arm hold setup statements, then one
+ * output node: an element, a fragment, a `@{ … }` block, or a directive. In
+ * statement position `{children}` is therefore a JavaScript block around a
+ * dead expression, not a hole, and the body renders nothing in its place. It
+ * reads as a hole, so assertNoBareHoles rejects it once on the authored module,
+ * ahead of every compiler. Braces around one expression statement do nothing
+ * in JavaScript, so setup code never needs this shape. `@case` arms are the
+ * exception: the parser reads a `{` there as a hole, and it renders.
+ */
+
+const BARE_HOLE_MESSAGE =
+	'`{…}` in a `@{ … }` body or directive arm is a JavaScript block, not a hole, so it ' +
+	'renders nothing. Wrap it in a fragment to render it, as in `<>{children}</>`, or ' +
+	'remove the braces to keep it as setup code.';
+
+const WALK_SKIP_KEYS = new Set(['type', 'loc', 'start', 'end', 'range', 'metadata', 'parent']);
+
+/**
+ * Reject the first block statement holding a single expression statement among
+ * the statements of a `@{ … }` body or an `@if`/`@else`, `@for`/`@empty`, or
+ * `@try`/`@pending`/`@catch` arm. Runs once per module, on the authored AST,
+ * for every target.
+ */
+export function assertNoBareHoles(ast, source, filename) {
+	if (!/@(?:\{|(?:if|for|try)\b)/.test(source)) return;
+	const file = filename.split(/[\\/]/).pop();
+	const check = (body) => {
+		if (body == null) return;
+		// An `@else if` chain continues as a plain IfStatement.
+		if (body.type === 'IfStatement') {
+			check(body.consequent);
+			check(body.alternate);
+			return;
+		}
+		// The compilers also accept an arm that is a single node, or an `@else`
+		// that is a JSXIfExpression, which the walk below checks on its own.
+		if (!Array.isArray(body.body)) return;
+		for (const statement of body.body) {
+			if (
+				statement.type === 'BlockStatement' &&
+				statement.body.length === 1 &&
+				statement.body[0].type === 'ExpressionStatement'
+			) {
+				const at = statement.loc
+					? ` (${file}:${statement.loc.start.line}:${statement.loc.start.column})`
+					: '';
+				throw Object.assign(new Error(BARE_HOLE_MESSAGE + at), { code: 'OCTANE_BARE_HOLE' });
+			}
+		}
+	};
+	const visit = (node) => {
+		if (Array.isArray(node)) {
+			for (const child of node) {
+				if (child !== null && typeof child === 'object') visit(child);
+			}
+			return;
+		}
+		switch (node.type) {
+			case 'JSXCodeBlock':
+				check(node);
+				break;
+			case 'JSXIfExpression':
+				check(node.consequent);
+				check(node.alternate);
+				break;
+			case 'JSXForExpression':
+				check(node.body);
+				check(node.empty);
+				break;
+			case 'JSXTryExpression':
+				check(node.block);
+				check(node.pending);
+				check(node.handler?.body);
+				break;
+		}
+		for (const key in node) {
+			if (WALK_SKIP_KEYS.has(key)) continue;
+			const child = node[key];
+			if (child !== null && typeof child === 'object') visit(child);
+		}
+	};
+	visit(ast);
+}

package/dist/compiler/bundler.js

@@ -316,10 +316,10 @@ function normalizeHmrDialect(value) {
 /**
  * Classify direct function exports whose production TSRX body has no renderable
  * JavaScript return. A direct `memo(LocalComponent)` export preserves that
- * contract, as do null-only early-return guards that compile to template
- * control flow. Bundler adapters attach this fact after compiling the exact
- * source they loaded. Re-exports and indirect bindings remain deliberately
- * unknown.
+ * contract, as does a default export of such a binding, and so do null-only
+ * early-return guards that compile to template control flow. Bundler adapters
+ * attach this fact after compiling the exact source they loaded. Re-exports and
+ * indirect bindings remain deliberately unknown.
  */
 export function findVoidComponentExports(source, id) {
 	let ast;
@@ -357,6 +357,17 @@ export function findVoidComponentExports(source, id) {
 		if (declaration) declarations.push(declaration);
 	}
 
+	// The local a direct `memo(Local)` call wraps, or null. The imported memo
+	// identity is lexical proof; method calls, comparators, and arbitrary
+	// wrappers stay unknown.
+	const memoTarget = (node) =>
+		node?.type === 'CallExpression' &&
+		node.callee?.type === 'Identifier' &&
+		memoLocals.has(node.callee.name) &&
+		node.arguments?.length === 1 &&
+		node.arguments[0]?.type === 'Identifier'
+			? node.arguments[0].name
+			: null;
 	const voidBindings = new Set();
 	const memoDependents = new Map();
 	const hasLowerableJsxReturnBranches = createJsxReturnBranchClassifier(ast.body || []);
@@ -375,10 +386,9 @@ export function findVoidComponentExports(source, id) {
 			continue;
 		}
 		if (declaration.type !== 'VariableDeclaration' || declaration.kind !== 'const') continue;
-		// Resolve only the exact, immutable `const Export = memo(Local)` form. The
-		// imported memo identity is lexical proof; method calls, comparators, and
-		// arbitrary wrappers stay unknown. Index the reverse edges once so a chain
-		// declared outermost-first does not rescan every declaration per link.
+		// Resolve only the exact, immutable `const Export = memo(Local)` form.
+		// Index the reverse edges once so a chain declared outermost-first does
+		// not rescan every declaration per link.
 		for (const item of declaration.declarations || []) {
 			const init = item.init;
 			if (
@@ -389,17 +399,9 @@ export function findVoidComponentExports(source, id) {
 			) {
 				voidBindings.add(item.id.name);
 			}
-			if (
-				item.id?.type !== 'Identifier' ||
-				reassigned.has(item.id) ||
-				init?.type !== 'CallExpression' ||
-				init.callee?.type !== 'Identifier' ||
-				!memoLocals.has(init.callee.name) ||
-				init.arguments?.length !== 1 ||
-				init.arguments[0]?.type !== 'Identifier'
-			)
-				continue;
-			const target = init.arguments[0].name;
+			const target =
+				item.id?.type === 'Identifier' && !reassigned.has(item.id) ? memoTarget(init) : null;
+			if (target === null) continue;
 			let dependents = memoDependents.get(target);
 			if (dependents === undefined) memoDependents.set(target, (dependents = []));
 			dependents.push(item.id.name);
@@ -418,12 +420,17 @@ export function findVoidComponentExports(source, id) {
 	for (const node of ast.body || []) {
 		if (node.type === 'ExportDefaultDeclaration') {
 			const declaration = node.declaration;
+			// React's `export default Local` and `export default memo(Local)` export
+			// a local binding's value, so they carry that binding's proof.
 			if (
-				(declaration?.type === 'FunctionDeclaration' ||
+				((declaration?.type === 'FunctionDeclaration' ||
 					declaration?.type === 'FunctionExpression' ||
 					declaration?.type === 'ArrowFunctionExpression') &&
-				(declaration.id == null || !reassigned.has(declaration.id)) &&
-				isVoidFunction(declaration)
+					(declaration.id == null || !reassigned.has(declaration.id)) &&
+					isVoidFunction(declaration)) ||
+				voidBindings.has(
+					declaration?.type === 'Identifier' ? declaration.name : memoTarget(declaration),
+				)
 			) {
 				exports.push('default');
 			}