marko 6.4.0 → 6.4.2

package/dist/debug/html.js

@@ -164,6 +164,16 @@ function assertValidAttrValue(name, value) {
 	const unrenderable = describeUnrenderable(value);
 	if (unrenderable) throw new Error(`The \`${name}\` attribute cannot be ${unrenderable}.`);
 }
+function _assert_class_toggles(classes, toggles) {
+	{
+		const written = new Set(classes.split(" "));
+		for (const toggle of toggles) {
+			const names = new Set(toggle.split(" "));
+			for (const name of names) if (written.has(name)) throw new Error(`The toggled class \`${name}\` is also written by another part of the \`class\` value; a toggled class may appear only once.`);
+			for (const name of names) written.add(name);
+		}
+	}
+}
 function assertValidTextValue(value) {
 	const unrenderable = describeUnrenderable(value);
 	if (unrenderable) throw new Error(`Text content cannot be ${unrenderable}.`);
@@ -220,18 +230,18 @@ function _hoist_read_error() {
 function _assert_hoist(value) {
 	if (value !== void 0 && typeof value !== "function") throw new Error(`Hoisted values must be functions, received type "${typeof value}".`);
 }
-function assertExclusiveAttrs(attrs, onError = throwErr) {
+function assertExclusiveAttrs(attrs, onError = throwErr, isSet = isTruthy) {
 	if (attrs) {
 		let exclusiveAttrs;
-		if (attrs.checkedChange) (exclusiveAttrs ||= []).push("checkedChange");
+		if (isSet(attrs.checkedChange)) (exclusiveAttrs ||= []).push("checkedChange");
 		if ("checkedValue" in attrs) {
 			(exclusiveAttrs ||= []).push("checkedValue");
 			if ("checked" in attrs) exclusiveAttrs.push("checked");
-		} else if (attrs.checkedValueChange) {
+		} else if (isSet(attrs.checkedValueChange)) {
 			(exclusiveAttrs ||= []).push("checkedValueChange");
 			if ("checked" in attrs) exclusiveAttrs.push("checked");
 		}
-		if (attrs.valueChange) {
+		if (isSet(attrs.valueChange)) {
 			(exclusiveAttrs ||= []).push("valueChange");
 			if ("checked" in attrs && !exclusiveAttrs.includes("checked")) exclusiveAttrs.push("checked");
 		}
@@ -247,6 +257,9 @@ function assertHandlerIsFunction(name, value) {
 function assertValidTagName(tagName) {
 	if (!/^[a-z][a-z0-9._-]*$/i.test(tagName)) throw new Error(`Invalid tag name: "${tagName}". Tag names must start with a letter and contain only letters, numbers, periods, hyphens, and underscores.`);
 }
+function isTruthy(value) {
+	return value;
+}
 function throwErr(msg) {
 	throw new Error(msg);
 }
@@ -293,11 +306,12 @@ function forUntil(until, from, step, cb) {
 }
 //#endregion
 //#region src/common/opt.ts
-function forEach(opt, cb) {
+function reduce(opt, cb, acc) {
 	if (opt) {
-		if (Array.isArray(opt)) for (const item of opt) cb(item);
-		else cb(opt);
+		if (Array.isArray(opt)) for (const item of opt) acc = cb(acc, item);
+		else acc = cb(acc, opt);
 	}
+	return acc;
 }
 function push(opt, item) {
 	return opt ? Array.isArray(opt) ? (opt.push(item), opt) : [opt, item] : item;
@@ -647,6 +661,17 @@ var Serializer = class {
 			channel
 		});
 	}
+	dropCall(value, object, property) {
+		const { mutated } = this.#state;
+		for (let i = 0; i < mutated.length; i++) {
+			const mutation = mutated[i];
+			if (mutation.value === value && mutation.object === object && mutation.property === property) {
+				mutated.splice(i, 1);
+				return true;
+			}
+		}
+		return false;
+	}
 };
 function register(id, val, scope, locals) {
 	REGISTRY.set(val, {
@@ -740,7 +765,7 @@ function writeAssigned(state) {
 			if (writeProp(state, mutation.object, null, "")) {
 				const objectRef = state.refs.get(mutation.object);
 				if (objectRef && objectRef.scopeId === void 0) {
-					if (!objectRef.id) {
+					if (!objectRef.id && !isAncestorChannelRef(state, objectRef)) {
 						objectRef.id = nextRefAccess(state);
 						state.buf[objectStartIndex] = "(" + objectRef.id + "=" + state.buf[objectStartIndex];
 						state.buf.push(")");
@@ -753,7 +778,7 @@ function writeAssigned(state) {
 			const valueStartIndex = state.buf.push(toAccess(toObjectKey(mutation.property)) + "(");
 			if (mutation.value === void 0) {} else if (writeProp(state, mutation.value, null, "")) {
 				const valueRef = typeof mutation.value === "string" ? state.strs.get(mutation.value) : state.refs.get(mutation.value);
-				if (valueRef && !valueRef.id && valueRef.scopeId === void 0) {
+				if (valueRef && !valueRef.id && valueRef.scopeId === void 0 && !isAncestorChannelRef(state, valueRef)) {
 					valueRef.id = mutation.valueId || nextRefAccess(state);
 					state.buf[valueStartIndex] = valueRef.id + "=" + state.buf[valueStartIndex];
 				}
@@ -770,7 +795,7 @@ function writeCallArg(state, val) {
 		state.buf.push("$");
 	} else if (writeProp(state, val, null, "")) {
 		const ref = state.refs.get(val) || state.strs.get(val);
-		if (ref && ref.id === null) assignId(state, ref);
+		if (ref) ensureId(state, ref);
 	} else state.buf.push("void 0");
 }
 function hasChannelMutations(state) {
@@ -852,8 +877,7 @@ function writeRegistered(state, val, parent, accessor, registered) {
 			state.buf.push(registered.access + "(_(" + scopeId + ")");
 			for (const local of locals) {
 				state.buf.push(",");
-				if (local) writePlainObject(state, local, new Reference(ref, null, state.flushId, state.buf.length));
-				else state.buf.push("0");
+				writePlainObject(state, local, newArgReference(state, ref, local));
 			}
 		} else state.buf.push("_(" + scopeId + "," + quoteRegisterId(registered.id));
 		state.buf.push(")");
@@ -1162,6 +1186,17 @@ function writeArrayArg(state, ref, items, assignsPrefix, plainPrefix, needsId) {
 	}
 	state.buf.push(")");
 }
+function newArgReference(state, parent, val) {
+	for (const key in val) {
+		const member = val[key];
+		if (isDedupedMember(member) && !(typeof member === "string" ? state.strs.has(member) : state.refs.has(member))) {
+			const ref = new Reference(parent, null, state.flushId, null, nextRefAccess(state));
+			state.buf.push(ref.id + "=");
+			return ref;
+		}
+	}
+	return new Reference(parent, null, state.flushId, state.buf.length);
+}
 function isDedupedMember(val) {
 	switch (typeof val) {
 		case "object": return val !== null && val[K_SCOPE_ID] === void 0;
@@ -1358,20 +1393,9 @@ function writeResponse(state, val, ref) {
 }
 function writeIntl(state, val, name, ref) {
 	const { locale, ...options } = val.resolvedOptions();
-	let needsId = false;
-	for (const key in options) if (isDedupedMember(options[key])) {
-		needsId = true;
-		break;
-	}
 	state.buf.push("new Intl." + name + "(" + quote(locale, 0) + ",");
-	let optionsRef;
-	if (needsId) {
-		optionsRef = new Reference(ref, null, state.flushId, null, nextRefAccess(state));
-		state.buf.push(optionsRef.id + "={");
-	} else {
-		optionsRef = new Reference(ref, null, state.flushId, state.buf.length);
-		state.buf.push("{");
-	}
+	const optionsRef = newArgReference(state, ref, options);
+	state.buf.push("{");
 	writeObjectProps(state, options, optionsRef);
 	state.buf.push("})");
 	return true;
@@ -1395,7 +1419,7 @@ function writeReadableStream(state, val, ref) {
 	const handle = newAsyncHandle(state, ref, iterId);
 	const onFulfilled = ({ value, done }) => {
 		if (done) writeAsyncCall(state, boundary, handle, "r", value, channel);
-		else if (!boundary.signal.aborted) {
+		else if (!boundary.aborted) {
 			reader.read().then(onFulfilled, onRejected);
 			boundary.startAsync();
 			writeAsyncCall(state, boundary, handle, "f", value, channel);
@@ -1442,13 +1466,10 @@ function writeGenerator(state, iter, ref) {
 		state.buf.push("," + holder.id + "={}");
 		writeProp(state, returnValue, holder, "v");
 	} else if (returnValue !== void 0) {
-		const sepIndex = state.buf.push(",") - 1;
+		state.buf.push(",");
 		if (writeProp(state, returnValue, ref, "") && isDedupedMember(returnValue)) {
 			const retRef = typeof returnValue === "string" ? state.strs.get(returnValue) : state.refs.get(returnValue);
-			if (retRef && !retRef.id && retRef.scopeId === void 0) {
-				retRef.id = nextRefAccess(state);
-				state.buf[sepIndex] = "," + retRef.id + "=";
-			}
+			if (retRef) ensureId(state, retRef);
 		}
 	}
 	state.buf.push(")");
@@ -1464,7 +1485,7 @@ function writeAsyncGenerator(state, iter, ref) {
 	const handle = newAsyncHandle(state, ref, iterId);
 	const onFulfilled = ({ value, done }) => {
 		if (done) writeAsyncCall(state, boundary, handle, "r", value, channel);
-		else if (!boundary.signal.aborted) {
+		else if (!boundary.aborted) {
 			iter.next().then(onFulfilled, onRejected);
 			boundary.startAsync();
 			writeAsyncCall(state, boundary, handle, "f", value, channel);
@@ -1511,7 +1532,7 @@ function writeMaybeIterableProps(state, val, ref) {
 	return sep;
 }
 function writeAsyncCall(state, boundary, handle, method, value, channel, valueId = null) {
-	if (boundary.signal.aborted) return;
+	if (boundary.aborted) return;
 	state.mutated.push({
 		value,
 		object: handle,
@@ -1569,6 +1590,7 @@ const accessorPrefixDescriptions = {
 	ControlledType: "the controlled type",
 	ControlledValue: "the controlled value",
 	DynamicHTMLLastChild: "the dynamic html",
+	DynamicHTMLValue: "the dynamic html value",
 	EventAttributes: "the event handlers",
 	IdFallback: "the generated id",
 	KeyedScopes: "the keyed scopes",
@@ -1607,6 +1629,9 @@ function trackChannel(state, ref) {
 	}
 	return false;
 }
+function isAncestorChannelRef(state, ref) {
+	return ref.channel?.readyId !== state.channel?.readyId;
+}
 function abortUnreachableChannel(state, val) {
 	const err = new TypeError("Unable to serialize a value shared between independently lazy loaded content. Values shared this way must also be serialized by content that is not lazily loaded, or by a common parent.", { cause: val });
 	err.stack = void 0;
@@ -1700,11 +1725,10 @@ function quote(str, startPos) {
 	return "\"" + (lastPos === startPos ? str : result + str.slice(lastPos)) + "\"";
 }
 function writeRef(state, ref) {
-	if (ref.id === null && ref.scopeId === void 0 && ref.path === null && (ref.pos === null || ref.flushId !== state.flushId)) {
+	if (ref.id === null && ref.scopeId === void 0 && ref.path === null && (ref.pos === null || ref.flushId !== state.flushId) && !isAncestorChannelRef(state, ref)) {
 		ref.path = accessPath(state, ref);
 		ref.pos = state.buf.length;
 		ref.flushId = state.flushId;
-		ref.channel = state.channel;
 		state.buf.push(ref.path);
 	} else state.buf.push(ensureId(state, ref));
 }
@@ -1725,23 +1749,26 @@ function accessId(state, ref) {
 }
 function assignId(state, ref) {
 	const { pos } = ref;
-	ref.id = nextRefAccess(state);
 	if (pos !== null && ref.flushId === state.flushId) {
+		ref.id = nextRefAccess(state);
 		if (pos === 0) state.buf[0] = ref.id + "=" + state.buf[0];
 		else state.buf[pos - 1] += ref.id + "=";
 		return ref.id;
 	}
-	ref.channel = state.channel;
+	if (isAncestorChannelRef(state, ref)) return ref.path || accessPath(state, ref);
+	ref.id = nextRefAccess(state);
 	return ref.id + "=" + (ref.path || accessPath(state, ref));
 }
 function accessPath(state, ref) {
 	let cur = ref;
 	let accessPrevValue = "";
 	do {
+		if (cur.accessor === null) throw new Error("Unable to serialize a reused value: no access path reaches where it was first written, and it has no id.");
 		accessPrevValue = toAccess(cur.accessor) + accessPrevValue;
 		const parent = cur.parent;
 		if (parent.id) {
-			if (trackChannel(state, parent) || !parent.parent) return parent.id + accessPrevValue;
+			trackChannel(state, parent);
+			return parent.id + accessPrevValue;
 		}
 		if (parent.flushId === state.flushId || parent.scopeId !== void 0) return accessId(state, parent) + accessPrevValue;
 		cur = parent;
@@ -1969,9 +1996,9 @@ function _attrs(data, nodeAccessor, scopeId, tagName) {
 	}
 	return result;
 }
-function _attrs_content(data, nodeAccessor, scopeId, tagName, serializeReason) {
+function _attrs_content(data, nodeAccessor, scopeId, tagName, markerGuard) {
 	_html(`${_attrs(data, nodeAccessor, scopeId, tagName)}>`);
-	_attr_content(nodeAccessor, scopeId, data?.content, serializeReason);
+	_attr_content(nodeAccessor, scopeId, data?.content, markerGuard);
 }
 function _attrs_partial(data, skip, nodeAccessor, scopeId, tagName) {
 	const partial = {};
@@ -1985,9 +2012,9 @@ function _attrs_partial(data, skip, nodeAccessor, scopeId, tagName) {
 	});
 	return _attrs(partial, nodeAccessor, scopeId, tagName);
 }
-function _attrs_partial_content(data, skip, nodeAccessor, scopeId, tagName, serializeReason) {
+function _attrs_partial_content(data, skip, nodeAccessor, scopeId, tagName, markerGuard) {
 	_html(`${_attrs_partial(data, skip, nodeAccessor, scopeId, tagName)}>`);
-	_attr_content(nodeAccessor, scopeId, data?.content, serializeReason);
+	_attr_content(nodeAccessor, scopeId, data?.content, markerGuard);
 }
 function writeControlledScope(type, scopeId, nodeAccessor, value, valueChange, serializeType) {
 	var handlerName = [
@@ -2116,11 +2143,6 @@ const REORDER_RUNTIME_CODE = `((runtime) => {
 
     if (op == "#") {
       (placeholders[id] = placeholder).i++;
-    } else if (op == "!") {
-      if (runtime.l[id] && placeholders[id]) {
-        nextSibling = node.nextSibling;
-        onNextSibling = () => placeholders[id].c();
-      }
     } else if (node.tagName == "T" && (id = node.getAttribute(runtime.i))) {
       nextSibling = node.nextSibling;
       onNextSibling = () => {
@@ -2132,7 +2154,8 @@ const REORDER_RUNTIME_CODE = `((runtime) => {
         placeholders[id] ||
         (placeholderRoot = placeholders[id] =
           {
-            i: runtime.l[id] ? 1 : 2,
+            // The writer streams a reorder only after its markers.
+            i: 1,
             r: id,
             // Resume may still walk markers inside the dropped placeholder, so
             // park it in any detached parent (a bare <t> clone is the cheapest).
@@ -2240,8 +2263,17 @@ function _html(html) {
 function writeScript(script) {
 	$chunk.writeScript(script);
 }
-function _script(scopeId, registryId, serializeMarker) {
-	if (serializeMarker === 0 && ($chunk.serializeState.readyId || $chunk.context?.[kIsAsync])) _resume_branch(scopeId);
+function catchableBoundary() {
+	const { boundary } = $chunk;
+	return boundary.withinCatch ? boundary : null;
+}
+function mayDrop(written) {
+	const { boundary } = $chunk;
+	for (let cur = written; cur && !isWithin(boundary, cur); cur = cur.parent) if (cur.aborted || cur.count) return true;
+	return false;
+}
+function _script(scopeId, registryId, markerGuard) {
+	if (markerGuard === 0 && ($chunk.serializeState.readyId || $chunk.context?.[kIsAsync])) _resume_branch(scopeId);
 	$chunk.boundary.state.needsMainRuntime = true;
 	$chunk.writeEffect(scopeId, registryId);
 }
@@ -2289,8 +2321,8 @@ function _resume_branch(scopeId) {
 	const branchId = $chunk.context?.[kBranchId];
 	if (branchId !== void 0 && branchId !== scopeId) writeScope(scopeId, { [ClosestBranchId]: branchId });
 }
-function _attr_content(nodeAccessor, scopeId, content, serializeReason) {
-	const shouldResume = serializeReason !== 0;
+function _attr_content(nodeAccessor, scopeId, content, markerGuard) {
+	const shouldResume = markerGuard !== 0;
 	const render = normalizeServerRender(content);
 	const branchId = _peek_scope_id();
 	if (render) {
@@ -2324,47 +2356,47 @@ function writeScopePassive(scopeId, partialScope) {
 	passive[scopeId] = Object.assign(passive[scopeId] || {}, partialScope);
 	return scope;
 }
-function _show_start(display, mark) {
+function _show_start(display, markerGuard, branchExprGuard, parentEndTag) {
 	if (display) {
-		if (mark) $chunk.writeHTML($chunk.boundary.state.mark("[", ""));
+		if (resumesMarker(markerGuard, branchExprGuard, parentEndTag)) $chunk.writeHTML($chunk.boundary.state.mark("[", ""));
 	} else $chunk.writeHTML("<t hidden>");
 }
-function _show_end(scopeId, accessor, display, serializeMarker, serializeStateful, parentEndTag, singleNode) {
+function _show_end(scopeId, accessor, display, markerGuard, branchExprGuard, parentEndTag, singleNode) {
 	const branchId = _scope_id();
 	const wrap = !display;
 	if (wrap) $chunk.writeHTML("</t>");
-	writeBranchEnd(scopeId, accessor, serializeStateful, serializeMarker, parentEndTag, wrap || singleNode ? 1 : void 0, " " + branchId);
+	writeBranchEnd(scopeId, accessor, branchExprGuard, markerGuard, parentEndTag, wrap || singleNode ? 1 : void 0, " " + branchId);
 }
-function _for_of(list, cb, by, scopeId, accessor, serializeBranch, serializeMarker, serializeStateful, parentEndTag, singleNode) {
+function _for_of(list, cb, by, scopeId, accessor, branchGuard, markerGuard, branchExprGuard, parentEndTag, singleNode) {
 	forBranches(by, (each) => each ? forOf(list, (item, index) => {
 		const itemKey = forOfBy(by, item, index);
 		each(itemKey, itemKey === index, () => cb(item, index));
-	}) : forOf(list, cb), scopeId, accessor, serializeBranch, serializeMarker, serializeStateful, parentEndTag, singleNode);
+	}) : forOf(list, cb), scopeId, accessor, branchGuard, markerGuard, branchExprGuard, parentEndTag, singleNode);
 }
-function _for_in(obj, cb, by, scopeId, accessor, serializeBranch, serializeMarker, serializeStateful, parentEndTag, singleNode) {
+function _for_in(obj, cb, by, scopeId, accessor, branchGuard, markerGuard, branchExprGuard, parentEndTag, singleNode) {
 	forBranches(by, (each) => each ? forIn(obj, (key, value) => {
 		each(forInBy(by, key, value), false, () => cb(key, value));
-	}) : forIn(obj, cb), scopeId, accessor, serializeBranch, serializeMarker, serializeStateful, parentEndTag, singleNode);
+	}) : forIn(obj, cb), scopeId, accessor, branchGuard, markerGuard, branchExprGuard, parentEndTag, singleNode);
 }
-function _for_to(to, from, step, cb, by, scopeId, accessor, serializeBranch, serializeMarker, serializeStateful, parentEndTag, singleNode) {
+function _for_to(to, from, step, cb, by, scopeId, accessor, branchGuard, markerGuard, branchExprGuard, parentEndTag, singleNode) {
 	forBranches(by, (each) => {
 		let index = 0;
 		return each ? forTo(to, from, step, (value) => {
 			const itemKey = forStepBy(by, value);
 			each(itemKey, itemKey === index++, () => cb(value));
 		}) : forTo(to, from, step, cb);
-	}, scopeId, accessor, serializeBranch, serializeMarker, serializeStateful, parentEndTag, singleNode);
+	}, scopeId, accessor, branchGuard, markerGuard, branchExprGuard, parentEndTag, singleNode);
 }
-function _for_until(to, from, step, cb, by, scopeId, accessor, serializeBranch, serializeMarker, serializeStateful, parentEndTag, singleNode) {
+function _for_until(to, from, step, cb, by, scopeId, accessor, branchGuard, markerGuard, branchExprGuard, parentEndTag, singleNode) {
 	forBranches(by, (each) => {
 		let index = 0;
 		return each ? forUntil(to, from, step, (value) => {
 			const itemKey = forStepBy(by, value);
 			each(itemKey, itemKey === index++, () => cb(value));
 		}) : forUntil(to, from, step, cb);
-	}, scopeId, accessor, serializeBranch, serializeMarker, serializeStateful, parentEndTag, singleNode);
+	}, scopeId, accessor, branchGuard, markerGuard, branchExprGuard, parentEndTag, singleNode);
 }
-function forBranches(by, iterate, scopeId, accessor, serializeBranch, serializeMarker, serializeStateful, parentEndTag, singleNode) {
+function forBranches(by, iterate, scopeId, accessor, branchGuard, markerGuard, branchExprGuard, parentEndTag, singleNode) {
 	if (by) {
 		const run = iterate;
 		const seenKeys = /* @__PURE__ */ new Set();
@@ -2374,14 +2406,14 @@ function forBranches(by, iterate, scopeId, accessor, serializeBranch, serializeM
 			else render();
 		});
 	}
-	if (serializeBranch === 0) {
+	if (branchGuard === 0) {
 		iterate(0);
-		writeBranchEnd(scopeId, accessor, serializeStateful, serializeMarker, parentEndTag, singleNode, "");
+		writeBranchEnd(scopeId, accessor, branchExprGuard, markerGuard, parentEndTag, singleNode, "");
 		return;
 	}
 	const { state } = $chunk.boundary;
-	const resumeKeys = serializeMarker !== 0;
-	const resumeMarker = resumeKeys && (!parentEndTag || serializeStateful !== 0);
+	const resumeKeys = markerGuard !== 0;
+	const resumeMarker = resumesMarker(markerGuard, branchExprGuard, parentEndTag);
 	let flushBranchIds = "";
 	let loopScopes;
 	iterate((itemKey, sameAsIndex, render) => {
@@ -2400,11 +2432,11 @@ function forBranches(by, iterate, scopeId, accessor, serializeBranch, serializeM
 		});
 	});
 	if (loopScopes) writeScope(scopeId, { [BranchScopes + accessor]: loopScopes });
-	writeBranchEnd(scopeId, accessor, serializeStateful, serializeMarker, parentEndTag, singleNode, singleNode ? flushBranchIds : flushBranchIds ? " " + flushBranchIds : "");
+	writeBranchEnd(scopeId, accessor, branchExprGuard, markerGuard, parentEndTag, singleNode, singleNode ? flushBranchIds : flushBranchIds ? " " + flushBranchIds : "");
 }
-function _if(cb, scopeId, accessor, serializeBranch, serializeMarker, serializeStateful, parentEndTag, singleNode) {
-	const resumeBranch = serializeBranch !== 0;
-	const resumeMarker = serializeMarker !== 0 && (!parentEndTag || serializeStateful !== 0);
+function _if(cb, scopeId, accessor, branchGuard, markerGuard, branchExprGuard, parentEndTag, singleNode) {
+	const resumeBranch = branchGuard !== 0;
+	const resumeMarker = resumesMarker(markerGuard, branchExprGuard, parentEndTag);
 	const branchId = _peek_scope_id();
 	const chunk = $chunk;
 	const beforeBranch = resumeMarker && resumeBranch && !singleNode ? deferBranchStart(chunk) : void 0;
@@ -2415,7 +2447,7 @@ function _if(cb, scopeId, accessor, serializeBranch, serializeMarker, serializeS
 		[ConditionalRenderer + accessor]: branchIndex || void 0,
 		[BranchScopes + accessor]: resumeMarker ? void 0 : writeScope(branchId, {})
 	});
-	writeBranchEnd(scopeId, accessor, serializeStateful, serializeMarker, parentEndTag, singleNode, shouldWriteBranch ? " " + branchId : "");
+	writeBranchEnd(scopeId, accessor, branchExprGuard, markerGuard, parentEndTag, singleNode, shouldWriteBranch ? " " + branchId : "");
 }
 function deferBranchStart(chunk) {
 	const beforeBranch = chunk.html;
@@ -2425,15 +2457,17 @@ function deferBranchStart(chunk) {
 function applyBranchStart(chunk, beforeBranch, rendered) {
 	chunk.html = beforeBranch + (rendered ? chunk.boundary.state.mark("[", "") : "") + chunk.html;
 }
-function writeBranchEnd(scopeId, accessor, serializeStateful, serializeMarker, parentEndTag, singleNode, branchIds) {
+function resumesMarker(markerGuard, branchExprGuard, parentEndTag) {
+	return markerGuard !== 0 && (!parentEndTag || branchExprGuard !== 0);
+}
+function writeBranchEnd(scopeId, accessor, branchExprGuard, markerGuard, parentEndTag, singleNode, branchIds) {
 	const endTag = parentEndTag || "";
-	if (serializeMarker !== 0) {
-		if (!parentEndTag || serializeStateful !== 0) {
-			const { state } = $chunk.boundary;
-			const mark = singleNode ? state.mark(parentEndTag ? "}" : "|", scopeId + " " + accessor + (branchIds || "")) : state.mark(parentEndTag ? ")" : "]", scopeId + " " + accessor + (branchIds || ""));
-			$chunk.writeHTML(mark + endTag);
-		} else $chunk.writeHTML(endTag + _el_resume(scopeId, accessor));
-	} else $chunk.writeHTML(endTag);
+	if (resumesMarker(markerGuard, branchExprGuard, parentEndTag)) {
+		const { state } = $chunk.boundary;
+		const mark = singleNode ? state.mark(parentEndTag ? "}" : "|", scopeId + " " + accessor + (branchIds || "")) : state.mark(parentEndTag ? ")" : "]", scopeId + " " + accessor + (branchIds || ""));
+		$chunk.writeHTML(mark + endTag);
+	} else if (markerGuard !== 0) $chunk.writeHTML(endTag + _el_resume(scopeId, accessor));
+	else $chunk.writeHTML(endTag);
 }
 let writeScope = (scopeId, partialScope) => {
 	const { state } = $chunk.boundary;
@@ -2465,12 +2499,14 @@ function scopeWithId(state, scopeId) {
 	if (!scope) scopes.set(scopeId, scope = { [K_SCOPE_ID]: scopeId });
 	return scope;
 }
-function _subscribe(subscribers, scope, resumeId, serializeMarker) {
+function _subscribe(subscribers, scope, resumeId, markerGuard) {
 	if (subscribers) {
-		const { serializer } = $chunk.boundary.state;
-		if (!$chunk.serializeState.readyId && !serializer.written(subscribers)) subscribers.add(scope);
-		else if (resumeId) _script(scope[K_SCOPE_ID], resumeId, serializeMarker);
-		else serializer.writeCall(scope, subscribers, "add", $chunk.serializeState);
+		const { boundary, serializeState } = $chunk;
+		const { serializer } = boundary.state;
+		if (!serializeState.readyId && !serializer.written(subscribers)) subscribers.add(scope);
+		else if (resumeId) _script(scope[K_SCOPE_ID], resumeId, markerGuard);
+		else serializer.writeCall(scope, subscribers, "add", serializeState);
+		if (boundary.withinCatch) (boundary.subscribed ||= []).push(subscribers, scope, serializeState);
 	}
 	return scope;
 }
@@ -2478,19 +2514,19 @@ const CLIENT_ALL = 715827883;
 function maskGroup(mask, group) {
 	return mask === 715827883 ? 1 : typeof mask === "number" ? group < 15 ? mask >>> 1 + 2 * group & 3 : 0 : mask[group] ?? 0;
 }
-function _set_serialize_reason(reason) {
-	$chunk.boundary.state.serializeReason = reason;
+function _set_scope_reason(reason) {
+	$chunk.boundary.state.scopeReason = reason;
 }
 function _scope_reason() {
-	const reason = $chunk.boundary.state.serializeReason;
-	$chunk.boundary.state.serializeReason = void 0;
+	const reason = $chunk.boundary.state.scopeReason;
+	$chunk.boundary.state.scopeReason = void 0;
 	return reason;
 }
-function _serialize_if(condition, key) {
+function _write_if(condition, key) {
 	return condition && maskGroup(condition, key) ? 1 : void 0;
 }
-function _serialize_guard(condition, key) {
-	return _serialize_if(condition, key) || 0;
+function _write_guard(condition, key) {
+	return _write_if(condition, key) || 0;
 }
 function writeWaitReady(readyId, renderer, input) {
 	const chunk = $chunk;
@@ -2503,6 +2539,7 @@ function writeWaitReady(readyId, renderer, input) {
 		flushScopes: false
 	});
 	const bodyEnd = body.render(renderer, input);
+	if (boundary.aborted) throw boundary.reason;
 	if (body === bodyEnd) {
 		chunk.writeHTML(body.html);
 		body.deferOwnReady();
@@ -2512,8 +2549,8 @@ function writeWaitReady(readyId, renderer, input) {
 		chunk.next = body;
 	}
 }
-function _await(scopeId, accessor, promise, content, serializeMarker) {
-	const resumeMarker = serializeMarker !== 0;
+function _await(scopeId, accessor, promise, content, markerGuard) {
+	const resumeMarker = markerGuard !== 0;
 	if (!isPromise(promise)) {
 		if (resumeMarker) {
 			const branchId = _peek_scope_id();
@@ -2533,7 +2570,8 @@ function _await(scopeId, accessor, promise, content, serializeMarker) {
 	promise.then((value) => {
 		if (chunk.async) {
 			chunk.async = false;
-			if (!boundary.signal.aborted) {
+			if (!boundary.aborted) {
+				const { state } = boundary;
 				chunk.render(() => {
 					if (resumeMarker) {
 						const branchId = _peek_scope_id();
@@ -2549,6 +2587,7 @@ function _await(scopeId, accessor, promise, content, serializeMarker) {
 						async.end = $chunk;
 					}
 				});
+				if (!chunk.async && boundary.pendingReorders?.delete(chunk)) state.reorder(chunk);
 				boundary.endAsync();
 			}
 		}
@@ -2595,12 +2634,13 @@ function tryBoundary(content, catchContent, branchId, renderers) {
 	const chunk = $chunk;
 	const { boundary } = chunk;
 	const { state } = boundary;
-	const catchBoundary = new Boundary(state, boundary.signal, boundary);
+	const catchBoundary = new Boundary(state, void 0, boundary);
+	if (catchContent) catchBoundary.withinCatch = true;
 	const body = chunk.fork(catchBoundary, null);
 	const bodyEnd = body.render(() => withBranchId(branchId, content));
-	if (catchBoundary.signal.aborted) {
-		if (catchContent) catchContent(catchBoundary.signal.reason);
-		else boundary.abort(catchBoundary.signal.reason);
+	if (catchBoundary.aborted) {
+		if (!catchContent) throw catchBoundary.reason;
+		catchContent(catchBoundary.reason);
 		return true;
 	}
 	if (body === bodyEnd) {
@@ -2612,49 +2652,69 @@ function tryBoundary(content, catchContent, branchId, renderers) {
 	chunk.next = body;
 	boundary.startAsync();
 	const reorderId = catchContent ? state.nextReorderId() : "";
-	const endMarker = reorderId && state.mark("!", reorderId);
 	if (reorderId) {
-		chunk.writeHTML(state.mark("!^", reorderId));
-		bodyEnd.writeHTML(endMarker);
+		chunk.catchRange = {
+			id: reorderId,
+			end: bodyEnd
+		};
 		captureContext(chunk);
 	}
 	catchBoundary.onNext = () => {
-		if (boundary.signal.aborted) return;
-		if (catchBoundary.signal.aborted) {
+		if (boundary.aborted) return;
+		if (catchBoundary.aborted) {
 			if (!reorderId) {
-				boundary.abort(catchBoundary.signal.reason);
+				boundary.abort(catchBoundary.reason);
 				return;
 			}
-			if (!bodyEnd.consumed) {
-				let cur = body;
-				let writeMarker = true;
-				do {
-					const next = cur.next;
-					if (cur.boundary !== catchBoundary) cur.boundary.abort(catchBoundary.signal.reason);
-					if (writeMarker && !cur.consumed) {
-						writeMarker = false;
-						cur.async = false;
-						cur.next = bodyNext;
-						cur.needsWalk = true;
-						cur.html = endMarker;
-						cur.scripts = cur.effects = cur.lastEffect = "";
-						cur.placeholder = cur.reorderId = cur.deferredReady = null;
-					}
-					cur = next;
-				} while (cur !== bodyNext);
-			}
+			const streamed = !chunk.catchRange;
 			const catchChunk = chunk.fork(boundary, null);
-			catchChunk.reorderId = reorderId;
-			catchChunk.render(catchContent, catchBoundary.signal.reason);
-			state.reorder(catchChunk);
+			chunk.catchRange = null;
+			if (!renderersAtSettle) catchChunk.render(clearTryRenderers, branchId);
+			const inOrder = catchChunk === catchChunk.render(catchContent, catchBoundary.reason);
+			if (boundary.aborted) return;
+			if (bodyEnd.consumed || !inOrder) catchChunk.reorderStart = state.mark("*", branchId + "");
+			if (bodyEnd.consumed) {
+				catchChunk.reorderId = reorderId;
+				state.reorder(catchChunk);
+			} else {
+				let reorder = null;
+				if (!inOrder) reorder = catchChunk;
+				else if (streamed) reorder = chunk.fork(boundary, null);
+				if (reorder) reorder.reorderId = reorderId;
+				const endMarker = state.mark("!", reorderId);
+				let cut = body;
+				while (cut.consumed) cut = cut.next;
+				cut.async = false;
+				cut.next = inOrder ? catchChunk : bodyNext;
+				cut.html = streamed ? endMarker : inOrder ? "" : state.mark("!^", reorderId) + endMarker;
+				cut.scripts = cut.effects = cut.lastEffect = "";
+				cut.placeholder = cut.reorderId = cut.catchRange = null;
+				cut.deferredReorder = reorder;
+				if (inOrder) catchChunk.next = bodyNext;
+			}
 			boundary.endAsync();
 		} else if (!catchBoundary.count) {
 			if (renderersAtSettle && catchBoundary.resumeWrites) bodyEnd.render(renderers);
+			chunk.catchRange = null;
 			boundary.endAsync();
 		} else boundary.onNext();
 	};
 	return renderersAtSettle;
 }
+function unsubscribe(subscribed, serializer) {
+	for (let i = 0; i < subscribed.length; i += 3) {
+		const subscribers = subscribed[i];
+		const scope = subscribed[i + 1];
+		if (!serializer.written(subscribers)) subscribers.delete(scope);
+		else if (!serializer.dropCall(scope, subscribers, "add")) serializer.writeCall(scope, subscribers, "delete", subscribed[i + 2]);
+	}
+}
+function clearTryRenderers(branchId) {
+	writeScope(branchId, {
+		[CatchContent]: 0,
+		[PlaceholderContent]: _scope_with_id(branchId)["#PlaceholderContent"] && 0
+	});
+}
 function writeTryRenderers(branchId, catchContent, placeholderContent) {
 	writeScope(branchId, {
 		[CatchContent]: catchContent,
@@ -2694,7 +2754,7 @@ var State = class {
 	flushScopes = false;
 	writeScopes = {};
 	readyIds = null;
-	serializeReason;
+	scopeReason;
 	$global;
 	constructor($global) {
 		this.$global = $global;
@@ -2755,38 +2815,57 @@ var State = class {
 		return "<!--" + this.commentPrefix + code + str + "-->";
 	}
 };
-var Boundary = class extends AbortController {
+var Boundary = class {
 	onNext = NOOP$2;
 	count = 0;
 	resumeWrites = 0;
 	state;
 	parent;
+	aborted = false;
+	reason;
+	subscribed;
+	pendingReorders;
+	children;
+	withinCatch = false;
 	constructor(state, signal, parent) {
-		super();
 		this.state = state;
 		this.parent = parent;
-		this.signal.addEventListener("abort", () => {
-			this.count = 0;
-			this.state = new State(this.state.$global);
-			this.onNext();
-		});
-		if (signal) {
+		if (parent) {
+			this.withinCatch = parent.withinCatch;
+			if (parent.aborted) this.abort(parent.reason);
+			else (parent.children ||= []).push(this);
+		} else if (signal) {
 			if (signal.aborted) this.abort(signal.reason);
 			else signal.addEventListener("abort", this);
 		}
 	}
+	abort(reason) {
+		if (this.aborted) return;
+		const { state } = this;
+		this.aborted = true;
+		this.reason = reason;
+		if (this.subscribed) unsubscribe(this.subscribed, state.serializer);
+		if (this.pendingReorders) {
+			for (const reorder of this.pendingReorders) state.reorder(reorder);
+			this.pendingReorders = void 0;
+		}
+		this.count = 0;
+		this.state = new State(state.$global);
+		if (this.children) for (const child of this.children) child.abort(reason);
+		this.onNext();
+	}
 	handleEvent(event) {
 		this.abort(event.target.reason);
 	}
 	flush() {
-		if (!this.signal.aborted) flushSerializer(this, this.state);
-		return this.count ? 1 : this.signal.aborted ? 2 : 0;
+		if (!this.aborted) flushSerializer(this, this.state);
+		return this.count ? 1 : this.aborted ? 2 : 0;
 	}
 	startAsync() {
-		if (!this.signal.aborted) this.count++;
+		if (!this.aborted) this.count++;
 	}
 	endAsync() {
-		if (!this.signal.aborted) {
+		if (!this.aborted) {
 			if (!this.count) throw new Error("A boundary ended more async work than it started.");
 			this.count--;
 			this.onNext();
@@ -2800,9 +2879,12 @@ var Chunk = class Chunk {
 	lastEffect = "";
 	async = false;
 	consumed = false;
-	needsWalk = false;
 	reorderId = null;
+	reorderStart = "";
 	deferredReady = null;
+	heldEffects = null;
+	deferredReorder = null;
+	catchRange = null;
 	placeholder = null;
 	boundary;
 	next;
@@ -2822,7 +2904,7 @@ var Chunk = class Chunk {
 	}
 	writeEffect(scopeId, registryId) {
 		countResumeWrite(this);
-		if (this.lastEffect === registryId) this.effects += " " + scopeId;
+		if (this.lastEffect === registryId) this.effects = concatEffects(this.effects, scopeId + "");
 		else {
 			this.lastEffect = registryId;
 			this.effects = concatEffects(this.effects, registryId + " " + scopeId);
@@ -2833,12 +2915,16 @@ var Chunk = class Chunk {
 	}
 	append(chunk) {
 		this.html += chunk.html;
-		this.needsWalk ||= chunk.needsWalk;
 		this.effects = concatEffects(this.effects, chunk.effects);
 		this.scripts = concatScripts(this.scripts, chunk.scripts);
 		this.lastEffect = chunk.lastEffect || this.lastEffect;
 		this.deferredReady = concat(this.deferredReady, chunk.takeDeferredReady());
 	}
+	takeHeldEffects() {
+		const { heldEffects } = this;
+		this.heldEffects = null;
+		return heldEffects;
+	}
 	takeDeferredReady() {
 		const { deferredReady } = this;
 		this.deferredReady = null;
@@ -2853,64 +2939,123 @@ var Chunk = class Chunk {
 			this.deferredReady = concat(deferred, this.deferredReady);
 		}
 	}
-	flushPlaceholder() {
-		const { placeholder } = this;
-		if (placeholder) {
-			this.placeholder = null;
-			const body = placeholder.body.consume();
-			if (body.async) {
-				const { state } = this.boundary;
-				const { branchId, scopeId, placeholderBranchId } = placeholder;
-				const reorderId = body.reorderId = branchId ? branchId + "" : state.nextReorderId();
-				this.writeHTML(state.mark("!^", reorderId));
-				const { effects } = this;
-				const beforeBranch = deferBranchStart(this);
-				if (this.render(() => withBranchId(placeholderBranchId, placeholder.render)) !== this) this.boundary.abort(/* @__PURE__ */ new Error("An @placeholder cannot contain async content."));
-				if (this.boundary.signal.aborted) return;
-				const stateful = this.effects !== effects;
-				applyBranchStart(this, beforeBranch, stateful);
-				if (stateful) {
-					this.render(() => writeScope(branchId, { [PlaceholderBranch]: scopeWithId(state, placeholderBranchId) }));
-					this.writeHTML(state.mark("]", scopeId + " " + (PlaceholderBranch + branchId) + " " + placeholderBranchId));
-					body.writeEffect(branchId, PLACEHOLDER_DISMISS_REGISTER_ID);
+	renderPlaceholders(boundary) {
+		const { state } = boundary;
+		restart: for (;;) {
+			let reorders = null;
+			for (let cur = this; cur.next && !cur.async; cur = cur.next) {
+				if (cur.renderPlaceholder(state)) {
+					if (boundary.aborted) return;
+					continue restart;
 				}
-				this.writeHTML(state.mark("!", reorderId));
-				state.reorder(body);
-			} else {
-				body.next = this.next;
-				this.next = body;
+				if (cur.deferredReorder) (reorders ||= []).push(cur.deferredReorder);
 			}
+			if (state.writeReorders) {
+				for (const reorder of state.writeReorders) if ((reorders = renderReorderPlaceholders(reorder, reorders)) === false) {
+					if (boundary.aborted) return;
+					continue restart;
+				}
+			}
+			for (let i = 0; reorders && i < reorders.length; i++) if ((reorders = renderReorderPlaceholders(reorders[i], reorders)) === false) {
+				if (boundary.aborted) return;
+				continue restart;
+			}
+			return;
 		}
 	}
-	consume() {
+	renderPlaceholder(state) {
+		const { placeholder } = this;
+		if (!placeholder) return false;
+		this.placeholder = null;
+		if (this.boundary.aborted) return false;
+		const { body } = placeholder;
+		let end = body;
+		while (end.next && !end.async) end = end.next;
+		if (!end.async) {
+			end.next = this.next;
+			this.next = body;
+			return false;
+		}
+		const { branchId, scopeId, placeholderBranchId } = placeholder;
+		const reorderId = body.reorderId = branchId + "";
+		this.writeHTML(state.mark("!^", reorderId));
+		const { effects } = this;
+		const beforeBranch = deferBranchStart(this);
+		if (this.render(() => withBranchId(placeholderBranchId, placeholder.render)) !== this) this.boundary.abort(/* @__PURE__ */ new Error("An @placeholder cannot contain async content."));
+		if (this.boundary.aborted) return true;
+		const stateful = this.effects !== effects;
+		applyBranchStart(this, beforeBranch, stateful);
+		if (stateful) {
+			this.render(() => writeScope(branchId, { [PlaceholderBranch]: scopeWithId(state, placeholderBranchId) }));
+			this.writeHTML(state.mark("]", scopeId + " " + (PlaceholderBranch + branchId) + " " + placeholderBranchId));
+			dismissChunk(end, body).writeEffect(branchId, PLACEHOLDER_DISMISS_REGISTER_ID);
+		}
+		this.writeHTML(state.mark("!", reorderId));
+		this.deferredReorder = body;
+		return false;
+	}
+	markCatchRange() {
+		const { catchRange } = this;
+		if (catchRange) {
+			const { state } = this.boundary;
+			this.catchRange = null;
+			this.writeHTML(state.mark("!^", catchRange.id));
+			catchRange.end.writeHTML(state.mark("!", catchRange.id));
+		}
+	}
+	queueDeferredReorder() {
+		const { deferredReorder } = this;
+		if (deferredReorder) {
+			this.deferredReorder = null;
+			deferredReorder.boundary.state.reorder(deferredReorder);
+		}
+	}
+	consume(boundary) {
+		this.renderPlaceholders(boundary);
 		let cur = this;
 		let html = "";
 		let effects = "";
 		let scripts = "";
-		let lastEffect = "";
-		let needsWalk = false;
+		let effectsEnd;
+		let heldEffects = this.heldEffects;
 		let deferredReady;
+		this.heldEffects = null;
+		if (this.serializeState.readyId && this.effects) followHeldEffects(this);
 		while (cur.next && !cur.async) {
-			cur.flushPlaceholder();
-			needsWalk ||= cur.needsWalk;
+			cur.markCatchRange();
+			cur.queueDeferredReorder();
 			html += cur.html;
 			if (cur.serializeState.readyId) deferredReady = push(deferredReady, cur);
 			else {
-				effects = concatEffects(effects, cur.effects);
+				if (cur.effects) {
+					if (effectsEnd && effectsEnd.boundary !== cur.boundary) {
+						heldEffects = holdEffectsOn(heldEffects, effectsEnd, effects);
+						effects = "";
+					}
+					effectsEnd = cur;
+					effects = concatEffects(effects, cur.effects);
+				}
 				scripts = concatScripts(scripts, cur.scripts);
-				lastEffect = cur.lastEffect || lastEffect;
 			}
 			deferredReady = concat(deferredReady, cur.takeDeferredReady());
 			cur.consumed = true;
 			cur = cur.next;
 		}
 		cur.deferOwnReady();
+		if (effects) {
+			if (cur.serializeState.readyId) heldEffects = holdEffectsOn(heldEffects, effectsEnd, effects);
+			else if (effectsEnd.boundary !== cur.boundary) {
+				heldEffects = holdEffectsOn(heldEffects, effectsEnd, effects);
+				if (isWithin(cur.boundary, effectsEnd.boundary)) cur.lastEffect ||= effectsEnd.lastEffect;
+			} else {
+				cur.effects = concatEffects(effects, cur.effects);
+				cur.lastEffect ||= effectsEnd.lastEffect;
+			}
+		}
+		cur.heldEffects = heldEffects;
 		cur.deferredReady = concat(deferredReady, cur.deferredReady);
-		cur.needsWalk ||= needsWalk;
 		cur.html = html + cur.html;
-		cur.effects = concatEffects(effects, cur.effects);
 		cur.scripts = concatScripts(scripts, cur.scripts);
-		cur.lastEffect ||= lastEffect;
 		return cur;
 	}
 	render(content, val) {
@@ -2930,10 +3075,12 @@ var Chunk = class Chunk {
 		const { serializeState } = this;
 		const { readyId } = serializeState;
 		let scripts = "";
-		forEach(this.takeDeferredReady(), (chunk) => {
+		const held = this.takeDeferredReady();
+		if (held) for (const chunk of Array.isArray(held) ? held : [held]) {
+			if (chunk.boundary.aborted) continue;
 			scripts = concatScripts(scripts, chunk.flushReadyScripts(boundary, reservations, holdEffects));
 			if (chunk.effects || chunk.deferredReady) this.deferredReady = push(this.deferredReady, chunk);
-		});
+		}
 		if (readyId && !this.async) {
 			const { state } = boundary;
 			flushSerializer(boundary, serializeState);
@@ -2961,16 +3108,18 @@ var Chunk = class Chunk {
 		const { $global, runtimePrefix } = state;
 		let needsWalk = state.walkOnNextFlush;
 		if (needsWalk) state.walkOnNextFlush = false;
+		flushSerializer(boundary, state);
 		let readyResumeScripts = this.flushReadyScripts(boundary, void 0, this.async);
-		for (let channel; !boundary.signal.aborted && (channel = state.serializer.pendingReadyChannel());) {
+		for (let channel; !boundary.aborted && (channel = state.serializer.pendingReadyChannel());) {
 			const resumes = state.serializer.stringifyScopes([], boundary, channel);
 			const deps = state.serializer.takeChannelDeps();
 			state.needsMainRuntime = true;
 			readyResumeScripts = concatScripts(readyResumeScripts, state.writeReady(channel.readyId, concatSequence(depsMarker(deps), resumes)));
 		}
 		if (readyResumeScripts) needsWalk = true;
-		const effects = this.async ? "" : this.effects;
+		const effects = this.async ? "" : joinHeldEffects(this.takeHeldEffects(), this.effects);
 		let { html, scripts } = this;
+		if (html && state.hasReorderRuntime) html = state.mark("*", "") + html;
 		if (state.needsMainRuntime && !state.hasMainRuntime) {
 			state.hasMainRuntime = true;
 			scripts = concatScripts(scripts, WALKER_RUNTIME_CODE + "(\"" + $global.runtimeId + "\")(\"" + $global.renderId + "\")");
@@ -2983,64 +3132,60 @@ var Chunk = class Chunk {
 		let reordered = "";
 		let needsResumeArray = false;
 		if (state.writeReorders) {
-			let carried = null;
 			for (const reorderedChunk of state.writeReorders) {
-				if (reorderedChunk.async && reorderedChunk.consumed) {
-					let aborted = reorderedChunk.boundary;
-					while (aborted && !aborted.signal.aborted) aborted = aborted.parent;
-					if (!aborted) {
-						(carried ||= []).push(reorderedChunk);
-						continue;
-					}
-					reorderedChunk.async = false;
-				}
 				needsWalk = true;
 				if (!state.hasReorderRuntime) {
 					state.hasReorderRuntime = true;
 					scripts = concatScripts(scripts, REORDER_RUNTIME_CODE + "(" + runtimePrefix + ")");
 				}
-				const { reorderId } = reorderedChunk;
+				const { reorderId, reorderStart } = reorderedChunk;
 				const readyReservations = [];
 				let reorderHTML = "";
 				let reorderEffects = "";
+				let effectsBoundary = reorderedChunk.boundary;
 				let reorderScripts = "";
-				let cur = reorderedChunk;
+				let cur = reorderedChunk.boundary.aborted ? null : reorderedChunk;
 				reorderedChunk.reorderId = null;
-				for (;;) {
-					cur.flushPlaceholder();
+				while (cur) {
+					cur.markCatchRange();
+					cur.queueDeferredReorder();
 					cur.deferOwnReady();
 					const { next } = cur;
 					const readyResumeScripts = cur.flushReadyScripts(boundary, readyReservations, this.async);
 					this.deferredReady = concat(this.deferredReady, cur.takeDeferredReady());
 					cur.consumed = true;
 					reorderHTML += cur.html;
+					if (this.async && cur.effects && cur.boundary !== effectsBoundary) {
+						if (reorderEffects) {
+							holdReorderEffects(this, effectsBoundary, reorderEffects);
+							reorderEffects = "";
+						}
+						effectsBoundary = cur.boundary;
+					}
 					reorderEffects = concatEffects(reorderEffects, cur.effects);
 					reorderScripts = concatScripts(reorderScripts, concatScripts(readyResumeScripts, cur.scripts));
 					if (cur.async) {
 						reorderHTML += state.mark("#", cur.reorderId = state.nextReorderId());
-						state.reorder(cur);
+						cur.reorderStart = reorderStart;
+						(cur.boundary.pendingReorders ||= /* @__PURE__ */ new Set()).add(cur);
 						cur.html = cur.effects = cur.scripts = cur.lastEffect = "";
 						cur.next = null;
 					}
-					if (next) cur = next;
-					else break;
+					cur = next;
 				}
 				if (reorderEffects) {
-					if (this.async) {
-						this.effects = concatEffects(this.effects, reorderEffects);
-						this.lastEffect = "";
-					} else {
+					if (this.async) holdReorderEffects(this, effectsBoundary, reorderEffects);
+					else {
 						needsResumeArray = true;
 						reorderScripts = concatScripts(reorderScripts, "_.push(\"" + reorderEffects + "\")");
 					}
 				}
 				for (const reservation of readyReservations) reordered = concatScripts(reordered, reservation);
 				reordered = concatScripts(reordered, reorderScripts && runtimePrefix + ".j" + toAccess(reorderId) + "=_=>{" + reorderScripts + "}");
-				html += "<t hidden " + state.commentPrefix + "=" + reorderId + ">" + reorderHTML + "</t>";
+				html += "<t hidden " + state.commentPrefix + "=" + reorderId + ">" + reorderStart + reorderHTML + "</t>";
 			}
-			state.writeReorders = carried;
+			state.writeReorders = null;
 		}
-		flushSerializer(boundary, state);
 		if (state.resumes || needsResumeArray && !state.hasWrittenResume) scripts = concatScripts(scripts, state.resumeScript(state.resumes));
 		scripts = concatScripts(scripts, reordered);
 		if (needsWalk) scripts = concatScripts(scripts, state.walkScript());
@@ -3052,16 +3197,54 @@ var Chunk = class Chunk {
 	}
 	flushHTML(boundary) {
 		const { state } = boundary;
-		if (this.needsWalk) {
-			this.needsWalk = false;
-			state.walkOnNextFlush = true;
-		}
 		this.flushScript(boundary);
 		const { html, scripts } = this;
 		this.html = this.scripts = "";
 		return state.flushChunk(html, scripts, boundary.count);
 	}
 };
+function renderReorderPlaceholders(reorder, reorders) {
+	if (!reorder.boundary.aborted) for (let cur = reorder; cur; cur = cur.next) {
+		if (cur.renderPlaceholder(reorder.boundary.state)) return false;
+		if (cur.deferredReorder) (reorders ||= []).push(cur.deferredReorder);
+	}
+	return reorders;
+}
+function dismissChunk(end, body) {
+	if (end.boundary !== body.boundary) while (end.next) end = end.next;
+	return end;
+}
+function followHeldEffects(chunk) {
+	const held = reduce(chunk.deferredReady, lastHeldOf, chunk);
+	if (held !== chunk) {
+		held.effects = concatEffects(held.effects, chunk.effects);
+		chunk.effects = "";
+	}
+}
+function lastHeldOf(held, cur) {
+	return cur.serializeState === held.serializeState && cur.boundary === held.boundary ? cur : held;
+}
+function holdEffectsOn(heldEffects, chunk, effects) {
+	chunk.effects = effects;
+	return push(heldEffects, chunk);
+}
+function isWithin(boundary, outer) {
+	while (boundary && boundary !== outer) boundary = boundary.parent;
+	return !!boundary;
+}
+function holdReorderEffects(head, boundary, effects) {
+	if (!head.serializeState.readyId) {
+		if (head.effects) head.heldEffects = holdEffectsOn(head.heldEffects, head.fork(head.boundary, null), head.effects);
+		head.effects = head.lastEffect = "";
+	}
+	head.heldEffects = holdEffectsOn(head.heldEffects, head.fork(boundary, null), effects);
+}
+function joinHeldEffects(heldEffects, effects) {
+	return concatEffects(reduce(heldEffects, joinUncaught, ""), effects);
+}
+function joinUncaught(joined, held) {
+	return held.boundary.aborted ? joined : concatEffects(joined, held.effects);
+}
 function flushSerializer(boundary, serializeState) {
 	const { state } = boundary;
 	const { serializer } = state;
@@ -3223,8 +3406,8 @@ function _escape_comment(val) {
 //#endregion
 //#region src/html/dynamic-tag.ts
 const voidElementsReg = /^(?:area|b(?:ase|r)|col|embed|hr|i(?:mg|nput)|link|meta|param|source|track|wbr)$/;
-let _dynamic_tag = (scopeId, accessor, tag, inputOrArgs, content, inputIsArgs, serializeReason) => {
-	const shouldResume = serializeReason !== 0;
+let _dynamic_tag = (scopeId, accessor, tag, inputOrArgs, content, inputIsArgs, markerGuard) => {
+	const shouldResume = markerGuard !== 0;
 	const renderer = normalizeDynamicRenderer(tag);
 	const state = getState();
 	const branchId = _peek_scope_id();
@@ -3244,8 +3427,8 @@ let _dynamic_tag = (scopeId, accessor, tag, inputOrArgs, content, inputIsArgs, s
 					_html(_attrs_textarea_value(branchId, `#${renderer.toLowerCase()}/0`, input));
 				} else {
 					if (renderContent && typeof renderContent !== "function") throw new Error(`Body content is not supported for the \`<${renderer}>\` tag.`);
-					if (renderer === "select" && ("value" in input || "valueChange" in input)) _attr_select_value(branchId, `#${renderer.toLowerCase()}/0`, input.value, input.valueChange, renderContent ? () => _dynamic_tag(branchId, `#${renderer.toLowerCase()}/0`, renderContent, void 0, 0, void 0, serializeReason) : void 0, 1);
-					else if (renderContent) _dynamic_tag(branchId, `#${renderer.toLowerCase()}/0`, renderContent, void 0, 0, void 0, serializeReason);
+					if (renderer === "select" && ("value" in input || "valueChange" in input)) _attr_select_value(branchId, `#${renderer.toLowerCase()}/0`, input.value, input.valueChange, renderContent ? () => _dynamic_tag(branchId, `#${renderer.toLowerCase()}/0`, renderContent, void 0, 0, void 0, markerGuard) : void 0, 1);
+					else if (renderContent) _dynamic_tag(branchId, `#${renderer.toLowerCase()}/0`, renderContent, void 0, 0, void 0, markerGuard);
 				}
 				_html(`</${renderer}>`);
 			} else if (content) throw new Error(`Body content is not supported for the \`<${renderer}>\` tag.`);
@@ -3264,13 +3447,13 @@ let _dynamic_tag = (scopeId, accessor, tag, inputOrArgs, content, inputIsArgs, s
 		const beforeBranch = shouldResume ? deferBranchStart(chunk) : void 0;
 		const render = () => {
 			if (renderer) try {
-				_set_serialize_reason(shouldResume && inputOrArgs !== void 0 ? CLIENT_ALL : 0);
+				_set_scope_reason(shouldResume && inputOrArgs !== void 0 ? CLIENT_ALL : 0);
 				return inputIsArgs ? renderer(...inputOrArgs) : renderer(content ? {
 					...inputOrArgs,
 					content
 				} : inputOrArgs);
 			} finally {
-				_set_serialize_reason(void 0);
+				_set_scope_reason(void 0);
 			}
 			else if (content) return content();
 		};
@@ -3486,13 +3669,13 @@ var ServerRendered = class {
 				switch (!boundary.count && boundary.flush()) {
 					case 2:
 						settle(boundary);
-						reject(boundary.signal.reason);
+						reject(boundary.reason);
 						break;
 					case 0:
-						head = head.consume();
-						if (boundary.signal.aborted) break;
+						head = head.consume(boundary);
+						if (boundary.aborted) break;
 						html += head.flushHTML(boundary);
-						if (!(boundary.count || boundary.signal.aborted)) {
+						if (!(boundary.count || boundary.aborted)) {
 							settle(boundary);
 							resolve(html);
 						}
@@ -3523,14 +3706,14 @@ var ServerRendered = class {
 				if (status === 2) {
 					if (!tick) offTick(onNext);
 					settle(boundary);
-					onAbort(boundary.signal.reason);
+					onAbort(boundary.reason);
 					return;
 				}
 				if (write || status === 0) {
-					head = head.consume();
-					if (boundary.signal.aborted) continue;
+					head = head.consume(boundary);
+					if (boundary.aborted) continue;
 					const html = head.flushHTML(boundary);
-					if (boundary.signal.aborted) continue;
+					if (boundary.aborted) continue;
 					if (html) onWrite(html);
 					if (!boundary.count) {
 						if (!tick) offTick(onNext);
@@ -3554,10 +3737,10 @@ var ServerRendered = class {
 		this.#head = null;
 		if (!head) throw new Error(CONSUMED_RESULT_MESSAGE);
 		const { boundary } = head;
-		const html = boundary.flush() === 0 ? head.consume().flushHTML(boundary) : "";
+		const html = boundary.flush() === 0 ? head.consume(boundary).flushHTML(boundary) : "";
 		if (boundary.count) boundary.abort(/* @__PURE__ */ new Error("Cannot consume asynchronous render with 'toString'"));
 		settle(boundary);
-		if (boundary.signal.aborted) throw boundary.signal.reason;
+		if (boundary.aborted) throw boundary.reason;
 		return html;
 	}
 };
@@ -3569,19 +3752,18 @@ function NOOP$1() {}
 //#endregion
 //#region src/html/assets.ts
 const kAssets = Symbol();
-const kBlockIndex = Symbol();
-const kDeferIndex = Symbol();
-let assetFlush;
-function withLoadAssets(renderer, assetId, triggers) {
+const kHead = Symbol();
+function withLoadAssets(renderer, flush, assetId, triggers) {
 	return Object.assign((input) => {
-		const g = $global();
-		addAsset(g, assetId, triggers);
-		_html(flush(g, ""));
+		writeLoadAsset(assetId, flush, triggers);
 		return writeWaitReady(assetId, renderer, input);
 	}, renderer);
 }
+function writeLoadAsset(assetId, flush, triggers) {
+	const g = $global();
+	writeAsset(g, addAsset(g, assetId, flush, triggers));
+}
 function withPageAssets(template, runtime, assetId, runtimeId) {
-	assetFlush = runtime;
 	return Object.assign((input) => {
 		const g = $global();
 		if (runtimeId) {
@@ -3590,57 +3772,78 @@ function withPageAssets(template, runtime, assetId, runtimeId) {
 				g.runtimeId = runtimeId;
 			} else if (g.runtimeId !== runtimeId) console.error(`A page entry compiled with runtimeId "${runtimeId}" is nested in a render using runtimeId "${g.runtimeId}", so its content cannot resume.`);
 		}
-		addAsset(g, assetId);
+		const asset = addAsset(g, assetId, runtime);
 		if (g.__flush__) {
-			_html(flush(g, ""));
+			writeAsset(g, asset);
 			return writeWaitReady(assetId, template, input);
 		}
-		g.__flush__ = flush;
+		g.__flush__ = flushPage;
 		return template(input);
 	}, template);
 }
 function _flush_head() {
 	const g = $global();
-	return g[kAssets] ? flush(g, "") : "";
+	if (!g[kAssets]) return "";
+	g[kHead] = true;
+	return takeAssets(g, catchableBoundary());
+}
+function flushPage(g, html) {
+	return takeAssets(g, null) + html;
+}
+function takeAssets(g, at) {
+	let block = "";
+	let defer = "";
+	for (const asset of g[kAssets]) if (asset.htmlAt === void 0) {
+		asset.htmlAt = at;
+		block += blockHTML(g, asset);
+		if (!asset.triggers) defer += deferHTML(g, asset);
+	}
+	return block + defer;
+}
+function writeAsset(g, asset) {
+	if (needsWrite(asset.htmlAt)) {
+		asset.htmlAt = void 0;
+		if (g[kHead] || g.__flush__ !== flushPage) {
+			const block = blockHTML(g, asset);
+			_html(block + (asset.triggers ? "" : deferHTML(g, asset)));
+			if (block && isInResumedBranch()) writeScript(`document.head.insertAdjacentHTML("beforeend",${_escape_script(JSON.stringify(block))})`);
+			asset.htmlAt = catchableBoundary();
+		}
+	}
+	if (asset.triggers && needsWrite(asset.scriptAt)) {
+		const defer = deferHTML(g, asset);
+		if (defer) writeScript(asset.script ||= triggerScript(asset.id, defer, asset.triggers));
+		asset.scriptAt = catchableBoundary();
+	}
 }
-function flush(g, html) {
-	let result = "";
-	const assets = g[kAssets];
-	const { length } = assets;
-	let bi = g[kBlockIndex];
-	let di = g[kDeferIndex];
-	for (; bi < length; bi++) result += assetFlush(g, "block", assets[bi].id);
-	for (; di < length; di++) {
-		const { id, triggers } = assets[di];
-		const deferHTML = assetFlush(g, "defer", id);
-		if (triggers) {
-			if (deferHTML) writeTriggerScript(id, deferHTML, triggers);
-		} else result += deferHTML;
-	}
-	g[kBlockIndex] = bi;
-	g[kDeferIndex] = di;
-	return result + html;
-}
-function addAsset(g, id, triggers) {
-	const assets = g[kAssets];
-	if (!assets) {
-		g[kAssets] = [{
-			id,
-			triggers
-		}];
-		g[kBlockIndex] = g[kDeferIndex] = 0;
-	} else if (!assets.find((a) => a.id === id)) assets.push({
+function needsWrite(at) {
+	return at === void 0 || at !== null && mayDrop(at);
+}
+function blockHTML(g, asset) {
+	return asset.block ??= asset.flush(g, "block", asset.id);
+}
+function deferHTML(g, asset) {
+	return asset.defer ??= asset.flush(g, "defer", asset.id);
+}
+function addAsset(g, id, flush, triggers) {
+	const assets = g[kAssets] ||= [];
+	let asset = assets.find((a) => a.id === id);
+	if (!asset) assets.push(asset = {
 		id,
-		triggers
+		flush,
+		triggers,
+		block: void 0,
+		defer: void 0,
+		script: void 0,
+		htmlAt: void 0,
+		scriptAt: void 0
 	});
-	else {
-		const existing = assets.find((a) => a.id === id);
-		if (JSON.stringify(existing.triggers) !== JSON.stringify(triggers)) console.error(`The lazy asset "${id}" is imported with different \`load\` triggers; an asset must use one consistent trigger.`);
-	}
+	else if (JSON.stringify(asset.triggers) !== JSON.stringify(triggers)) console.error(`The lazy asset "${id}" is imported with different \`load\` triggers; an asset must use one consistent trigger.`);
+	return asset;
 }
-function writeTriggerScript(id, html, triggers) {
+function triggerScript(id, html, triggers) {
 	const htmlStr = _escape_script(JSON.stringify(html));
-	const insert = `(d=new Range().createContextualFragment(h),d.querySelectorAll("script").forEach(s=>s.onerror=()=>console.error(${_escape_script(JSON.stringify(`The lazy module for "${id}" failed to load; its server-rendered content cannot become interactive.`))})),p.after(d))`;
+	const insert = `(d=new Range().createContextualFragment(h),d.querySelectorAll("script").forEach(s=>s.onerror=()=>console.error(${_escape_script(JSON.stringify(`The lazy module for "${id}" failed to load; its server-rendered content cannot become interactive.`))})),document.head.append(d))`;
 	const exprs = triggers.map((trigger) => {
 		const options = trigger.options && toObjectExpression(trigger.options);
 		switch (trigger.type) {
@@ -3650,7 +3853,7 @@ function writeTriggerScript(id, html, triggers) {
 			default: return `(e=>e?.addEventListener("${trigger.type.slice(3)}",l,{once:1}))(${querySelectorOrLoad(trigger.selector)})`;
 		}
 	});
-	writeScript(`((p,h,d,l=$=>{d||${insert}})=>${exprs.length > 1 ? `{${exprs.join(";")}}` : exprs[0]})(document.currentScript,${htmlStr})`);
+	return `((h,d,l=$=>{d||${insert}})=>${exprs.length > 1 ? `{${exprs.join(";")}}` : exprs[0]})(${htmlStr})`;
 }
 function querySelectorOrLoad(selector) {
 	return `document.querySelector(${JSON.stringify(selector)})||${`(console.warn(${JSON.stringify(`A lazy load trigger could not find an element matching "${selector}". The module was loaded immediately.`)}),l())`}`;
@@ -3674,6 +3877,7 @@ const K_TAGS_API_STATE = Symbol();
 const COMPAT_REGISTRY = /* @__PURE__ */ new WeakMap();
 const compat = {
 	$global,
+	writeLoadAsset,
 	fork: _await,
 	write: _html,
 	writeScript,
@@ -3697,7 +3901,10 @@ const compat = {
 	onFlush(fn) {
 		const { flushHTML } = Chunk.prototype;
 		Chunk.prototype.flushHTML = function(boundary) {
+			const { state } = boundary;
+			const reorders = swapReorders(state, null);
 			fn(this);
+			swapReorders(state, reorders);
 			return flushHTML.call(this, boundary);
 		};
 	},
@@ -3723,21 +3930,52 @@ const compat = {
 			return compatRegistered;
 		};
 	},
+	joinChunks(chunks) {
+		let joined;
+		for (const chunk of chunks) {
+			if (chunk.boundary.aborted) continue;
+			if (joined) joined.append(chunk);
+			else joined = chunk;
+		}
+		return joined;
+	},
+	appendChunks(chunks) {
+		const chunk = getChunk();
+		for (const part of chunks) {
+			chunk.append(part);
+			if (part.effects) chunk.lastEffect = part.lastEffect;
+		}
+	},
+	deferReorders(reorders) {
+		const chunk = getChunk();
+		for (let i = reorders.length; i--;) {
+			const carrier = chunk.fork(chunk.boundary, chunk.next);
+			carrier.deferredReorder = reorders[i];
+			chunk.next = carrier;
+		}
+	},
 	createChunk($global) {
 		const state = this.ensureState($global);
 		return new Chunk(new Boundary(state), null, null, state);
 	},
-	flushScript($global, chunk) {
-		chunk ||= this.createChunk($global);
+	flushScript(chunk, reorders) {
 		const { boundary } = chunk;
-		const scripts = boundary.flush() === 0 ? chunk.flushScript(boundary).scripts : "";
-		if (boundary.signal.aborted) throw boundary.signal.reason;
+		const { state } = boundary;
+		let html = "";
+		let scripts = "";
+		if (reorders) for (const reorder of reorders) state.reorder(reorder);
+		if (boundary.flush() === 0) ({html, scripts} = chunk.flushScript(boundary));
+		if (boundary.aborted) throw boundary.reason;
 		if (boundary.count) throw new Error("Cannot serialize promise across tags/class compat layer.");
-		return scripts;
+		return {
+			html,
+			scripts
+		};
 	},
-	render(renderer, willRerender, classAPIOut, component, input, completeChunks, registerChildScope) {
+	render(renderer, willRerender, classAPIOut, component, input, componentScopes, registerChildScope, parentChunk) {
+		if (parentChunk?.boundary.aborted) return;
 		const state = this.ensureState(classAPIOut.global);
-		const boundary = new Boundary(state);
+		const boundary = new Boundary(state, void 0, parentChunk?.boundary);
 		const context = getChunk()?.context ?? null;
 		let head = new Chunk(boundary, new Chunk(boundary, null, context, state), context, state);
 		let normalizedInput = input;
@@ -3745,7 +3983,8 @@ const compat = {
 			normalizedInput = {};
 			for (const key in input) normalizedInput[key === "renderBody" ? "content" : key] = input[key];
 		}
-		head.render(() => {
+		const componentScope = new Chunk(boundary, null, context, state);
+		componentScope.render(() => {
 			if (this.hasPendingClassFunctions(classAPIOut.global)) drainClassFunctions(classAPIOut.global, (hostId) => {
 				const fnScopeId = _scope_id();
 				const scope = writeScope(fnScopeId, {
@@ -3760,11 +3999,13 @@ const compat = {
 				writeScope(scopeId, { m5c: component.id });
 				_script(scopeId, SET_SCOPE_REGISTER_ID);
 			}
-			_set_serialize_reason(willRerender ? CLIENT_ALL : 0);
+		});
+		head.render(() => {
+			_set_scope_reason(willRerender ? CLIENT_ALL : 0);
 			try {
 				renderer(normalizedInput);
 			} finally {
-				_set_serialize_reason(void 0);
+				_set_scope_reason(void 0);
 			}
 			const asyncOut = classAPIOut.beginAsync({
 				last: true,
@@ -3772,17 +4013,29 @@ const compat = {
 			});
 			classAPIOut.onLast((next) => {
 				(boundary.onNext = () => {
-					if (boundary.signal.aborted) {
-						asyncOut.error(boundary.signal.reason);
+					if (boundary.aborted) {
 						boundary.onNext = NOOP;
+						if (parentChunk?.boundary.aborted) {
+							asyncOut.end();
+							next();
+						} else asyncOut.error(boundary.reason);
 					} else if (!boundary.count) {
 						boundary.onNext = NOOP;
-						head = head.consume();
+						const queued = swapReorders(state, null);
+						head = head.consume(boundary);
+						const reorders = swapReorders(state, queued);
+						if (reorders) asyncOut.writer.get("reorders").push(...reorders);
+						const heldEffects = head.takeHeldEffects();
+						if (heldEffects) {
+							head.effects = joinHeldEffects(heldEffects, head.effects);
+							head.lastEffect = "";
+						}
 						asyncOut.write(head.html);
 						asyncOut.script(head.scripts);
-						asyncOut.end();
 						head.html = head.scripts = "";
-						completeChunks.push(head);
+						asyncOut.writer.get("chunks").push(head);
+						asyncOut.end();
+						componentScopes.push(componentScope);
 						next();
 					}
 				})();
@@ -3820,9 +4073,15 @@ function drainClassFunctions($global, writeScope) {
 	for (const [id, fn, hostId] of pending) register(id, fn, scopeByHost[hostId] ||= writeScope(hostId));
 	pending.length = 0;
 }
+function swapReorders(state, reorders) {
+	const { writeReorders } = state;
+	state.writeReorders = reorders;
+	return writeReorders;
+}
 function NOOP() {}
 //#endregion
 exports.$global = $global;
+exports._assert_class_toggles = _assert_class_toggles;
 exports._assert_hoist = _assert_hoist;
 exports._attr = _attr;
 exports._attr_and = _attr_and;
@@ -3889,9 +4148,7 @@ exports._scope_id = _scope_id;
 exports._scope_reason = _scope_reason;
 exports._scope_with_id = _scope_with_id;
 exports._script = _script;
-exports._serialize_guard = _serialize_guard;
-exports._serialize_if = _serialize_if;
-exports._set_serialize_reason = _set_serialize_reason;
+exports._set_scope_reason = _set_scope_reason;
 exports._show_end = _show_end;
 exports._show_start = _show_start;
 exports._style_html = _style_html;
@@ -3904,6 +4161,8 @@ exports._trailers = _trailers;
 exports._try = _try;
 exports._unescaped = _unescaped;
 exports._var = _var;
+exports._write_guard = _write_guard;
+exports._write_if = _write_if;
 exports.attrTag = attrTag;
 exports.attrTags = attrTags;
 exports.compat = compat;