@askrjs/askr 0.0.50 → 0.0.52

package/dist/renderer/component-host-cleanup.js

@@ -1,68 +1,143 @@
+import { incDevCounter } from "../runtime/dev-namespace.js";
 import { cleanupComponent } from "../runtime/component-cleanup.js";
-import "../runtime/component-contracts.js";
-import { removeElementListeners, removeElementReactiveProps } from "./cleanup.js";
+import { registerLifecycleTransaction } from "../runtime/lifecycle-batch.js";
+import { clearDelegatedHandlersForElement, removeDelegatedListener } from "../runtime/events.js";
+import "../runtime/index.js";
+import { elementListeners, elementReactivePropsCleanup, elementRefs, forEachElementReactivePropCleanup, removeElementRef } from "./cleanup.js";
 //#region src/renderer/component-host-cleanup.ts
 function cleanupDetachedComponentHost(host, retainedInstance) {
-	removeElementListeners(host);
-	removeElementReactiveProps(host);
-	const hostInstances = host.__ASKR_INSTANCES;
-	if (hostInstances && hostInstances.length > 0) for (const instance of hostInstances) {
-		if (instance === retainedInstance) continue;
-		cleanupComponent(instance);
+	const retainedInstances = retainedInstance instanceof Object && typeof retainedInstance[Symbol.iterator] === "function" ? new Set(retainedInstance) : /* @__PURE__ */ new Set([retainedInstance]);
+	const cleanupErrors = [];
+	const cleanedInstances = /* @__PURE__ */ new Set();
+	const elements = [host];
+	try {
+		const descendants = host.querySelectorAll("*");
+		for (let index = 0; index < descendants.length; index += 1) elements.push(descendants[index]);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	for (const element of elements) {
+		cleanupElementListeners(element, cleanupErrors);
+		cleanupElementReactiveProps(element, cleanupErrors);
+		cleanupElementRef(element, cleanupErrors);
+		cleanupElementInstances(element, retainedInstances, cleanedInstances, cleanupErrors);
+		clearHostMetadata(element, cleanupErrors);
 	}
-	else if (host.__ASKR_INSTANCE && host.__ASKR_INSTANCE !== retainedInstance) cleanupComponent(host.__ASKR_INSTANCE);
-	const descendants = host.querySelectorAll("*");
-	for (let index = 0; index < descendants.length; index += 1) {
-		const descendant = descendants[index];
-		removeElementListeners(descendant);
-		removeElementReactiveProps(descendant);
-		if (descendant.__ASKR_INSTANCES?.length) {
-			for (const instance of descendant.__ASKR_INSTANCES) {
-				if (instance === retainedInstance) continue;
-				cleanupComponent(instance);
-			}
-			try {
-				delete descendant.__ASKR_INSTANCES;
-			} catch {}
-		} else if (descendant.__ASKR_INSTANCE && descendant.__ASKR_INSTANCE !== retainedInstance) {
-			cleanupComponent(descendant.__ASKR_INSTANCE);
-			try {
-				delete descendant.__ASKR_INSTANCE;
-			} catch {}
+	if (cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, "Detached component host cleanup failed");
+}
+function cleanupElementListeners(element, cleanupErrors) {
+	const listenerMap = elementListeners.get(element);
+	if (listenerMap) {
+		elementListeners.delete(element);
+		for (const entry of listenerMap.values()) try {
+			incDevCounter("listenerRemoves");
+			if (entry.isDelegated) removeDelegatedListener(element, entry.eventName);
+			else if (entry.options !== void 0) element.removeEventListener(entry.eventName, entry.handler, entry.options);
+			else element.removeEventListener(entry.eventName, entry.handler);
+		} catch (error) {
+			cleanupErrors.push(error);
 		}
 	}
 	try {
-		delete host.__ASKR_INSTANCE;
-		delete host.__ASKR_INSTANCES;
-		delete host.__ASKR_WRAPPER_HOST;
-	} catch {}
+		clearDelegatedHandlersForElement(element);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
 }
-function pruneComponentHostInstances(host, retainedInstances) {
-	const retained = new Set(retainedInstances);
-	const nextInstances = [];
-	const staleInstances = /* @__PURE__ */ new Set();
-	const retainOrMarkStale = (instance) => {
-		if (!instance) return;
-		if (retained.has(instance)) {
-			if (!nextInstances.includes(instance)) nextInstances.push(instance);
-			return;
+function cleanupElementReactiveProps(element, cleanupErrors) {
+	if (!elementReactivePropsCleanup.has(element)) return;
+	const entries = [];
+	forEachElementReactivePropCleanup(element, (entry) => entries.push(entry));
+	elementReactivePropsCleanup.delete(element);
+	for (const entry of entries) try {
+		entry.cleanup();
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+}
+function cleanupElementRef(element, cleanupErrors) {
+	try {
+		removeElementRef(element);
+	} catch (error) {
+		elementRefs.delete(element);
+		cleanupErrors.push(error);
+	}
+}
+function cleanupElementInstances(element, retainedInstances, cleanedInstances, cleanupErrors) {
+	const instances = new Set(element.__ASKR_INSTANCES ?? []);
+	if (element.__ASKR_INSTANCE) instances.add(element.__ASKR_INSTANCE);
+	for (const instance of instances) {
+		if (retainedInstances.has(instance) || cleanedInstances.has(instance)) continue;
+		cleanedInstances.add(instance);
+		try {
+			cleanupComponent(instance);
+		} catch (error) {
+			cleanupErrors.push(error);
 		}
-		staleInstances.add(instance);
+	}
+}
+function clearHostMetadata(element, cleanupErrors) {
+	for (const property of [
+		"__ASKR_INSTANCE",
+		"__ASKR_INSTANCES",
+		"__ASKR_WRAPPER_HOST"
+	]) try {
+		delete element[property];
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+}
+function pruneComponentHostInstances(host, retainedInstances) {
+	const hadInstanceList = Object.prototype.hasOwnProperty.call(host, "__ASKR_INSTANCES");
+	const hadPrimaryInstance = Object.prototype.hasOwnProperty.call(host, "__ASKR_INSTANCE");
+	const previousInstanceList = host.__ASKR_INSTANCES?.slice();
+	const previousPrimaryInstance = host.__ASKR_INSTANCE;
+	const previousInstances = collectHostInstances(host);
+	const commit = () => {
+		const retained = new Set(retainedInstances);
+		const currentInstances = collectHostInstances(host);
+		const nextInstances = Array.from(currentInstances).filter((instance) => retained.has(instance));
+		for (const instance of retained) if (instance.target === host && !nextInstances.includes(instance)) nextInstances.push(instance);
+		writeHostInstances(host, nextInstances);
+		cleanupHostInstances(Array.from(currentInstances).filter((instance) => !retained.has(instance)), "Component host pruning failed");
+	};
+	const rollback = () => {
+		const currentInstances = collectHostInstances(host);
+		try {
+			if (hadInstanceList) host.__ASKR_INSTANCES = previousInstanceList;
+			else delete host.__ASKR_INSTANCES;
+			if (hadPrimaryInstance) host.__ASKR_INSTANCE = previousPrimaryInstance;
+			else delete host.__ASKR_INSTANCE;
+		} catch {}
+		cleanupHostInstances(Array.from(currentInstances).filter((instance) => !previousInstances.has(instance)), "Provisional component host cleanup failed");
 	};
-	for (const instance of host.__ASKR_INSTANCES ?? []) retainOrMarkStale(instance);
-	retainOrMarkStale(host.__ASKR_INSTANCE);
-	for (const instance of staleInstances) cleanupComponent(instance);
+	if (!registerLifecycleTransaction({}, commit, rollback)) commit();
+}
+function collectHostInstances(host) {
+	const instances = /* @__PURE__ */ new Set();
+	for (const instance of host.__ASKR_INSTANCES ?? []) instances.add(instance);
+	if (host.__ASKR_INSTANCE) instances.add(host.__ASKR_INSTANCE);
+	return instances;
+}
+function writeHostInstances(host, instances) {
 	try {
-		if (nextInstances.length > 0) {
-			host.__ASKR_INSTANCES = nextInstances;
-			host.__ASKR_INSTANCE = nextInstances[0];
+		if (instances.length > 0) {
+			host.__ASKR_INSTANCES = instances;
+			host.__ASKR_INSTANCE = instances[0];
 		} else {
 			delete host.__ASKR_INSTANCES;
 			delete host.__ASKR_INSTANCE;
 		}
 	} catch {}
 }
+function cleanupHostInstances(instances, message) {
+	const cleanupErrors = [];
+	for (const instance of instances) try {
+		cleanupComponent(instance);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	if (cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, message);
+}
 //#endregion
 export { cleanupDetachedComponentHost, pruneComponentHostInstances };
-
-//# sourceMappingURL=component-host-cleanup.js.map

package/dist/renderer/component-host-instances.js

@@ -1,6 +1,7 @@
+import { isProductionEnvironment } from "../common/env.js";
 import { getDevValue, incDevCounter } from "../runtime/dev-namespace.js";
 import { getCurrentInstance } from "../runtime/component-scope.js";
-import "../runtime/component-contracts.js";
+import "../runtime/index.js";
 import { extractKey } from "./utils.js";
 import { ROUTE_ROOT_COMPONENT } from "../common/router-internal.js";
 //#region src/renderer/component-host-instances.ts
@@ -19,6 +20,7 @@ function getVNodeComponentInstance(node) {
 function setVNodeComponentInstance(node, instance) {
 	if (typeof node !== "object" || node === null) return;
 	const objectNode = node;
+	vnodeComponentInstances.delete(objectNode);
 	if (Object.prototype.hasOwnProperty.call(objectNode, "__instance")) try {
 		objectNode.__instance = instance;
 		return;
@@ -29,8 +31,30 @@ function setVNodeComponentInstance(node, instance) {
 	} catch {}
 	vnodeComponentInstances.set(objectNode, instance);
 }
+/** @internal Restore component ownership after provisional creation fails. */
+function restoreVNodeComponentInstance(node, instance) {
+	if (typeof node !== "object" || node === null) return;
+	const objectNode = node;
+	vnodeComponentInstances.delete(objectNode);
+	if (instance) {
+		setVNodeComponentInstance(objectNode, instance);
+		return;
+	}
+	try {
+		delete objectNode.__instance;
+	} catch {
+		try {
+			objectNode.__instance = void 0;
+		} catch {}
+	}
+}
 let fallbackComponentInstanceId = 0;
+const PRODUCTION_BUILD_ENABLED = isProductionEnvironment();
 function nextComponentInstanceId() {
+	if (PRODUCTION_BUILD_ENABLED || isProductionEnvironment()) {
+		fallbackComponentInstanceId++;
+		return `comp-${fallbackComponentInstanceId}`;
+	}
 	const key = "__COMPONENT_INSTANCE_ID";
 	try {
 		incDevCounter(key);
@@ -48,18 +72,45 @@ function inheritComponentKey(target, source) {
 		if (!target.props) target.props = {};
 		const props = target.props;
 		if (props["data-key"] === void 0) props["data-key"] = String(inheritedKey);
+		if (props["data-askr-key-kind"] === void 0) props["data-askr-key-kind"] = typeof inheritedKey;
 	}
 	return target;
 }
-function findHostInstanceByType(host, type) {
+function setComponentOwnershipIdentity(instance, node, parent, wrapperDepth = 0, position) {
+	instance._vnodeOwner = typeof node === "object" && node !== null ? node : void 0;
+	instance._vnodeParent = parent;
+	const key = extractKey(node);
+	if (key === void 0) delete instance._vnodeKey;
+	else instance._vnodeKey = key;
+	instance._vnodePosition = position;
+	instance._wrapperDepth = wrapperDepth;
+}
+function findHostInstanceByType(host, type, node, parent, wrapperDepth) {
 	const instances = host.__ASKR_INSTANCES;
-	if (instances && instances.length > 0) for (let index = instances.length - 1; index >= 0; index -= 1) {
-		const instance = instances[index];
-		if (instance.fn === type) return instance;
+	if (instances && instances.length > 0) {
+		const vnodeOwner = getVNodeComponentInstance(node);
+		if (vnodeOwner && vnodeOwner.fn === type && instances.includes(vnodeOwner)) return vnodeOwner;
+		const key = extractKey(node);
+		const identityMatches = instances.filter((instance) => {
+			if (instance.fn !== type) return false;
+			if (parent !== void 0 && instance._vnodeParent !== parent) return false;
+			if (key !== void 0 && instance._vnodeKey !== key) return false;
+			if (wrapperDepth !== void 0 && instance._wrapperDepth !== wrapperDepth) return false;
+			return true;
+		});
+		if (identityMatches.length === 1) return identityMatches[0];
+		if (identityMatches.length > 1 && key !== void 0) return identityMatches[identityMatches.length - 1];
+		const sameType = instances.filter((instance) => instance.fn === type);
+		if (sameType.length === 1) return sameType[0];
+		return null;
+	}
+	if (host.__ASKR_INSTANCE?.fn === type) {
+		const instance = host.__ASKR_INSTANCE;
+		const key = extractKey(node);
+		if ((parent === void 0 || instance._vnodeParent === parent) && (key === void 0 || instance._vnodeKey === key) && (wrapperDepth === void 0 || instance._wrapperDepth === wrapperDepth)) return instance;
+		if (node === void 0 && parent === void 0 && wrapperDepth === void 0) return instance;
 	}
-	return host.__ASKR_INSTANCE?.fn === type ? host.__ASKR_INSTANCE : null;
+	return null;
 }
 //#endregion
-export { findHostInstanceByType, getVNodeComponentInstance, inheritComponentCleanupStrict, inheritComponentKey, isRouteRootComponentVNode, nextComponentInstanceId, setVNodeComponentInstance };
-
-//# sourceMappingURL=component-host-instances.js.map
+export { findHostInstanceByType, getVNodeComponentInstance, inheritComponentCleanupStrict, inheritComponentKey, isRouteRootComponentVNode, nextComponentInstanceId, restoreVNodeComponentInstance, setComponentOwnershipIdentity, setVNodeComponentInstance };

package/dist/renderer/component-host-replacement.js

@@ -0,0 +1,105 @@
+import { cleanupComponent } from "../runtime/component-cleanup.js";
+import { registerLifecycleRollback, registerLifecycleTransaction } from "../runtime/lifecycle-batch.js";
+import "../runtime/index.js";
+import { elementRefs, removeElementRef, updateElementRef } from "./cleanup.js";
+import { cleanupDetachedComponentHost } from "./component-host-cleanup.js";
+import { restoreVNodeComponentInstance } from "./component-host-instances.js";
+//#region src/renderer/component-host-replacement.ts
+function cleanupProvisionalComponentInstance(instance) {
+	try {
+		cleanupComponent(instance);
+	} catch {}
+}
+function cleanupProvisionalComponentInstances(instances) {
+	for (let index = instances.length - 1; index >= 0; index -= 1) cleanupProvisionalComponentInstance(instances[index]);
+}
+function createRetainedHostInstanceSet(owner, additional) {
+	const retained = /* @__PURE__ */ new Set([owner]);
+	for (const instance of additional ?? []) retained.add(instance);
+	return retained;
+}
+function cleanupReplacementNode(node, retainedInstance) {
+	if (node instanceof Element) {
+		cleanupDetachedComponentHost(node, retainedInstance);
+		return;
+	}
+	try {
+		delete node.__ASKR_INSTANCE;
+	} catch {}
+}
+function beginComponentHostReplacement(existingHost, retainedInstance, previousTarget, retainedInstances = [retainedInstance], disposeOnRollback = false) {
+	const parent = existingHost.parentNode;
+	const previousRef = elementRefs.get(existingHost);
+	let previousRefDetached = false;
+	let nextDom = null;
+	let didReplace = false;
+	let replacementAttempted = false;
+	let finished = false;
+	const commit = () => {
+		if (finished) return;
+		finished = true;
+		if (replacementAttempted && didReplace) cleanupDetachedComponentHost(existingHost, retainedInstances);
+	};
+	const rollback = () => {
+		if (finished) return;
+		finished = true;
+		if (!replacementAttempted) return;
+		const rollbackErrors = [];
+		if (nextDom && nextDom !== existingHost) try {
+			cleanupReplacementNode(nextDom, retainedInstance);
+		} catch (error) {
+			rollbackErrors.push(error);
+		}
+		try {
+			if (disposeOnRollback) cleanupComponent(retainedInstance);
+			else retainedInstance.target = previousTarget;
+		} catch (error) {
+			rollbackErrors.push(error);
+		}
+		if (previousRefDetached && previousRef) try {
+			updateElementRef(existingHost, previousRef);
+		} catch (error) {
+			rollbackErrors.push(error);
+		}
+		if (rollbackErrors.length > 0) throw new AggregateError(rollbackErrors, "Component host replacement rollback failed");
+	};
+	const staged = registerLifecycleTransaction({}, commit, rollback);
+	const replace = (materialize, prepareNextDom) => {
+		replacementAttempted = true;
+		if (!staged && previousRef) {
+			removeElementRef(existingHost);
+			previousRefDetached = true;
+		}
+		try {
+			nextDom = materialize();
+			prepareNextDom(nextDom);
+			if (parent && nextDom !== existingHost) {
+				parent.replaceChild(nextDom, existingHost);
+				didReplace = true;
+			}
+		} catch (error) {
+			if (!staged) try {
+				rollback();
+			} catch {}
+			throw error;
+		}
+		if (!staged) commit();
+		return nextDom;
+	};
+	return { replace };
+}
+function registerVNodeComponentInstanceRollback(node, previousInstance, provisionalInstance) {
+	let restored = false;
+	const restoreOwnership = () => {
+		if (restored) return;
+		restored = true;
+		restoreVNodeComponentInstance(node, previousInstance);
+	};
+	(provisionalInstance.cleanupFns ??= []).push(restoreOwnership);
+	registerLifecycleRollback(() => {
+		restoreOwnership();
+		cleanupProvisionalComponentInstance(provisionalInstance);
+	});
+}
+//#endregion
+export { beginComponentHostReplacement, cleanupProvisionalComponentInstance, cleanupProvisionalComponentInstances, createRetainedHostInstanceSet, registerVNodeComponentInstanceRollback };

package/dist/renderer/component-host-results.js

@@ -0,0 +1,138 @@
+import { _isDOMElement } from "../common/vnode.js";
+import "./types.js";
+import { getVNodeContextFrame, markVNodeTreeWithContextFrame, withContext } from "../runtime/context.js";
+import { getCurrentInstance } from "../runtime/component-scope.js";
+import { cleanupComponent } from "../runtime/component-cleanup.js";
+import { isPromiseLike } from "../common/promise.js";
+import { captureInlineRenderSnapshot, createComponentInstance, mountInstanceInline, renderComponentInline, warnUnusedStateReads } from "../runtime/component-internal.js";
+import "../runtime/index.js";
+import { getRendererDOMHost } from "./dom-host.js";
+import { findHostInstanceByType, getVNodeComponentInstance, inheritComponentCleanupStrict, isRouteRootComponentVNode, nextComponentInstanceId, restoreVNodeComponentInstance, setComponentOwnershipIdentity, setVNodeComponentInstance } from "./component-host-instances.js";
+import { cleanupProvisionalComponentInstance, cleanupProvisionalComponentInstances, registerVNodeComponentInstanceRollback } from "./component-host-replacement.js";
+//#region src/renderer/component-host-results.ts
+function materializeComponentResultNode(childInstance, result, parentNamespace) {
+	const dom = getRendererDOMHost().createComponentResultNode(childInstance.fn, result, parentNamespace);
+	if (dom instanceof Element) {
+		mountInstanceInline(childInstance, dom);
+		return dom;
+	}
+	if (!dom) {
+		const placeholder = document.createComment("");
+		try {
+			placeholder.__ASKR_INSTANCE = childInstance;
+		} catch {}
+		childInstance._placeholder = placeholder;
+		mountInstanceInline(childInstance, null);
+		return placeholder;
+	}
+	const host = document.createElement("div");
+	host.appendChild(dom);
+	host.__ASKR_WRAPPER_HOST = true;
+	mountInstanceInline(childInstance, host);
+	return host;
+}
+function resolveNestedComponentResult(result, snapshot, parentInstance) {
+	let currentResult = result;
+	let activeSnapshot = snapshot;
+	let depth = 0;
+	while (_isDOMElement(currentResult) && typeof currentResult.type === "function" && depth < 16) {
+		const nestedSnapshot = getVNodeContextFrame(currentResult) ?? activeSnapshot;
+		const nestedInstance = createComponentInstance(nextComponentInstanceId(), currentResult.type, currentResult.props ?? {}, null);
+		nestedInstance.isRoot = isRouteRootComponentVNode(currentResult);
+		nestedInstance.parentInstance = parentInstance;
+		nestedInstance.portalScope = parentInstance?.portalScope ?? nestedInstance.portalScope;
+		inheritComponentCleanupStrict(nestedInstance);
+		if (nestedSnapshot) nestedInstance.ownerFrame = nestedSnapshot;
+		let nextResult;
+		try {
+			nextResult = withContext(nestedSnapshot ?? null, () => renderComponentInline(nestedInstance));
+			if (isPromiseLike(nextResult)) throw new Error("Async components are not supported. Components must return synchronously.");
+		} catch (error) {
+			cleanupProvisionalComponentInstance(nestedInstance);
+			throw error;
+		}
+		cleanupComponent(nestedInstance);
+		activeSnapshot = nestedSnapshot ?? null;
+		currentResult = nextResult;
+		depth += 1;
+	}
+	return currentResult;
+}
+function resolveHostNestedComponentResult(host, retainedInstance, result, snapshot, retainedInstances) {
+	let currentResult = result;
+	let activeSnapshot = snapshot;
+	let depth = 0;
+	const createdInstances = [];
+	const createdVNodeOwners = [];
+	try {
+		while (_isDOMElement(currentResult) && typeof currentResult.type === "function" && depth < 16) {
+			const nestedVNode = currentResult;
+			const nestedSnapshot = getVNodeContextFrame(currentResult) ?? activeSnapshot;
+			let nestedInstance = findHostInstanceByType(host, currentResult.type, nestedVNode, retainedInstance, depth);
+			const hadNestedInstance = !!nestedInstance;
+			if (!nestedInstance) {
+				nestedInstance = createComponentInstance(nextComponentInstanceId(), currentResult.type, nestedVNode.props ?? {}, null);
+				createdInstances.push(nestedInstance);
+				const previous = getVNodeComponentInstance(nestedVNode);
+				createdVNodeOwners.push({
+					node: nestedVNode,
+					previous
+				});
+				registerVNodeComponentInstanceRollback(nestedVNode, previous, nestedInstance);
+			}
+			setComponentOwnershipIdentity(nestedInstance, nestedVNode, retainedInstance, depth);
+			if (hadNestedInstance) captureInlineRenderSnapshot(nestedInstance);
+			setVNodeComponentInstance(currentResult, nestedInstance);
+			nestedInstance.isRoot = isRouteRootComponentVNode(currentResult);
+			nestedInstance.parentInstance = retainedInstance;
+			nestedInstance.portalScope = retainedInstance.portalScope ?? nestedInstance.portalScope;
+			inheritComponentCleanupStrict(nestedInstance);
+			nestedInstance.props = (nestedVNode.props ?? {}) || {};
+			if (nestedSnapshot) nestedInstance.ownerFrame = nestedSnapshot;
+			const nextResult = withContext(nestedSnapshot ?? null, () => renderComponentInline(nestedInstance));
+			if (isPromiseLike(nextResult)) throw new Error("Async components are not supported. Components must return synchronously.");
+			retainedInstances.add(nestedInstance);
+			warnUnusedStateReads(nestedInstance);
+			activeSnapshot = nestedSnapshot ?? null;
+			currentResult = markVNodeTreeWithContextFrame(nextResult, activeSnapshot);
+			depth += 1;
+		}
+		for (const instance of createdInstances) mountInstanceInline(instance, host);
+	} catch (error) {
+		for (let index = createdVNodeOwners.length - 1; index >= 0; index -= 1) {
+			const owner = createdVNodeOwners[index];
+			restoreVNodeComponentInstance(owner.node, owner.previous);
+		}
+		cleanupProvisionalComponentInstances(createdInstances);
+		throw error;
+	}
+	return currentResult;
+}
+function resolveWrapperHostResult(host, result, snapshot, retainedInstances) {
+	let currentResult = result;
+	let activeSnapshot = snapshot;
+	let depth = 0;
+	while (_isDOMElement(currentResult) && typeof currentResult.type === "function" && depth < 16) {
+		const nestedSnapshot = getVNodeContextFrame(currentResult) ?? activeSnapshot;
+		const nestedInstance = findHostInstanceByType(host, currentResult.type, currentResult, getCurrentInstance(), depth);
+		if (!nestedInstance) break;
+		captureInlineRenderSnapshot(nestedInstance);
+		setComponentOwnershipIdentity(nestedInstance, currentResult, getCurrentInstance(), depth);
+		nestedInstance.props = (currentResult.props ?? {}) || {};
+		nestedInstance.parentInstance = getCurrentInstance();
+		nestedInstance.isRoot = isRouteRootComponentVNode(currentResult);
+		nestedInstance.portalScope = getCurrentInstance()?.portalScope ?? nestedInstance.portalScope;
+		inheritComponentCleanupStrict(nestedInstance);
+		if (nestedSnapshot) nestedInstance.ownerFrame = nestedSnapshot;
+		const nextResult = withContext(nestedSnapshot ?? null, () => renderComponentInline(nestedInstance));
+		if (isPromiseLike(nextResult)) throw new Error("Async components are not supported. Components must return synchronously.");
+		retainedInstances.add(nestedInstance);
+		warnUnusedStateReads(nestedInstance);
+		activeSnapshot = nestedSnapshot ?? null;
+		currentResult = nextResult;
+		depth += 1;
+	}
+	return markVNodeTreeWithContextFrame(currentResult, activeSnapshot);
+}
+//#endregion
+export { materializeComponentResultNode, resolveHostNestedComponentResult, resolveNestedComponentResult, resolveWrapperHostResult };