octane 0.1.50 → 0.1.51

package/dist/cjs/runtime.cjs

@@ -4238,29 +4238,53 @@ function __useStateWithGetter(initial, slot) {
 let HIDDEN_REVEAL_ACTIONS = null;
 function deferHiddenRevealAction(boundary, action) {
   const deferred = HIDDEN_REVEAL_ACTIONS ??= /* @__PURE__ */ new WeakMap();
-  const actions = deferred.get(boundary);
-  if (actions === void 0) deferred.set(boundary, [action]);
-  else actions.push(action);
+  let queue = deferred.get(boundary);
+  if (queue === void 0) {
+    queue = { entries: [], live: 0 };
+    deferred.set(boundary, queue);
+  }
+  const entry = { action, active: true, queue };
+  queue.entries.push(entry);
+  queue.live++;
+  return entry;
+}
+function claimHiddenRevealAction(boundary, entry) {
+  const queue = entry.queue;
+  if (HIDDEN_REVEAL_ACTIONS?.get(boundary) !== queue) return null;
+  if (!entry.active) return null;
+  entry.active = false;
+  if (--queue.live === 0) HIDDEN_REVEAL_ACTIONS.delete(boundary);
+  return entry.action;
+}
+function cancelHiddenRevealAction(boundary, entry) {
+  const queue = entry.queue;
+  if (claimHiddenRevealAction(boundary, entry) === null || queue.live === 0) return;
+  if (queue.entries.length > queue.live * 2) {
+    queue.entries = queue.entries.filter((candidate) => candidate.active);
+  }
 }
 function publishHiddenRevealActions(boundary) {
-  const actions = HIDDEN_REVEAL_ACTIONS?.get(boundary);
-  if (actions === void 0) return;
+  const queue = HIDDEN_REVEAL_ACTIONS?.get(boundary);
+  if (queue === void 0) return;
+  const entries = queue.entries;
   if (boundary.__kind === "activityBlockSlot") {
-    for (let i = 0; i < actions.length; i++) {
-      const action = actions[i];
+    const end = entries.length;
+    for (let i = 0; i < end; i++) {
+      const entry = entries[i];
+      if (!entry.active) continue;
       enqueueEffectEventCommitAction(() => {
-        if (HIDDEN_REVEAL_ACTIONS?.get(boundary) !== actions) return;
-        const index = actions.indexOf(action);
-        if (index === -1) return;
-        actions.splice(index, 1);
-        if (actions.length === 0) HIDDEN_REVEAL_ACTIONS.delete(boundary);
-        return action();
+        const claimed = claimHiddenRevealAction(boundary, entry);
+        if (claimed === null) return;
+        return claimed();
       });
     }
     return;
   }
   HIDDEN_REVEAL_ACTIONS.delete(boundary);
-  for (let i = 0; i < actions.length; i++) enqueueEffectEventCommitAction(actions[i]);
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (entry.active) enqueueEffectEventCommitAction(entry.action);
+  }
 }
 function useLinkedState(source, reconcile, options, slot) {
   if (typeof options === "symbol") {
@@ -5334,10 +5358,10 @@ function beginHydratePreload(state) {
   return promise;
 }
 function resolveHydrateWaiters(state, reason) {
-  if (state.hydrationWaiters.size === 0) return;
-  const waiters = [...state.hydrationWaiters];
-  state.hydrationWaiters.clear();
-  for (let i = 0; i < waiters.length; i++) waiters[i](reason);
+  const waiters = state.hydrationWaiters;
+  if (waiters === null) return;
+  state.hydrationWaiters = null;
+  for (const waiter of waiters) waiter(reason);
 }
 function waitForHydratePrefetchStrategy(state, strategy) {
   const controller = state.prefetchAbort;
@@ -5351,13 +5375,13 @@ function waitForHydratePrefetchStrategy(state, strategy) {
       if (settled) return;
       settled = true;
       cleanup?.();
-      state.hydrationWaiters.delete(onHydrate);
+      state.hydrationWaiters?.delete(onHydrate);
       signal.removeEventListener("abort", onAbort);
       resolve(reason);
     };
     const onHydrate = () => finish("hydrate");
     const onAbort = () => finish("abort");
-    state.hydrationWaiters.add(onHydrate);
+    (state.hydrationWaiters ??= /* @__PURE__ */ new Set()).add(onHydrate);
     signal.addEventListener("abort", onAbort, { once: true });
     cleanup = strategy._s?.({
       element: state.wrapper,
@@ -5757,7 +5781,7 @@ function createHydrateSlot(props, scope, boundaryId) {
     prefetchPromise: null,
     preloadPromise: null,
     loadedBody: null,
-    hydrationWaiters: /* @__PURE__ */ new Set(),
+    hydrationWaiters: null,
     activationGeneration: 0,
     activationRequested: !serverPreserved,
     activationReady: !serverPreserved,
@@ -19475,28 +19499,23 @@ function enqueueInlineCaughtError(state) {
   const handler = rootErrorHandlersFor(block)?.onCaughtError;
   if (handler === void 0) return;
   const error = state.err;
-  let parkedOwner = null;
+  let parked = null;
   let cleanupRegistered = false;
   const action = (owner2) => {
-    parkedOwner = null;
+    parked = null;
     if (block.disposed || state.block !== block) return;
     const hidden = owner2 ?? findScheduledVisibilityOwner(block, true);
     if (hidden !== null) {
-      parkedOwner = hidden;
       if (!cleanupRegistered) {
         cleanupRegistered = true;
         (block.cleanups ??= []).push(() => {
-          const owner3 = parkedOwner;
-          parkedOwner = null;
-          if (owner3 === null) return;
-          const actions = HIDDEN_REVEAL_ACTIONS?.get(owner3);
-          if (actions === void 0) return;
-          const index = actions.indexOf(action);
-          if (index !== -1) actions.splice(index, 1);
-          if (actions.length === 0) HIDDEN_REVEAL_ACTIONS.delete(owner3);
+          const pending = parked;
+          parked = null;
+          if (pending === null) return;
+          cancelHiddenRevealAction(pending.owner, pending.entry);
         });
       }
-      deferHiddenRevealAction(hidden, action);
+      parked = { owner: hidden, entry: deferHiddenRevealAction(hidden, action) };
       return;
     }
     return { state, block, error, handler, resume: action };

package/dist/cjs/signals/engine.cjs

@@ -333,10 +333,14 @@ class ScopeImpl {
       type,
       ...node ? { key: node.key, revision: node.revision } : {}
     };
-    if (this.events.length === this.traceLimit) this.events.shift();
-    this.events.push(event);
+    if (this.events.length === this.traceLimit) {
+      this.events[(event.sequence - 1) % this.traceLimit] = event;
+    } else {
+      this.events.push(event);
+    }
   }
   inspect() {
+    const traceStart = this.traceLimit && this.events.length === this.traceLimit ? this.sequence % this.traceLimit : 0;
     return {
       scopeKey: this.scopeKey,
       epoch: this.epoch,
@@ -365,7 +369,9 @@ class ScopeImpl {
           dependencies
         };
       }),
-      trace: this.events.map((event) => ({ ...event }))
+      trace: this.events.map((event, index) => ({
+        ...traceStart ? this.events[(traceStart + index) % this.events.length] : event
+      }))
     };
   }
   dispose() {

package/dist/cjs/version.cjs

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

package/dist/compiler/bundler.js

@@ -75,6 +75,21 @@ export const OCTANE_RUNTIME_REQUESTS = Object.freeze({
 	server: 'octane/server',
 });
 
+// Vite can classify descriptor exports from its transform-local preflight AST,
+// but the neutral compiler must never trust caller-supplied facts or a naked
+// authored AST. Only opaque objects registered here can bypass the established
+// string classifier, and each proof is consumed once for its exact source/id.
+const descriptorChildrenExportProofs = new WeakMap();
+const descriptorChildrenExportAuthorities = new WeakMap();
+
+function consumeDescriptorChildrenExportProof(proof, source, id) {
+	if (proof === null || typeof proof !== 'object') return null;
+	const prepared = descriptorChildrenExportProofs.get(proof);
+	descriptorChildrenExportProofs.delete(proof);
+	if (prepared?.source !== source || prepared.id !== id) return null;
+	return prepared.exports;
+}
+
 /** Strip bundler query/hash suffixes without changing the underlying path. */
 export function cleanModuleId(id) {
 	const query = id.indexOf('?');
@@ -259,6 +274,7 @@ export function findVoidComponentExports(source, id) {
 	}
 
 	const voidBindings = new Set();
+	const memoDependents = new Map();
 	const hasLowerableJsxReturnBranches = createJsxReturnBranchClassifier(ast.body || []);
 	// Mirrors the compile-time lowering decisions exactly (nullish-guard @{}
 	// bodies AND React-style conditional JSX returns), so cross-module call-site
@@ -273,41 +289,40 @@ 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.
 		for (const item of declaration.declarations || []) {
+			const init = item.init;
 			if (
 				item.id?.type === 'Identifier' &&
-				(item.init?.type === 'FunctionExpression' ||
-					item.init?.type === 'ArrowFunctionExpression') &&
-				isVoidFunction(item.init)
+				(init?.type === 'FunctionExpression' || init?.type === 'ArrowFunctionExpression') &&
+				isVoidFunction(init)
 			) {
 				voidBindings.add(item.id.name);
 			}
+			if (
+				item.id?.type !== 'Identifier' ||
+				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;
+			let dependents = memoDependents.get(target);
+			if (dependents === undefined) memoDependents.set(target, (dependents = []));
+			dependents.push(item.id.name);
 		}
 	}
-	// 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.
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (const declaration of declarations) {
-			if (declaration.type !== 'VariableDeclaration' || declaration.kind !== 'const') continue;
-			for (const item of declaration.declarations || []) {
-				const init = item.init;
-				if (
-					item.id?.type !== 'Identifier' ||
-					voidBindings.has(item.id.name) ||
-					init?.type !== 'CallExpression' ||
-					init.callee?.type !== 'Identifier' ||
-					!memoLocals.has(init.callee.name) ||
-					init.arguments?.length !== 1 ||
-					init.arguments[0]?.type !== 'Identifier' ||
-					!voidBindings.has(init.arguments[0].name)
-				)
-					continue;
-				voidBindings.add(item.id.name);
-				changed = true;
-			}
+	const pending = [...voidBindings];
+	for (let index = 0; index < pending.length; index++) {
+		for (const dependent of memoDependents.get(pending[index]) ?? []) {
+			if (voidBindings.has(dependent)) continue;
+			voidBindings.add(dependent);
+			pending.push(dependent);
 		}
 	}
 
@@ -518,6 +533,7 @@ class OctaneBundlerCompiler {
 			if (renderer.intrinsics !== undefined) this.pragmaOwnedModules.add(renderer.intrinsics);
 		}
 		this.warn = typeof options.warn === 'function' ? options.warn : null;
+		descriptorChildrenExportAuthorities.set(this, options._descriptorPreflightAuthority ?? null);
 		this.warnedOwnership = new Set();
 		this.warnedCompileDiagnostics = new Set();
 		// Deliberately instance-scoped: separate projects/build environments must
@@ -933,8 +949,30 @@ class OctaneBundlerCompiler {
 		return findStaticRuntimeImportRequests(code, this._canonicalModuleId(id));
 	}
 
+	/** @internal Create a one-transform descriptor-export proof from a read-only AST. */
+	_prepareDescriptorChildrenExports(authority, source, id, ast) {
+		if (
+			authority === null ||
+			authority !== descriptorChildrenExportAuthorities.get(this) ||
+			typeof source !== 'string' ||
+			typeof id !== 'string' ||
+			ast === null ||
+			typeof ast !== 'object' ||
+			ast.type !== 'Program'
+		) {
+			throw new TypeError('Invalid descriptor-children preflight input.');
+		}
+		const proof = Object.freeze({});
+		descriptorChildrenExportProofs.set(proof, {
+			source,
+			id,
+			exports: Object.freeze(findDescriptorChildrenExports(ast, id)),
+		});
+		return proof;
+	}
+
 	/** CSS proof discovery uses the same ownership gate as the eventual compile. */
-	findCssModuleImportRequests(code, id, environment = 'client') {
+	findCssModuleImportRequests(code, id, environment = 'client', parsedAst = null) {
 		if (typeof code !== 'string' || !code.includes('.module.')) return [];
 		// The live-read witness currently follows DOM host ownership only. Even
 		// a DOM-owned module can delegate a JSX-valued prop to another renderer.
@@ -956,7 +994,7 @@ class OctaneBundlerCompiler {
 		) {
 			return [];
 		}
-		return findCssModuleImportRequests(code, filename);
+		return findCssModuleImportRequests(parsedAst ?? code, filename);
 	}
 
 	/**
@@ -1014,6 +1052,11 @@ class OctaneBundlerCompiler {
 
 	transform(code, id, options = {}) {
 		assertNativeReadOptions(options);
+		const preparedDescriptorChildrenExports = consumeDescriptorChildrenExportProof(
+			options._descriptorChildrenExportsProof,
+			code,
+			id,
+		);
 		const file = cleanModuleId(id);
 		const hydrateBoundaryPath = hydrateBoundaryPathFromId(id);
 		const collected = {
@@ -1199,7 +1242,10 @@ class OctaneBundlerCompiler {
 							voidComponentExports: findVoidComponentExports(voidComponentAst, filename),
 						}),
 				...(cssModuleConstantImports === undefined ? null : { cssModuleConstantImports }),
-				descriptorChildrenExports: findDescriptorChildrenExports(code, filename),
+				descriptorChildrenExports:
+					preparedDescriptorChildrenExports === null
+						? findDescriptorChildrenExports(code, filename)
+						: [...preparedDescriptorChildrenExports],
 				...finishMetadata(collected),
 			};
 		}

package/dist/compiler/client-only-server.js

@@ -151,12 +151,16 @@ export function createClientReferenceManifest(entries) {
 /** Return the runtime import/re-export requests that a bundler should resolve. */
 export function findStaticRuntimeImportRequests(source, filename = 'unknown') {
 	let ast;
-	try {
-		ast = parseModule(source, filename);
-	} catch {
-		// The owning compiler/parser will report the useful syntax diagnostic. Import
-		// classification is an adapter prepass and must not replace it.
-		return [];
+	if (source && typeof source === 'object' && source.type === 'Program') {
+		ast = source;
+	} else {
+		try {
+			ast = parseModule(source, filename);
+		} catch {
+			// The owning compiler/parser will report the useful syntax diagnostic. Import
+			// classification is an adapter prepass and must not replace it.
+			return [];
+		}
 	}
 	const requests = new Set();
 	for (const statement of ast.body ?? []) {

package/dist/compiler/compile-renderer-boundaries.js

@@ -499,7 +499,7 @@ function owningComponentForReference(components, node) {
 }
 
 function ownerReachableComponentsAst(ast, localSpecializations) {
-	const localNames = new Set(localSpecializations.components.keys());
+	const localNames = localSpecializations.components;
 	const dependencies = new Map();
 	const reachable = new Set(
 		[...localSpecializations.exported].filter((name) => localNames.has(name)),
@@ -702,7 +702,7 @@ function collectSpecializationAstReplacements(node, cloneNames, runtime, aliases
 }
 
 function specializeLocalComponentsAst(region, index, state) {
-	const localNames = new Set(state.localSpecializations.components.keys());
+	const localNames = state.localSpecializations.components;
 	const selected = new Set([
 		...jsxComponentReferences(region, localNames),
 		...localCallReferences(region, localNames),

package/dist/compiler/compile.js

@@ -5340,38 +5340,70 @@ function classifyStableHookfulChildCalls(moduleBody, ctx) {
 		});
 	}
 
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (const [name, candidate] of candidates) {
-			for (const edge of candidate.dependencies) {
-				if (!candidates.has(tagBindingName(edge))) {
-					candidates.delete(name);
-					changed = true;
-					break;
-				}
+	const dependents = new Map();
+	const removalQueue = [];
+	for (const [name, candidate] of candidates) {
+		let invalid = false;
+		for (const edge of candidate.dependencies) {
+			const childName = tagBindingName(edge);
+			if (!candidates.has(childName)) {
+				invalid = true;
+				continue;
 			}
+			let childDependents = dependents.get(childName);
+			if (childDependents === undefined) {
+				dependents.set(childName, (childDependents = []));
+			}
+			childDependents.push(name);
 		}
+		if (invalid) removalQueue.push(name);
 	}
-	changed = true;
-	while (changed) {
-		changed = false;
-		for (const candidate of candidates.values()) {
-			for (const edge of candidate.dependencies) {
-				const child = candidates.get(tagBindingName(edge));
-				for (const capture of child.captures) {
-					if (!candidate.captures.has(capture)) {
-						candidate.captures.add(capture);
-						changed = true;
-					}
-				}
-				for (const publication of child.publications) {
-					if (!candidate.publications.has(publication)) {
-						candidate.publications.add(publication);
-						changed = true;
-					}
-				}
-			}
+	for (let index = 0; index < removalQueue.length; index++) {
+		const name = removalQueue[index];
+		if (!candidates.delete(name)) continue;
+		const parentNames = dependents.get(name);
+		if (parentNames === undefined) continue;
+		for (const parentName of parentNames) {
+			if (candidates.has(parentName)) removalQueue.push(parentName);
+		}
+	}
+
+	const captureOwners = [];
+	const captureValues = [];
+	const publicationOwners = [];
+	const publicationValues = [];
+	for (const [name, candidate] of candidates) {
+		for (const capture of candidate.captures) {
+			captureOwners.push(name);
+			captureValues.push(capture);
+		}
+		for (const publication of candidate.publications) {
+			publicationOwners.push(name);
+			publicationValues.push(publication);
+		}
+	}
+	for (let index = 0; index < captureOwners.length; index++) {
+		const parentNames = dependents.get(captureOwners[index]);
+		if (parentNames === undefined) continue;
+		const capture = captureValues[index];
+		for (const parentName of parentNames) {
+			const parent = candidates.get(parentName);
+			if (parent === undefined || parent.captures.has(capture)) continue;
+			parent.captures.add(capture);
+			captureOwners.push(parentName);
+			captureValues.push(capture);
+		}
+	}
+	for (let index = 0; index < publicationOwners.length; index++) {
+		const parentNames = dependents.get(publicationOwners[index]);
+		if (parentNames === undefined) continue;
+		const publication = publicationValues[index];
+		for (const parentName of parentNames) {
+			const parent = candidates.get(parentName);
+			if (parent === undefined || parent.publications.has(publication)) continue;
+			parent.publications.add(publication);
+			publicationOwners.push(parentName);
+			publicationValues.push(publication);
 		}
 	}
 	for (const [name, candidate] of candidates) {

package/dist/compiler/css-module-imports.js

@@ -10,12 +10,16 @@ export function isPlainCssModuleId(id) {
 
 /** Only authored CSS-module imports can ask the host for this narrow proof. */
 export function findCssModuleImportRequests(source, id) {
-	if (typeof source !== 'string' || !source.includes('.module.')) return [];
 	let ast;
-	try {
-		ast = parseModule(source, id);
-	} catch {
-		return [];
+	if (source && typeof source === 'object' && source.type === 'Program') {
+		ast = source;
+	} else {
+		if (typeof source !== 'string' || !source.includes('.module.')) return [];
+		try {
+			ast = parseModule(source, id);
+		} catch {
+			return [];
+		}
 	}
 	const requests = new Set();
 	for (const statement of ast.body ?? []) {

package/dist/compiler/hydrate-boundaries.js

@@ -693,17 +693,38 @@ function visitJsxTag(name, visitIdentifier) {
 }
 
 /** Collect names whose values must cross from the parent module into a queried child. */
-function collectCaptures(nodes, importBindings, shadowedImports = new Set()) {
+function collectCaptures(
+	nodes,
+	importBindings,
+	shadowedImports = new Set(),
+	additionalBindings = null,
+) {
 	const captures = new Set();
 	const scopes = [];
 	const seen = new WeakSet();
-	const isBound = (name) => {
-		if (importBindings.has(name) && !shadowedImports.has(name)) return true;
-		for (let index = scopes.length - 1; index >= 0; index--) {
-			if (scopes[index].has(name)) return true;
-		}
-		return false;
-	};
+	// Module slicing can consult a second binding set without materializing its
+	// union for every boundary. Preserve the single-set path for all other walks.
+	const isBound =
+		additionalBindings === null
+			? (name) => {
+					if (importBindings.has(name) && !shadowedImports.has(name)) return true;
+					for (let index = scopes.length - 1; index >= 0; index--) {
+						if (scopes[index].has(name)) return true;
+					}
+					return false;
+				}
+			: (name) => {
+					if (
+						(importBindings.has(name) || additionalBindings.has(name)) &&
+						!shadowedImports.has(name)
+					) {
+						return true;
+					}
+					for (let index = scopes.length - 1; index >= 0; index--) {
+						if (scopes[index].has(name)) return true;
+					}
+					return false;
+				};
 	const reference = (node) => {
 		if (node?.name && !isBound(node.name)) captures.add(node.name);
 	};
@@ -976,8 +997,31 @@ function privateModuleDeclarationGraph(ast, importBindings) {
 	return { byBinding, records };
 }
 
+function sortedBoundaryRanges(boundaries) {
+	return boundaries
+		.map((boundary) => ({ end: boundary.node.end, start: boundary.node.start }))
+		.sort((left, right) => left.start - right.start || left.end - right.end);
+}
+
+function declarationContainsBoundary(node, boundaryRanges) {
+	let low = 0;
+	let high = boundaryRanges.length;
+	while (low < high) {
+		const middle = (low + high) >>> 1;
+		if (boundaryRanges[middle].start < node.start) low = middle + 1;
+		else high = middle;
+	}
+	for (let index = low; index < boundaryRanges.length; index++) {
+		const boundary = boundaryRanges[index];
+		if (boundary.start > node.end) break;
+		if (boundary.end <= node.end) return true;
+	}
+	return false;
+}
+
 function movableModuleDeclarations(analysis) {
 	const records = [];
+	let boundaryRanges = null;
 	const moduleBindings = topLevelBindingNames(analysis.ast);
 	const exportedBindings = localExportBindings(analysis.ast);
 	for (const node of analysis.ast.body ?? []) {
@@ -994,11 +1038,8 @@ function movableModuleDeclarations(analysis) {
 		// A declaration containing its own Hydrate site needs another extraction
 		// pass after it moves. Keep that uncommon declaration in the parent until
 		// recursive declaration slicing has an explicit protocol of its own.
-		if (
-			analysis.boundaries.some(
-				(boundary) => boundary.node.start >= node.start && boundary.node.end <= node.end,
-			)
-		) {
+		boundaryRanges ??= sortedBoundaryRanges(analysis.boundaries);
+		if (declarationContainsBoundary(node, boundaryRanges)) {
 			continue;
 		}
 		const bindings = declarationBindingSet(node);
@@ -1007,6 +1048,7 @@ function movableModuleDeclarations(analysis) {
 		records.push({
 			bindings,
 			dependencies: new Set(),
+			order: records.length,
 			retainedDependencies: new Set(),
 			node,
 		});
@@ -1123,8 +1165,12 @@ function hydrateBoundaryElement(
 	if (boundary.disabled) return node;
 	assertDirectChildren(boundary, boundary.filename);
 	validateBoundary(boundary, boundary.filename, boundary.hookNames);
-	const availableBindings = new Set([...importBindings, ...additionalModuleBindings]);
-	const captures = collectCaptures(node.children, availableBindings, boundary.shadowedImports);
+	const captures = collectCaptures(
+		node.children,
+		importBindings,
+		boundary.shadowedImports,
+		additionalModuleBindings.size === 0 ? null : additionalModuleBindings,
+	);
 	const attributes = [
 		...(opening.attributes ?? []),
 		jsxExpressionAttribute('__load', hydrateLoaderExpression(boundary, request), opening),
@@ -1222,8 +1268,9 @@ function extractedModuleAst(
 	const moduleBindings = moduleBindingsByPath.get(boundary.path) ?? new Set();
 	const captures = collectCaptures(
 		boundary.node.children,
-		new Set([...analysis.imports.importBindings, ...moduleBindings]),
+		analysis.imports.importBindings,
 		boundary.shadowedImports,
+		moduleBindings.size === 0 ? null : moduleBindings,
 	);
 	const pathName = boundary.path.replace(/[^A-Za-z0-9_$]/g, '_');
 	const componentName = uniqueGeneratedName(source, `__OctaneHydrateBoundary_${pathName}`);
@@ -1276,7 +1323,35 @@ function extractedModuleAst(
 	return pruneUnusedImportsAst(program, false);
 }
 
-function createModuleMovePlanAst(source, analysis, request) {
+function moduleReferencesForBoundary(analysis, boundary, request, moduleBindingsByPath) {
+	assertDirectChildren(boundary, boundary.filename);
+	validateBoundary(boundary, boundary.filename, analysis.imports.hookNames);
+	const collectModuleReferences = (nodes) =>
+		collectCaptures(nodes, analysis.imports.importBindings).filter(
+			(name) => !boundary.shadowedImports.has(name),
+		);
+	if (boundary.children.length === 0) {
+		return collectModuleReferences(boundary.node.children);
+	}
+	const nestedAnalysis = {
+		...analysis,
+		roots: boundary.children,
+	};
+	const fragment = transformHydrateAst(
+		{
+			type: 'Program',
+			sourceType: 'module',
+			body: boundary.node.children,
+			metadata: { path: [] },
+		},
+		nestedAnalysis,
+		request,
+		moduleBindingsByPath,
+	);
+	return collectModuleReferences(fragment.body);
+}
+
+function createModuleMovePlanAst(analysis, request) {
 	const candidates = movableModuleDeclarations(analysis);
 	if (candidates.records.length === 0) {
 		return {
@@ -1340,13 +1415,9 @@ function createModuleMovePlanAst(source, analysis, request) {
 	const referencesByPath = new Map();
 	for (const boundary of analysis.boundaries) {
 		if (boundary.disabled || hasPermanentStaticAncestor(boundary)) continue;
-		const childAst = extractedModuleAst(source, analysis, boundary, request, allBindingsByPath);
 		referencesByPath.set(
 			boundary.path,
-			collectCaptures(
-				(childAst.body ?? []).filter((node) => node.type !== 'ImportDeclaration'),
-				analysis.imports.importBindings,
-			),
+			moduleReferencesForBoundary(analysis, boundary, request, allBindingsByPath),
 		);
 	}
 	const recordsForReferences = (childReferences) => {
@@ -1371,8 +1442,11 @@ function createModuleMovePlanAst(source, analysis, request) {
 		return records;
 	};
 	const preliminaryCounts = new Map();
-	for (const references of referencesByPath.values()) {
-		for (const record of recordsForReferences(references)) {
+	const preliminaryRecordsByPath = new Map();
+	for (const [path, references] of referencesByPath) {
+		const records = recordsForReferences(references);
+		preliminaryRecordsByPath.set(path, records);
+		for (const record of records) {
 			preliminaryCounts.set(record, (preliminaryCounts.get(record) ?? 0) + 1);
 		}
 	}
@@ -1383,9 +1457,12 @@ function createModuleMovePlanAst(source, analysis, request) {
 	const movedRecords = new Set();
 	for (const boundary of analysis.boundaries) {
 		if (boundary.disabled || hasPermanentStaticAncestor(boundary)) continue;
-		const records = recordsForReferences(referencesByPath.get(boundary.path) ?? []);
-		if (records.size === 0) continue;
-		const ordered = candidates.records.filter((record) => records.has(record));
+		const records = preliminaryRecordsByPath.get(boundary.path);
+		if (records === undefined) continue;
+		const ordered = [...records]
+			.filter((record) => !eagerRecords.has(record))
+			.sort((left, right) => left.order - right.order);
+		if (ordered.length === 0) continue;
 		bindingsByPath.set(boundary.path, new Set(ordered.flatMap((record) => [...record.bindings])));
 		declarationsByPath.set(boundary.path, ordered);
 		for (const record of ordered) movedRecords.add(record);
@@ -1532,7 +1609,7 @@ export function prepareHydrateBoundaries(source, filename, boundaryPath = null,
 		boundary.hookNames = analysis.imports.hookNames;
 	}
 	const request = sameSourceRequest(filename);
-	const moduleMovePlan = createModuleMovePlanAst(source, analysis, request);
+	const moduleMovePlan = createModuleMovePlanAst(analysis, request);
 	const permanentStaticRemoved =
 		boundaryPath === null
 			? createPermanentStaticRemovalPlanAst(analysis, request, moduleMovePlan)

package/dist/compiler/slot-hooks.js

@@ -232,10 +232,14 @@ function collectVoidJsxImportCandidates(ast) {
  */
 export function findVoidComponentImports(source, id) {
 	let ast;
-	try {
-		ast = parseModule(source, id);
-	} catch {
-		return [];
+	if (source && typeof source === 'object' && source.type === 'Program') {
+		ast = source;
+	} else {
+		try {
+			ast = parseModule(source, id);
+		} catch {
+			return [];
+		}
 	}
 	const unique = new Map();
 	for (const candidate of [

package/dist/compiler/vite.js

@@ -16,6 +16,7 @@
 import * as nodeCrypto from 'node:crypto';
 import * as nodeFs from 'node:fs';
 import * as nodePath from 'node:path';
+import { parseModule } from '@tsrx/core';
 import {
 	CLIENT_REFERENCE_MANIFEST_FILENAME,
 	cleanModuleId,
@@ -38,6 +39,7 @@ const PROFILE_DEFINE = '__OCTANE_PROFILE_ENABLED__';
 const VOID_EXPORTS_META = 'octane:void-component-exports';
 const DESCRIPTOR_CHILDREN_EXPORTS_META = 'octane:descriptor-children-exports';
 const CLIENT_REFERENCE_META = 'octane:client-reference';
+const DESCRIPTOR_PREFLIGHT_AUTHORITY = Symbol('octane.descriptor-preflight');
 
 function realRoot(path) {
 	try {
@@ -491,9 +493,8 @@ async function loadDescriptorChildrenImports(
 	return proven;
 }
 
-async function loadClientOnlyImports(context, compiler, code, importer) {
+async function loadClientOnlyImports(context, compiler, requests, importer) {
 	if (typeof context.resolve !== 'function') return [];
-	const requests = compiler.findServerImportRequests(code, importer);
 	const classified = [];
 	await Promise.all(
 		requests.map(async (request) => {
@@ -611,6 +612,7 @@ export function octane(options = {}) {
 	// virtual module until its own transform publishes metadata.
 	let allowDescriptorGraphLoad = true;
 	let compiler = createOctaneCompiler({
+		_descriptorPreflightAuthority: DESCRIPTOR_PREFLIGHT_AUTHORITY,
 		root: projectRoot,
 		exclude: options.exclude,
 		profile: profileEnabled,
@@ -630,6 +632,7 @@ export function octane(options = {}) {
 		cssModuleProofStates.clear();
 		projectRoot = nodePath.resolve(root);
 		compiler = createOctaneCompiler({
+			_descriptorPreflightAuthority: DESCRIPTOR_PREFLIGHT_AUTHORITY,
 			root: projectRoot,
 			exclude: options.exclude,
 			profile: profileEnabled,
@@ -752,9 +755,47 @@ export function octane(options = {}) {
 					? forceSsr
 					: transformOptions?.ssr === true || this.environment?.config?.consumer === 'server';
 			const environment = server ? 'server' : 'client';
-			const cssRequests = specializeCssModuleConstants
-				? compiler.findCssModuleImportRequests(code, id, environment)
-				: [];
+			// Parse authored source once, synchronously classify every applicable
+			// adapter concern, then let the AST fall out of scope before any graph
+			// loading begins. Compilation keeps its independent authoritative parser.
+			const preflight = (() => {
+				const authoredSource = code;
+				let ast;
+				try {
+					ast = parseModule(authoredSource, id);
+				} catch {
+					// Every adapter classifier uses this exact parser/source/id and would
+					// return an empty result after repeating the same failed parse. Preserve
+					// those facts without the retries. The compiler receives no descriptor
+					// proof, so its canonical-id fallback and authoritative diagnostics stay
+					// unchanged.
+					return {
+						cssRequests: [],
+						descriptorExportsProof: null,
+						descriptorImports: [],
+						serverImportRequests: [],
+						voidImports: [],
+					};
+				}
+				return {
+					cssRequests: specializeCssModuleConstants
+						? compiler.findCssModuleImportRequests(code, id, environment, ast)
+						: [],
+					descriptorExportsProof: compiler._prepareDescriptorChildrenExports(
+						DESCRIPTOR_PREFLIGHT_AUTHORITY,
+						code,
+						id,
+						ast,
+					),
+					descriptorImports: findDescriptorChildrenImports(ast, id),
+					serverImportRequests: server ? compiler.findServerImportRequests(ast, id) : [],
+					voidImports:
+						specializeProductionRoots && !server && !hmrEnabled && !profileEnabled
+							? findVoidComponentImports(ast, id)
+							: [],
+				};
+			})();
+			const cssRequests = preflight.cssRequests;
 			const loadCssImports = () =>
 				loadCssModuleImports(
 					this,
@@ -774,6 +815,9 @@ export function octane(options = {}) {
 					.filter((key) => key.startsWith('export\0'))
 					.map((key) => key.slice('export\0'.length));
 				const result = compiler.transform(code, id, {
+					...(preflight.descriptorExportsProof === null
+						? null
+						: { _descriptorChildrenExportsProof: preflight.descriptorExportsProof }),
 					environment,
 					hmr: !server && hmrEnabled ? 'vite' : false,
 					// DEV server transforms also carry SSR-only diagnostics. HMR itself
@@ -849,11 +893,11 @@ export function octane(options = {}) {
 			};
 
 			if (server) {
-				const descriptorImports = findDescriptorChildrenImports(code, id).filter(
+				const descriptorImports = preflight.descriptorImports.filter(
 					(candidate) => candidate.local !== undefined || !nodeFs.existsSync(cleanModuleId(id)),
 				);
 				return Promise.all([
-					loadClientOnlyImports(this, compiler, code, id),
+					loadClientOnlyImports(this, compiler, preflight.serverImportRequests, id),
 					loadDescriptorChildrenImports(
 						this,
 						descriptorImports,
@@ -871,9 +915,9 @@ export function octane(options = {}) {
 
 			const voidImports =
 				specializeProductionRoots && !server && !hmrEnabled && !profileEnabled
-					? findVoidComponentImports(code, id)
+					? preflight.voidImports
 					: [];
-			const descriptorImports = findDescriptorChildrenImports(code, id).filter(
+			const descriptorImports = preflight.descriptorImports.filter(
 				(candidate) => candidate.local !== undefined || !nodeFs.existsSync(cleanModuleId(id)),
 			);
 			if (voidImports.length === 0 && descriptorImports.length === 0 && cssRequests.length === 0) {

package/dist/runtime.js

@@ -4071,29 +4071,53 @@ function __useStateWithGetter(initial, slot) {
 let HIDDEN_REVEAL_ACTIONS = null;
 function deferHiddenRevealAction(boundary, action) {
   const deferred = HIDDEN_REVEAL_ACTIONS ??= /* @__PURE__ */ new WeakMap();
-  const actions = deferred.get(boundary);
-  if (actions === void 0) deferred.set(boundary, [action]);
-  else actions.push(action);
+  let queue = deferred.get(boundary);
+  if (queue === void 0) {
+    queue = { entries: [], live: 0 };
+    deferred.set(boundary, queue);
+  }
+  const entry = { action, active: true, queue };
+  queue.entries.push(entry);
+  queue.live++;
+  return entry;
+}
+function claimHiddenRevealAction(boundary, entry) {
+  const queue = entry.queue;
+  if (HIDDEN_REVEAL_ACTIONS?.get(boundary) !== queue) return null;
+  if (!entry.active) return null;
+  entry.active = false;
+  if (--queue.live === 0) HIDDEN_REVEAL_ACTIONS.delete(boundary);
+  return entry.action;
+}
+function cancelHiddenRevealAction(boundary, entry) {
+  const queue = entry.queue;
+  if (claimHiddenRevealAction(boundary, entry) === null || queue.live === 0) return;
+  if (queue.entries.length > queue.live * 2) {
+    queue.entries = queue.entries.filter((candidate) => candidate.active);
+  }
 }
 function publishHiddenRevealActions(boundary) {
-  const actions = HIDDEN_REVEAL_ACTIONS?.get(boundary);
-  if (actions === void 0) return;
+  const queue = HIDDEN_REVEAL_ACTIONS?.get(boundary);
+  if (queue === void 0) return;
+  const entries = queue.entries;
   if (boundary.__kind === "activityBlockSlot") {
-    for (let i = 0; i < actions.length; i++) {
-      const action = actions[i];
+    const end = entries.length;
+    for (let i = 0; i < end; i++) {
+      const entry = entries[i];
+      if (!entry.active) continue;
       enqueueEffectEventCommitAction(() => {
-        if (HIDDEN_REVEAL_ACTIONS?.get(boundary) !== actions) return;
-        const index = actions.indexOf(action);
-        if (index === -1) return;
-        actions.splice(index, 1);
-        if (actions.length === 0) HIDDEN_REVEAL_ACTIONS.delete(boundary);
-        return action();
+        const claimed = claimHiddenRevealAction(boundary, entry);
+        if (claimed === null) return;
+        return claimed();
       });
     }
     return;
   }
   HIDDEN_REVEAL_ACTIONS.delete(boundary);
-  for (let i = 0; i < actions.length; i++) enqueueEffectEventCommitAction(actions[i]);
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (entry.active) enqueueEffectEventCommitAction(entry.action);
+  }
 }
 function useLinkedState(source, reconcile, options, slot) {
   if (typeof options === "symbol") {
@@ -5167,10 +5191,10 @@ function beginHydratePreload(state) {
   return promise;
 }
 function resolveHydrateWaiters(state, reason) {
-  if (state.hydrationWaiters.size === 0) return;
-  const waiters = [...state.hydrationWaiters];
-  state.hydrationWaiters.clear();
-  for (let i = 0; i < waiters.length; i++) waiters[i](reason);
+  const waiters = state.hydrationWaiters;
+  if (waiters === null) return;
+  state.hydrationWaiters = null;
+  for (const waiter of waiters) waiter(reason);
 }
 function waitForHydratePrefetchStrategy(state, strategy) {
   const controller = state.prefetchAbort;
@@ -5184,13 +5208,13 @@ function waitForHydratePrefetchStrategy(state, strategy) {
       if (settled) return;
       settled = true;
       cleanup?.();
-      state.hydrationWaiters.delete(onHydrate);
+      state.hydrationWaiters?.delete(onHydrate);
       signal.removeEventListener("abort", onAbort);
       resolve(reason);
     };
     const onHydrate = () => finish("hydrate");
     const onAbort = () => finish("abort");
-    state.hydrationWaiters.add(onHydrate);
+    (state.hydrationWaiters ??= /* @__PURE__ */ new Set()).add(onHydrate);
     signal.addEventListener("abort", onAbort, { once: true });
     cleanup = strategy._s?.({
       element: state.wrapper,
@@ -5590,7 +5614,7 @@ function createHydrateSlot(props, scope, boundaryId) {
     prefetchPromise: null,
     preloadPromise: null,
     loadedBody: null,
-    hydrationWaiters: /* @__PURE__ */ new Set(),
+    hydrationWaiters: null,
     activationGeneration: 0,
     activationRequested: !serverPreserved,
     activationReady: !serverPreserved,
@@ -19309,28 +19333,23 @@ function enqueueInlineCaughtError(state) {
   const handler = rootErrorHandlersFor(block)?.onCaughtError;
   if (handler === void 0) return;
   const error = state.err;
-  let parkedOwner = null;
+  let parked = null;
   let cleanupRegistered = false;
   const action = (owner2) => {
-    parkedOwner = null;
+    parked = null;
     if (block.disposed || state.block !== block) return;
     const hidden = owner2 ?? findScheduledVisibilityOwner(block, true);
     if (hidden !== null) {
-      parkedOwner = hidden;
       if (!cleanupRegistered) {
         cleanupRegistered = true;
         (block.cleanups ??= []).push(() => {
-          const owner3 = parkedOwner;
-          parkedOwner = null;
-          if (owner3 === null) return;
-          const actions = HIDDEN_REVEAL_ACTIONS?.get(owner3);
-          if (actions === void 0) return;
-          const index = actions.indexOf(action);
-          if (index !== -1) actions.splice(index, 1);
-          if (actions.length === 0) HIDDEN_REVEAL_ACTIONS.delete(owner3);
+          const pending = parked;
+          parked = null;
+          if (pending === null) return;
+          cancelHiddenRevealAction(pending.owner, pending.entry);
         });
       }
-      deferHiddenRevealAction(hidden, action);
+      parked = { owner: hidden, entry: deferHiddenRevealAction(hidden, action) };
       return;
     }
     return { state, block, error, handler, resume: action };

package/dist/signals/engine.js

@@ -332,10 +332,14 @@ class ScopeImpl {
       type,
       ...node ? { key: node.key, revision: node.revision } : {}
     };
-    if (this.events.length === this.traceLimit) this.events.shift();
-    this.events.push(event);
+    if (this.events.length === this.traceLimit) {
+      this.events[(event.sequence - 1) % this.traceLimit] = event;
+    } else {
+      this.events.push(event);
+    }
   }
   inspect() {
+    const traceStart = this.traceLimit && this.events.length === this.traceLimit ? this.sequence % this.traceLimit : 0;
     return {
       scopeKey: this.scopeKey,
       epoch: this.epoch,
@@ -364,7 +368,9 @@ class ScopeImpl {
           dependencies
         };
       }),
-      trace: this.events.map((event) => ({ ...event }))
+      trace: this.events.map((event, index) => ({
+        ...traceStart ? this.events[(traceStart + index) % this.events.length] : event
+      }))
     };
   }
   dispose() {

package/dist/universal-core.js

@@ -8914,6 +8914,7 @@ function createObjectDriver(renderer = "object") {
         );
       }
       const state = container[OBJECT_DRIVER_STATE];
+      const useBatchedDetaches = batch.commands.length >= 4096;
       const simulated = /* @__PURE__ */ new Map();
       const destroyed = /* @__PURE__ */ new Set();
       const readSimulated = (id) => {
@@ -8946,27 +8947,66 @@ function createObjectDriver(renderer = "object") {
       const DETACHED = /* @__PURE__ */ Symbol("octane.object-driver.detached");
       const parentChanges = /* @__PURE__ */ new Map();
       let rootChildren = null;
+      let pendingDetaches = null;
       const readParent = (id) => {
         if (parentChanges.has(id)) return parentChanges.get(id);
         return state.parents.has(id) ? state.parents.get(id) : DETACHED;
       };
+      const flushPendingDetaches = (parent, children) => {
+        const detached = pendingDetaches?.get(parent);
+        if (detached === void 0) return;
+        let write = 0;
+        for (let read = 0; read < children.length; read++) {
+          const child = children[read];
+          if (!detached.delete(child)) children[write++] = child;
+        }
+        if (detached.size !== 0) {
+          const missing = detached.values().next().value;
+          throw new Error(`Object driver: child ${missing} is not attached.`);
+        }
+        children.length = write;
+        pendingDetaches.delete(parent);
+        if (pendingDetaches.size === 0) pendingDetaches = null;
+      };
       const simulatedChildren = (parent) => {
+        let children;
         if (parent === null) {
-          return rootChildren ??= container.children.map((child) => child.id);
+          children = rootChildren ??= container.children.map((child) => child.id);
+        } else {
+          const value = readSimulated(parent);
+          if (value === void 0) throw new Error(`Object driver: unknown parent ${parent}.`);
+          children = value.children;
         }
-        const value = readSimulated(parent);
-        if (value === void 0) throw new Error(`Object driver: unknown parent ${parent}.`);
-        return value.children;
+        flushPendingDetaches(parent, children);
+        return children;
       };
-      const detachSimulated = (id) => {
+      const detachSimulated = (id, defer) => {
         const parent = readParent(id);
         if (parent === DETACHED) return;
-        const children = simulatedChildren(parent);
-        const index = children.indexOf(id);
-        if (index === -1) throw new Error(`Object driver: child ${id} is not attached.`);
-        children.splice(index, 1);
+        if (useBatchedDetaches && defer) {
+          const detaches = pendingDetaches ??= /* @__PURE__ */ new Map();
+          const detached = detaches.get(parent);
+          if (detached === void 0) detaches.set(parent, /* @__PURE__ */ new Set([id]));
+          else detached.add(id);
+        } else {
+          const children = simulatedChildren(parent);
+          const index = children.indexOf(id);
+          if (index === -1) throw new Error(`Object driver: child ${id} is not attached.`);
+          children.splice(index, 1);
+        }
         parentChanges.set(id, DETACHED);
       };
+      const forgetPendingDetachParent = (parent) => {
+        if (pendingDetaches === null) return;
+        pendingDetaches.delete(parent);
+        if (pendingDetaches.size === 0) pendingDetaches = null;
+      };
+      const flushAllPendingDetaches = () => {
+        while (pendingDetaches !== null) {
+          const parent = pendingDetaches.keys().next().value;
+          simulatedChildren(parent);
+        }
+      };
       for (const command of batch.commands) {
         if (command.op === "create") {
           if (hasSimulated(command.id))
@@ -9048,7 +9088,7 @@ function createObjectDriver(renderer = "object") {
           }
           if (!hasSimulated(command.id))
             throw new Error(`Object driver: unknown child ${command.id}.`);
-          detachSimulated(command.id);
+          detachSimulated(command.id, false);
           const children = simulatedChildren(command.parent);
           const before = command.before === null ? children.length : children.indexOf(command.before);
           if (before === -1) throw new Error(`Object driver: unknown before id ${command.before}.`);
@@ -9065,11 +9105,10 @@ function createObjectDriver(renderer = "object") {
           if (command.parent !== null && typeof command.parent !== "number") {
             throw new Error("Object driver does not support portal target parents.");
           }
-          const children = simulatedChildren(command.parent);
-          const index = children.indexOf(command.id);
-          if (index === -1) throw new Error(`Object driver: child ${command.id} is not attached.`);
-          children.splice(index, 1);
-          parentChanges.set(command.id, DETACHED);
+          if (readParent(command.id) !== command.parent) {
+            throw new Error(`Object driver: child ${command.id} is not attached.`);
+          }
+          detachSimulated(command.id, true);
           for (const type of readSimulated(command.id).localCallbacks.keys()) {
             cleanupKeys.add(keyFor(command.id, type));
           }
@@ -9077,12 +9116,14 @@ function createObjectDriver(renderer = "object") {
           const instance = readSimulated(command.id);
           if (instance === void 0)
             throw new Error(`Object driver: unknown destroy ${command.id}.`);
-          detachSimulated(command.id);
+          detachSimulated(command.id, true);
           for (const child of instance.children) parentChanges.set(child, DETACHED);
           instance.children.length = 0;
+          forgetPendingDetachParent(command.id);
           destroyed.add(command.id);
         }
       }
+      flushAllPendingDetaches();
       for (const [id, instance] of stagedInstances) {
         const staged = readSimulated(id);
         if (staged === void 0) continue;
@@ -9097,16 +9138,48 @@ function createObjectDriver(renderer = "object") {
       }
       let status = "prepared";
       let acceptedCallbacksRan = false;
-      const liveChildren = (parent) => objectChildren(container, parent, state.instances);
-      const detachLive = (id) => {
+      let pendingLiveDetaches = null;
+      const liveChildren = (parent) => {
+        const children = objectChildren(container, parent, state.instances);
+        const detached = pendingLiveDetaches?.get(parent);
+        if (detached === void 0) return children;
+        let write = 0;
+        for (let read = 0; read < children.length; read++) {
+          const child = children[read];
+          if (!detached.has(child.id)) children[write++] = child;
+        }
+        children.length = write;
+        pendingLiveDetaches.delete(parent);
+        if (pendingLiveDetaches.size === 0) pendingLiveDetaches = null;
+        return children;
+      };
+      const detachLive = (id, defer) => {
         if (!state.parents.has(id)) return;
         const parent = state.parents.get(id);
         const instance = state.instances.get(id);
-        const children = liveChildren(parent);
-        const index = children.indexOf(instance);
-        if (index !== -1) children.splice(index, 1);
+        if (useBatchedDetaches && defer) {
+          const detaches = pendingLiveDetaches ??= /* @__PURE__ */ new Map();
+          const detached = detaches.get(parent);
+          if (detached === void 0) detaches.set(parent, /* @__PURE__ */ new Set([id]));
+          else detached.add(id);
+        } else {
+          const children = liveChildren(parent);
+          const index = children.indexOf(instance);
+          if (index !== -1) children.splice(index, 1);
+        }
         state.parents.delete(id);
       };
+      const forgetPendingLiveParent = (parent) => {
+        if (pendingLiveDetaches === null) return;
+        pendingLiveDetaches.delete(parent);
+        if (pendingLiveDetaches.size === 0) pendingLiveDetaches = null;
+      };
+      const flushAllPendingLiveDetaches = () => {
+        while (pendingLiveDetaches !== null) {
+          const parent = pendingLiveDetaches.keys().next().value;
+          liveChildren(parent);
+        }
+      };
       return {
         apply() {
           if (status !== "prepared") return;
@@ -9163,7 +9236,7 @@ function createObjectDriver(renderer = "object") {
                   throw new Error("Object driver does not support portal target parents.");
                 }
                 const instance = state.instances.get(command.id);
-                detachLive(command.id);
+                detachLive(command.id, false);
                 const children = liveChildren(command.parent);
                 const before = command.before === null ? children.length : children.indexOf(state.instances.get(command.before));
                 children.splice(before, 0, instance);
@@ -9172,14 +9245,13 @@ function createObjectDriver(renderer = "object") {
                 if (command.parent !== null && typeof command.parent !== "number") {
                   throw new Error("Object driver does not support portal target parents.");
                 }
-                const children = liveChildren(command.parent);
-                children.splice(children.indexOf(state.instances.get(command.id)), 1);
-                state.parents.delete(command.id);
+                detachLive(command.id, true);
               } else if (command.op === "destroy") {
                 const instance = state.instances.get(command.id);
-                detachLive(command.id);
+                detachLive(command.id, true);
                 for (const child of instance.children) state.parents.delete(child.id);
                 instance.children.length = 0;
+                forgetPendingLiveParent(command.id);
                 state.instances.delete(command.id);
                 state.parents.delete(command.id);
                 state.events.delete(command.id);
@@ -9188,6 +9260,7 @@ function createObjectDriver(renderer = "object") {
                 state.localCleanups.delete(command.id);
               }
             }
+            flushAllPendingLiveDetaches();
             container.commits.push(batch);
           });
           runCommitTasks(tasks);

package/dist/version.js

@@ -1,4 +1,4 @@
-const version = "0.1.50";
+const version = "0.1.51";
 export {
   version
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octane",
-  "version": "0.1.50",
+  "version": "0.1.51",
   "license": "MIT",
   "type": "module",
   "sideEffects": [