marko 6.3.44 → 6.3.45

package/cheatsheet.md

@@ -7,7 +7,7 @@ Marko 6 = HTML superset, not JSX and not Marko 4/5 syntax. `.marko` files are co
 1. Text interpolation: `${expr}` inside tag bodies. A bare line at the template root parses as a tag (concise mode): `Welcome aboard` fails to compile, but `p is a tag` compiles **silently** to `<p is a tag></p>`, since any line starting with a real tag name loses its words to attributes. Wrap text in an element (`<p>Welcome aboard</p>`) or prefix the line with `--` and a space (`-- Welcome ${name}`). Attributes take raw JS after `=` with no braces or quotes: `<div title=user.name data-n=1 + 1>`.
 2. A top-level `>` hugging its operand in an attribute value **ends the tag** silently: `<button disabled=count>=8 onClick() {…}>More</button>` is `disabled=count` plus the text `=8 onClick() {…}>`, so the handler never binds. Space a `>=` (`disabled=count >= 8`), and parenthesize a bare `>` comparison (`hidden=(a > b)`) and a TS type argument `<let/s=(new Set<string>())>`. Do not move the type onto the tag variable instead: `<let/s:Set<string>=new Set()>` compiles but fails type-check with TS2322 (the annotation does not flow into the initializer). A `>` nested inside `(…)`/`{…}`/`[…]` is safe (`class={ big: n > 1 }`). `<` never closes a tag (`disabled=count<=1` is fine).
 3. State: `<let/name=initial>` (slash then var name!). Update by plain assignment in an event handler: `count++`, `text = "hi"`. No setState, no hooks.
-4. Derived values: `<const/total=items.length * price>` auto-recomputes. Never use an effect to derive state. A tag variable is whatever the tag returns, not the attribute you passed. `<let/draft=input.text>` re-runs on every `input.text` change but returns state it controls, so `draft` keeps your edits. Pick by intent: recomputes → `<const>`, seeds then diverges → `<let>`. A `<let>` you never assign is just a frozen `<const>`. Updates batch: mid-handler a reassigned `<let>` reads current but its derived `<const>` reads stale, so recompute from the `<let>`.
+4. Derived values: `<const/total=items.length * price>` auto-recomputes. Never use an effect to derive state. A tag variable is whatever the tag returns, not the attribute you passed. `<let/draft=input.text>` re-runs on every `input.text` change but returns state it controls, so `draft` keeps your edits; only a controllable `<let>` (`valueChange=`, or `<let/draft:=input.text>`) takes the new value. Pick by intent: recomputes → `<const>`, seeds then diverges → `<let>`. A `<let>` you never assign is just a frozen `<const>`. Updates batch: mid-handler a reassigned `<let>` reads current but its derived `<const>` reads stale, so recompute from the `<let>`.
 5. Never mutate state in place: `items.push(x)` does not update the UI. Always reassign:
    - add: `items = items.concat(x)`
    - remove: `items = items.toSpliced(i, 1)`
@@ -15,9 +15,9 @@ Marko 6 = HTML superset, not JSX and not Marko 4/5 syntax. `.marko` files are co
    - object: `user = { ...user, name }`
 6. Events: method shorthand `onClick() { ... }` or `onClick=fn`. Handlers receive `(event, element)`; delegation means the element is the second parameter, not `event.currentTarget`: `onSubmit(e) { e.preventDefault(); save() }`, `onClick(e, el) { el.focus() }`. Don't sync input values through `onInput`/`onChange`; that's what the change handlers below are for. Prefix with `async` to `await` in the body: `async onClick() { await save() }`.
 7. Native inputs are uncontrolled by default: `value=` sets the default value — later writes update what `form.reset()` restores, never a dirty field's display. Adding the matching `*Change` handler is what makes them controlled: `valueChange` on `<input>`/`<textarea>`/`<select>`, `checkedChange` on checkboxes/radios, `openChange` on `<details>`/`<dialog>`. `value:=text` is the shorthand for `value=text valueChange(v) { text = v }`. (`<textarea value:=text/>`: value attribute, not body.) `:=` differs by operand: on an identifier (`value:=text`) it assigns that variable; on a member expression (`<let/count:=input.count>` in a child) it wires `input.countChange`, so the child is controlled when the parent passes that handler and keeps its own state when it doesn't.
-8. Transform in the handler when needed; number inputs give strings: `<input type="number" value=n valueChange(v) { n = +v }>`, or `value:parseFloat:=n`.
+8. Transform in the handler when needed; number inputs give strings: `<input type="number" value=n valueChange(v) { n = +v }>`, or `value:parseFloat:=n`. Uncommitted edits (debounce, commit on blur) never sync through a `<script>`; that is rule 4's derive-by-effect trap. Pair a controllable `<let/value:=input.value>` with `<let/pending=null>`, show `<const/draft=pending ?? value>`, collect with `valueChange(v) { pending = v }`, and commit by assigning `value = pending; pending = null`. Prefer that to calling `input.valueChange(...)`, which throws unless every caller controls the tag.
 9. Radio/checkbox groups: `checkedValue:=picked` on each input (shared var, distinct `value=`); the match is checked; array var for multi-checkbox. Dropdown: `<select value:=picked>`.
-10. Module-level values, helpers and type aliases need `static`: `static const LIMIT = 10`, `static function fmt(n) {…}`, `static type Row = {…}`. Without it `function fmt(n) {` parses as a tag: ``Unable to find entry point for custom tag `<function>` ``, an error that never says `static`. Prefer it to `<const>` for anything that never changes: `<const/LIMIT=10>` emits a per-instance signal plus a `$setup` call. `server`/`client` narrow `static` to one platform (`client import { Chart } from "chart"`); the binding is `undefined` on the other, so read a `client` one only from `<script>`/handlers/`<lifecycle>` — reading it while rendering throws `is not a function` during SSR.
+10. Module-level values, helpers and type aliases need `static`: `static const LIMIT = 10`, `static function fmt(n) {…}`, `static type Row = {…}`. Without it `function fmt(n) {` parses as a tag: ``Unable to find entry point for custom tag `<function>` ``, an error that points at `static`. Prefer it to `<const>` for anything that never changes: `<const/LIMIT=10>` emits a per-instance signal plus a `$setup` call. `server`/`client` narrow `static` to one platform (`client import { Chart } from "chart"`); the binding is `undefined` on the other, so read a `client` one only from `<script>`/handlers/`<lifecycle>` — reading it while rendering throws `is not a function` during SSR.
 
 ## Canonical component
 
@@ -129,6 +129,7 @@ Don't fetch while rendering: start data loads early, pass the promise through th
 - Conditional attrs: `false`/`null` attrs are omitted from HTML. `aria-selected` etc. want strings: `aria-selected=(i === active && "true")`.
 - `class=` / `style=` accept strings, objects, arrays: `class=["btn", { active }]`, `style={ color }` (single braces). `style=` keys are kebab-case CSS names (`{ "background-color": c }`), not camelCase.
 - `<id/x>` mints a collision-free id for label/input wiring (`<label for=x>`/`<input id=x>`); don't hardcode ids in reusable tags; `<id/x=input.id>` reuses a caller's.
+- Head tags render where written: a `<title>`/`<meta>`/`<link>` inside a nested component stays in the body, giving a second title or an inert canonical. `<head>` is already written by the time descendants render, so page meta has to be known before it: under @marko/run declare it in the route's `+meta.*` file and read `$global.meta` from the layout that owns `<head>`, otherwise pass it down or set it on `$global` at the render call.
 
 ## Sharing data (`$global`)
 
@@ -201,6 +202,7 @@ Each left-hand habit is an error or silently wrong.
 | `const [x, setX] = useState()` / `state` / `class {}` block | `<let/x=0>` then `x = 1`                                                             |
 | `$ const y = x * 2;` (scriptlets are removed)               | `<const/y=x * 2>`                                                                    |
 | `<let/n=a + b>` for a value that should recompute           | `<const/n=a + b>`; `<let>` seeds an initial value, then de-syncs by design           |
+| `<let/x=input.x>` expecting it to track `input.x`           | `<const/x=input.x>`, or `<let/x:=input.x>` to make it controllable                   |
 | `function fmt(n) {…}` / `const LIMIT = 10` at module level  | `static function fmt(n) {…}` / `static const LIMIT = 10`                             |
 | `type Row = {…}` at module level                            | `static type Row = {…}`                                                              |
 | `<let x=0>`                                                 | `<let/x=0>`                                                                          |
@@ -213,6 +215,7 @@ Each left-hand habit is an error or silently wrong.
 | bare text on its own line at template root                  | wrap in an element (`<p>...`), or prefix the line with `--` and a space              |
 | `by=item` using the loop variable                           | `by="propName"` or `by=(item) => key`; `by=` is evaluated outside the loop           |
 | `onInput(e) { q = e.target.value }` to sync an input        | `value:=q`; the change handler owns the value                                        |
+| `<script>` syncing a draft field back from `value`          | `<const/draft=pending ?? value>`; a `<let>` holds only the uncommitted edit          |
 | fetching inside the component that renders the data         | start the promise early (route handler / top of template), pass it down to `<await>` |
 | `style={ backgroundColor: c }` (camelCase keys)             | `style={ "background-color": c }` (kebab-case)                                       |
 | `this.querySelector` / `this.getRootNode()` in `<script>`   | element ref getter: `<div/el>` then `el()` (there is no `this`)                      |
@@ -221,6 +224,7 @@ Each left-hand habit is an error or silently wrong.
 | hand-rolled `IntersectionObserver` to defer a widget's JS   | `import W from "<w>" with { load: "visible#sel" }`                                   |
 | imperative lib wired through `<script>` mount + cleanup     | `<lifecycle onMount/onUpdate/onDestroy>` (keeps `this` across all three)             |
 | `createContext`/provider to share data                      | `input` (prop drilling) or request-scoped `$global`                                  |
+| `<title>`/`<meta>` in a nested component                    | put page meta in the layout that owns `<head>`; head tags never hoist                |
 | `$global.x` in client-reactive code, not allow-listed       | `$global.serializedGlobals = { x: true }` first; otherwise the read is `undefined`   |
 | hand-namespaced global classes (`.my-card-title`)           | `<style/styles>` + `class=styles.card` (scoped CSS modules)                          |
 | `tsc --noEmit` to type check templates                      | `mtc`; `tsc` skips `.marko` files and exits 0                                        |

package/dist/debug/html.js

@@ -1011,7 +1011,8 @@ const replaceUnsafeRegExpSourceChar = (match) => {
 };
 function writeRegExp(state, val) {
 	const { source } = val;
-	state.buf.push("/" + (unsafeRegExpSourceDetect.test(source) ? source.replace(unsafeRegExpSourceReg, replaceUnsafeRegExpSourceChar) : source) + "/" + val.flags);
+	if (source.includes("<")) state.buf.push(`RegExp(${quote(source, 0)}${val.flags ? ",\"" + val.flags + "\"" : ""})`);
+	else state.buf.push("/" + (unsafeRegExpSourceDetect.test(source) ? source.replace(unsafeRegExpSourceReg, replaceUnsafeRegExpSourceChar) : source) + "/" + val.flags);
 	return true;
 }
 function writePromise(state, val, ref) {

package/dist/debug/html.mjs

@@ -1009,7 +1009,8 @@ const replaceUnsafeRegExpSourceChar = (match) => {
 };
 function writeRegExp(state, val) {
 	const { source } = val;
-	state.buf.push("/" + (unsafeRegExpSourceDetect.test(source) ? source.replace(unsafeRegExpSourceReg, replaceUnsafeRegExpSourceChar) : source) + "/" + val.flags);
+	if (source.includes("<")) state.buf.push(`RegExp(${quote(source, 0)}${val.flags ? ",\"" + val.flags + "\"" : ""})`);
+	else state.buf.push("/" + (unsafeRegExpSourceDetect.test(source) ? source.replace(unsafeRegExpSourceReg, replaceUnsafeRegExpSourceChar) : source) + "/" + val.flags);
 	return true;
 }
 function writePromise(state, val, ref) {

package/dist/html.js

@@ -780,7 +780,7 @@ function writeDate(state, val) {
 }
 function writeRegExp(state, val) {
 	let { source } = val;
-	return state.buf.push("/" + (unsafeRegExpSourceDetect.test(source) ? source.replace(unsafeRegExpSourceReg, replaceUnsafeRegExpSourceChar) : source) + "/" + val.flags), !0;
+	return source.includes("<") ? state.buf.push(`RegExp(${quote(source, 0)}${val.flags ? ",\"" + val.flags + "\"" : ""})`) : state.buf.push("/" + (unsafeRegExpSourceDetect.test(source) ? source.replace(unsafeRegExpSourceReg, replaceUnsafeRegExpSourceChar) : source) + "/" + val.flags), !0;
 }
 function writePromise(state, val, ref) {
 	let { boundary, channel } = state;

package/dist/html.mjs

@@ -779,7 +779,7 @@ function writeDate(state, val) {
 }
 function writeRegExp(state, val) {
 	let { source } = val;
-	return state.buf.push("/" + (unsafeRegExpSourceDetect.test(source) ? source.replace(unsafeRegExpSourceReg, replaceUnsafeRegExpSourceChar) : source) + "/" + val.flags), !0;
+	return source.includes("<") ? state.buf.push(`RegExp(${quote(source, 0)}${val.flags ? ",\"" + val.flags + "\"" : ""})`) : state.buf.push("/" + (unsafeRegExpSourceDetect.test(source) ? source.replace(unsafeRegExpSourceReg, replaceUnsafeRegExpSourceChar) : source) + "/" + val.flags), !0;
 }
 function writePromise(state, val, ref) {
 	let { boundary, channel } = state;

package/dist/translator/index.js

@@ -35,8 +35,6 @@ let package_json = require("../../package.json");
 package_json = __toESM(package_json, 1);
 let _marko_compiler = require("@marko/compiler");
 let _marko_compiler_babel_utils = require("@marko/compiler/babel-utils");
-let node_path = require("node:path");
-node_path = __toESM(node_path, 1);
 let path = require("path");
 path = __toESM(path, 1);
 let magic_string = require("magic-string");
@@ -1201,6 +1199,37 @@ function getSerializeSourcesForRef(ref) {
 		} else return ref.sources;
 	}
 }
+function mapCrossProgramReason(program, reason, exprs) {
+	let params;
+	let mapped;
+	let crossProgram = false;
+	forEach(reason.param, (param) => {
+		if (param.section.program === program) params = bindingUtil.add(params, param);
+		else {
+			crossProgram = true;
+			mapped = exprs ? mergeSerializeReasons(mapped, getSerializeSourcesForExprs(mapParamBindingToExpr(exprs, param))) : true;
+		}
+	});
+	if (!crossProgram) return reason;
+	return mergeRemappedSources(reason, params, mapped);
+}
+function mapDownstreamReason(program, reason, exprs) {
+	let params;
+	let mapped;
+	let downstream = false;
+	forEach(reason.param, (param) => {
+		if (param.section.program === program) {
+			downstream = true;
+			mapped = mergeSerializeReasons(mapped, getSerializeSourcesForExprs(mapParamBindingToExpr(exprs, param)));
+		} else params = bindingUtil.add(params, param);
+	});
+	if (!downstream) return reason;
+	return mergeRemappedSources(reason, params, mapped);
+}
+function mergeRemappedSources(reason, params, mapped) {
+	if (mapped !== true && (reason.state || reason.global || params)) mapped = mergeSerializeReasons(mapped, createSources(reason.state, params, reason.global));
+	return mapped;
+}
 function mergeSerializeReasons(a, b) {
 	if (a === true || b === true) return true;
 	return mergeSources(a, b);
@@ -1347,6 +1376,7 @@ function analyzeTagNameType(tag, allowDynamic) {
 				extra.tagNameType = 2;
 				extra.tagNameDynamic = true;
 				extra.featureType = "class";
+				if (childFile?.ast.program.extra?.hydratesTags) (0, _marko_compiler_babel_utils.getProgram)().node.extra.isInteractive = true;
 			} else if (!childFile) {
 				extra.tagNameType = 2;
 				extra.tagNameDynamic = true;
@@ -1447,6 +1477,7 @@ function startSection(path) {
 			loc: parentTag?.node.name.loc || void 0,
 			depth: parentSection ? parentSection.depth + 1 : 0,
 			parent: parentSection,
+			program: void 0,
 			sectionAccessor: void 0,
 			params: void 0,
 			referencedLocalClosures: void 0,
@@ -1470,6 +1501,7 @@ function startSection(path) {
 			isBranch: false,
 			structure: parentSection && !parentSection.structure ? null : []
 		};
+		section.program = parentSection ? parentSection.program : section;
 		sections.push(section);
 	}
 	return section;
@@ -1573,7 +1605,8 @@ function getSectionRegisterReasons(section) {
 	if (section.isBranch) return false;
 	const { downstreamBinding } = section;
 	if (downstreamBinding) {
-		const downstreamReasons = getAllSerializeReasonsForBinding(downstreamBinding.binding, downstreamBinding.properties);
+		let downstreamReasons = getAllSerializeReasonsForBinding(downstreamBinding.binding, downstreamBinding.properties);
+		if (downstreamReasons && downstreamReasons !== true) downstreamReasons = mapCrossProgramReason(section.program, downstreamReasons, downstreamBinding.exprs);
 		if (!downstreamReasons) return false;
 		if (isReasonDynamic(downstreamReasons) && !section.serializeReason && !section.serializeReasons.size && !section.parent?.serializeReason && !section.parent?.serializeReasons.size) return false;
 		return downstreamReasons;
@@ -1913,6 +1946,26 @@ function isClientAssetImport(file, request) {
 	return typeof hydrateIncludeImports === "function" ? hydrateIncludeImports(request) : !!hydrateIncludeImports?.test(request);
 }
 //#endregion
+//#region src/translator/util/binding-has-prop.ts
+function isSectionRendererElided(section) {
+	return !!section.downstreamBinding && !bindingHasProperty(section.downstreamBinding.binding, section.downstreamBinding.properties);
+}
+function bindingHasProperty(binding, properties) {
+	if (binding.pruned) return false;
+	else if (binding.pruned === void 0) throw new Error("Binding must be pruned before checking properties");
+	if (binding.reads.size || !properties) return true;
+	let property;
+	let rest;
+	if (Array.isArray(properties)) {
+		property = properties[0];
+		rest = properties.length === 2 ? properties[1] : properties.slice(1);
+	} else property = properties;
+	const propBinding = binding.propertyAliases.get(property);
+	if (propBinding && bindingHasProperty(propBinding, rest)) return true;
+	for (const alias of binding.aliases) if (bindingHasProperty(alias, properties)) return true;
+	return false;
+}
+//#endregion
 //#region src/translator/util/binding-prop-tree.ts
 const kDirectContent = Symbol("direct content");
 function getBindingPropTree(binding) {
@@ -1973,35 +2026,70 @@ function resolveRelativeToEntry(entryFile, file, req) {
 //#endregion
 //#region src/translator/util/entry-builder.ts
 const kState = Symbol();
-var entry_builder_default = {
+const builder = {
 	build(entryFile, exportInit) {
 		const state = entryFile[kState];
 		if (!state) throw entryFile.path.buildCodeFrameError("Unable to build hydrate code, no files were visited before finalizing the build");
 		const body = [];
-		if (state.init) {
+		for (const asset of state.assets) body.push(_marko_compiler.types.importDeclaration([], _marko_compiler.types.stringLiteral(asset)));
+		if (state.init || state.load) {
 			const isPage = entryFile.path.node.extra.page;
 			const initHelper = isPage ? "init" : "initEmbedded";
-			body.push(_marko_compiler.types.importDeclaration([_marko_compiler.types.importSpecifier(_marko_compiler.types.identifier(initHelper), _marko_compiler.types.identifier(initHelper))], _marko_compiler.types.stringLiteral(`${runtime_info_default.name}/${entryFile.markoOpts.optimize ? "" : "debug/"}dom`)), _marko_compiler.types.importDeclaration([], _marko_compiler.types.stringLiteral(`./${node_path.default.basename(entryFile.opts.filename)}`)));
+			if (state.init) body.push(_marko_compiler.types.importDeclaration([_marko_compiler.types.importSpecifier(_marko_compiler.types.identifier(initHelper), _marko_compiler.types.identifier(initHelper))], _marko_compiler.types.stringLiteral(`${runtime_info_default.name}/${entryFile.markoOpts.optimize ? "" : "debug/"}dom`)));
+			for (const root of state.roots) body.push(_marko_compiler.types.importDeclaration([], _marko_compiler.types.stringLiteral(root)));
+			if (!state.init) {
+				if (exportInit) body.push(_marko_compiler.types.exportDefaultDeclaration(_marko_compiler.types.arrowFunctionExpression([], _marko_compiler.types.blockStatement([]))));
+				return body;
+			}
 			const { runtimeId } = entryFile.markoOpts;
 			const readyId = !isPage && (0, _marko_compiler_babel_utils.getTemplateId)(entryFile.markoOpts, entryFile.opts.filename);
 			const initExpression = _marko_compiler.types.callExpression(_marko_compiler.types.identifier(initHelper), readyId ? runtimeId ? [_marko_compiler.types.stringLiteral(readyId), _marko_compiler.types.stringLiteral(runtimeId)] : [_marko_compiler.types.stringLiteral(readyId)] : runtimeId ? [_marko_compiler.types.stringLiteral(runtimeId)] : []);
 			body.push(exportInit ? _marko_compiler.types.exportDefaultDeclaration(_marko_compiler.types.arrowFunctionExpression([], initExpression)) : _marko_compiler.types.expressionStatement(initExpression));
 		} else {
-			for (const asset of state.assets) body.push(_marko_compiler.types.importDeclaration([], _marko_compiler.types.stringLiteral(asset)));
+			for (const asset of state.bundledAssets) body.push(_marko_compiler.types.importDeclaration([], _marko_compiler.types.stringLiteral(asset)));
 			if (exportInit) body.push(_marko_compiler.types.exportDefaultDeclaration(_marko_compiler.types.arrowFunctionExpression([], _marko_compiler.types.blockStatement([]))));
 		}
 		return body;
 	},
-	visit(file, entryFile, visitChild) {
+	visit(file, entryFile, visitChild = (id, bundled = false) => {
+		const state = entryFile[kState];
+		const resolved = resolveRelativeToEntry(entryFile, file, id);
+		const seenBundled = state.visited.get(resolved);
+		if (seenBundled === false || seenBundled && bundled) return;
+		state.visited.set(resolved, bundled);
+		const childFile = (0, _marko_compiler_babel_utils.loadFileForImport)(entryFile, resolved);
+		if (childFile) builder.visit(childFile, entryFile);
+	}) {
 		const state = entryFile[kState] ||= {
 			init: false,
-			assets: /* @__PURE__ */ new Set()
+			load: false,
+			bundled: 0,
+			roots: [],
+			assets: /* @__PURE__ */ new Set(),
+			bundledAssets: /* @__PURE__ */ new Set(),
+			visited: /* @__PURE__ */ new Map([[(0, _marko_compiler_babel_utils.resolveRelativePath)(entryFile, entryFile.opts.filename), false]])
 		};
 		const programExtra = file.path.node.extra;
 		const { analyzedTags, assetImports } = file.metadata.marko;
-		if (programExtra.isInteractive || programExtra.needsCompat) state.init = true;
-		if (assetImports) for (const request of assetImports) state.assets.add(resolveRelativeToEntry(entryFile, file, request));
-		for (const tag of analyzedTags || []) visitChild(tag);
+		const { loadImports } = programExtra;
+		const init = !!(programExtra.isInteractive || programExtra.needsCompat);
+		const load = !!programExtra.hasClientStatement;
+		const isRoot = !state.bundled && (init || load || !!programExtra.hasResumes);
+		if (init) state.init = true;
+		if (load) state.load = true;
+		if (isRoot) state.roots.push((0, _marko_compiler_babel_utils.resolveRelativePath)(entryFile, file.opts.filename));
+		if (assetImports) {
+			const assets = isRoot || state.bundled ? state.bundledAssets : state.assets;
+			for (const request of assetImports) assets.add(resolveRelativeToEntry(entryFile, file, request));
+		}
+		if (isRoot) state.bundled++;
+		for (const tag of analyzedTags ? [...analyzedTags] : []) {
+			const lazy = loadImports?.has(tag);
+			if (lazy) state.bundled++;
+			visitChild(tag, !!state.bundled);
+			if (lazy) state.bundled--;
+		}
+		if (isRoot) state.bundled--;
 	}
 };
 //#endregion
@@ -2536,26 +2624,6 @@ function sectionHasSetupStatements(section) {
 	return false;
 }
 //#endregion
-//#region src/translator/util/binding-has-prop.ts
-function isSectionRendererElided(section) {
-	return !!section.downstreamBinding && !bindingHasProperty(section.downstreamBinding.binding, section.downstreamBinding.properties);
-}
-function bindingHasProperty(binding, properties) {
-	if (binding.pruned) return false;
-	else if (binding.pruned === void 0) throw new Error("Binding must be pruned before checking properties");
-	if (binding.reads.size || !properties) return true;
-	let property;
-	let rest;
-	if (Array.isArray(properties)) {
-		property = properties[0];
-		rest = properties.length === 2 ? properties[1] : properties.slice(1);
-	} else property = properties;
-	const propBinding = binding.propertyAliases.get(property);
-	if (propBinding && bindingHasProperty(propBinding, rest)) return true;
-	for (const alias of binding.aliases) if (bindingHasProperty(alias, properties)) return true;
-	return false;
-}
-//#endregion
 //#region src/translator/util/module-registrations.ts
 /**
 * Writes the registrations for module scoped functions: the ones this template
@@ -6364,6 +6432,9 @@ var program_default = {
 			const paramsBinding = programExtra.binding;
 			if (paramsBinding && !paramsBinding.pruned) programExtra.domExports.params = getBindingPropTree(paramsBinding);
 			const section = programExtra.section;
+			forEachSection((childSection) => {
+				programExtra.hasResumes ||= !!(childSection.serializeReason || childSection.serializeReasons.size || childSection !== section && !isSectionRendererElided(childSection) && getSectionRegisterReasons(childSection));
+			});
 			if (!section.hoistedTo && !sectionHasSetupStatements(section)) programExtra.domExports.setupEmpty = true;
 		}
 	},
@@ -6388,16 +6459,8 @@ var program_default = {
 				}
 				if (isDOMPageEntry) {
 					const entryFile = program.hub.file;
-					const { filename } = entryFile.opts;
-					const visitedFiles = /* @__PURE__ */ new Set([(0, _marko_compiler_babel_utils.resolveRelativePath)(entryFile, filename)]);
-					entry_builder_default.visit(entryFile, entryFile, function visitChild(resolved) {
-						if (!visitedFiles.has(resolved)) {
-							visitedFiles.add(resolved);
-							const file = (0, _marko_compiler_babel_utils.loadFileForImport)(entryFile, resolved);
-							if (file) entry_builder_default.visit(file, entryFile, (id) => visitChild(resolveRelativeToEntry(entryFile, file, id)));
-						}
-					});
-					program.node.body = entry_builder_default.build(entryFile);
+					builder.visit(entryFile, entryFile);
+					program.node.body = builder.build(entryFile);
 					program.skip();
 					return;
 				}
@@ -6444,13 +6507,16 @@ var program_default = {
 //#endregion
 //#region src/translator/util/set-tag-sections-downstream.ts
 const [getTagDownstreams] = createSectionState("tag-downstreams", () => /* @__PURE__ */ new Map());
-function setTagDownstream(tag, binding) {
-	if (binding) getTagDownstreams(getSection(tag)).set(tag, binding);
+function setTagDownstream(tag, binding, exprs) {
+	if (binding) getTagDownstreams(getSection(tag)).set(tag, {
+		binding,
+		exprs
+	});
 }
 function finalizeTagDownstreams(section) {
-	for (const [tag, binding] of getTagDownstreams(section)) crawlSectionsAndSetBinding(tag, binding);
+	for (const [tag, { binding, exprs }] of getTagDownstreams(section)) crawlSectionsAndSetBinding(tag, binding, exprs);
 }
-function crawlSectionsAndSetBinding(tag, binding, properties, skip) {
+function crawlSectionsAndSetBinding(tag, binding, exprs, properties, skip) {
 	if (!skip) {
 		const contentSection = getSectionForBody(tag.get("body"));
 		if (contentSection) {
@@ -6460,7 +6526,8 @@ function crawlSectionsAndSetBinding(tag, binding, properties, skip) {
 			});
 			contentSection.downstreamBinding = target && (target.noSerialize || includes(target.noSerializeProperties, "content")) ? false : {
 				binding,
-				properties: concat(properties, "content")
+				properties: concat(properties, "content"),
+				exprs
 			};
 		}
 	}
@@ -6469,8 +6536,8 @@ function crawlSectionsAndSetBinding(tag, binding, properties, skip) {
 	const attrTags = getAttrTagPaths(tag);
 	for (const child of attrTags) if (child.isMarkoTag()) if ((0, _marko_compiler_babel_utils.isAttributeTag)(child)) {
 		const attrTagMeta = attrTagLookup[getTagName(child)];
-		crawlSectionsAndSetBinding(child, binding, concat(properties, attrTagMeta.name));
-	} else crawlSectionsAndSetBinding(child, binding, properties, true);
+		crawlSectionsAndSetBinding(child, binding, exprs, concat(properties, attrTagMeta.name));
+	} else crawlSectionsAndSetBinding(child, binding, exprs, properties, true);
 }
 //#endregion
 //#region src/translator/util/translate-var.ts
@@ -6537,10 +6604,10 @@ function knownTagAnalyze(tag, contentSection, propTree) {
 	startSection(tagBody);
 	trackParamsReferences(tagBody, 3);
 	getKnownTags(section).push(tagExtra);
-	setTagDownstream(tag, propTree?.props?.[0]?.binding);
 	tagExtra[kContentSection] = contentSection;
 	const varBinding = trackVarReferences(tag, 5);
 	const exprs = tagExtra[kKnownExprs] = analyzeParams(tagExtra, section, tag, propTree, attrExprs);
+	setTagDownstream(tag, propTree?.props?.[0]?.binding, exprs);
 	if (varBinding) {
 		addSetupStatement(section);
 		const mutatesTagVar = !!(tag.node.var.type === "Identifier" && tag.scope.getBinding(tag.node.var.name)?.constantViolations.length);
@@ -6656,7 +6723,7 @@ function analyzeParams(rootTagExtra, section, tag, propTree, rootAttrExprs) {
 	}
 	if (!propTree.props || propTree.rest || tag.node.arguments?.some((node) => _marko_compiler.types.isSpreadElement(node))) {
 		const extra = inputExpr.value = mergeReferences(section, tag.node, getAllTagReferenceNodes(tag.node));
-		setBindingDownstream(propTree.binding, extra);
+		setBindingDownstream(propTree.binding, extra, inputExpr);
 		return inputExpr;
 	}
 	const known = inputExpr.known = {};
@@ -6671,7 +6738,7 @@ function analyzeParams(rootTagExtra, section, tag, propTree, rootAttrExprs) {
 		i++;
 	}
 	const attrPropsTree = propTree.props[i];
-	if (attrPropsTree) known[i] = analyzeAttrs(rootTagExtra, section, tag, attrPropsTree, rootAttrExprs);
+	if (attrPropsTree) known[i] = analyzeAttrs(rootTagExtra, section, tag, attrPropsTree, rootAttrExprs, inputExpr);
 	else {
 		const args = tag.node.arguments;
 		tag.node.arguments = null;
@@ -6680,11 +6747,11 @@ function analyzeParams(rootTagExtra, section, tag, propTree, rootAttrExprs) {
 	}
 	return inputExpr;
 }
-function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
+function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs, rootExprs) {
 	const inputExpr = {};
 	if (!propTree.props) {
 		const extra = inputExpr.value = mergeReferences(section, tag.node, getAllTagReferenceNodes(tag.node));
-		setBindingDownstream(propTree.binding, extra);
+		setBindingDownstream(propTree.binding, extra, rootExprs);
 		return inputExpr;
 	}
 	const known = inputExpr.known = {};
@@ -6716,7 +6783,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
 				known[attrTagMeta.name] = { value: rootTagExtra };
 			} else if (childAttrExport.props) {
 				remaining.delete(attrTagMeta.name);
-				known[attrTagMeta.name] = analyzeAttrs(rootTagExtra, section, child, childAttrExport, rootAttrExprs);
+				known[attrTagMeta.name] = analyzeAttrs(rootTagExtra, section, child, childAttrExport, rootAttrExprs, rootExprs);
 			} else analyzeDynamicAttrTagChildGroup(attrTagMeta.group, child);
 		} else {
 			const group = child.node.extra.attributeTagGroup;
@@ -6752,7 +6819,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
 			const groupKnownValue = { value: groupExtra };
 			rootAttrExprs.add(groupExtra);
 			forEach(bindings, (binding) => {
-				setBindingDownstream(binding, groupExtra);
+				setBindingDownstream(binding, groupExtra, rootExprs);
 			});
 			for (const name of group) {
 				const attrTagMeta = attrTagLookup[name];
@@ -6795,7 +6862,7 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
 				known[attr.name] = { value: attrExtra };
 				rootAttrExprs.add(attrExtra);
 				addSetupExpr(section, attr.value);
-				setBindingDownstream(templateExportAttr.binding, attrExtra);
+				setBindingDownstream(templateExportAttr.binding, attrExtra, rootExprs);
 				if (getRootSection(templateExportAttr.binding.section) !== (0, _marko_compiler_babel_utils.getProgram)().node.extra.section && isInvokeOnlyBinding(templateExportAttr.binding)) attrExtra.invokeOnly = true;
 				if (knownSpread && !includes(knownSpread.binding.excludeProperties, attr.name)) addRead(attrExtra, {}, getOrCreatePropertyAlias(knownSpread.binding, attr.name), section, void 0);
 			}
@@ -6813,16 +6880,16 @@ function analyzeAttrs(rootTagExtra, section, tag, propTree, rootAttrExprs) {
 		known[prop] = { value: propExtra };
 		rootAttrExprs.add(propExtra);
 		addRead(propExtra, propExtra, propBinding, section, void 0);
-		setBindingDownstream(templateExportAttr === true ? propTree.rest.binding : templateExportAttr.binding, propExtra);
+		setBindingDownstream(templateExportAttr === true ? propTree.rest.binding : templateExportAttr.binding, propExtra, rootExprs);
 	}
 	else if (spreadReferenceNodes) if (remaining.size || propTree.rest && !propTree.rest.props) {
 		inputExpr.value = mergeReferences(section, tag.node, spreadReferenceNodes);
-		setBindingDownstream(propTree.rest?.binding || propTree.binding, inputExpr.value);
+		setBindingDownstream(propTree.rest?.binding || propTree.binding, inputExpr.value, rootExprs);
 	} else dropNodes(spreadReferenceNodes);
 	else {
 		if (restReferenceNodes) {
 			inputExpr.value = mergeReferences(section, tag.node, restReferenceNodes);
-			setBindingDownstream(propTree.rest.binding, inputExpr.value);
+			setBindingDownstream(propTree.rest.binding, inputExpr.value, rootExprs);
 		}
 		if (remaining.size) addSetupStatement(section);
 		if (propTree.rest && !propTree.rest.props) addSetupExpr(section, tag.node);
@@ -7057,41 +7124,6 @@ function writeAttrsToSignals(tag, propTree, importAlias, info) {
 		if (propTree.rest && !propTree.rest.props) addStatement("render", info.tagSection, tagReferencedBindings, _marko_compiler.types.expressionStatement(_marko_compiler.types.callExpression(info.getBindingIdentifier(propTree.rest.binding, importAlias + "_$rest"), [createScopeReadExpression(info.childScopeBinding, info.tagSection), _marko_compiler.types.objectExpression(restProps || [])])), true);
 	}
 }
-function mapParamReasonToExpr(exprs, reason) {
-	if (reason) {
-		if (reason === true) return true;
-		const result = /* @__PURE__ */ new Set();
-		forEach(reason, (prop) => {
-			forEach(mapParamBindingToExpr(exprs, prop), (expr) => {
-				result.add(expr);
-			});
-		});
-		return fromIter(result);
-	}
-}
-function mapParamBindingToExpr(exprs, binding) {
-	const isWholeAlias = binding.property === void 0 && binding.upstreamAlias !== void 0;
-	const props = [];
-	let curBinding = isWholeAlias ? binding.upstreamAlias : binding;
-	while (curBinding && (curBinding.property !== void 0 || curBinding.upstreamAlias)) {
-		if (curBinding.property !== void 0) props.push(curBinding.property);
-		curBinding = curBinding.upstreamAlias;
-	}
-	let curExpr = exprs;
-	for (let i = props.length; i--;) {
-		const nestedExpr = curExpr.known?.[props[i]];
-		if (!nestedExpr) return curExpr.value;
-		curExpr = nestedExpr;
-	}
-	if (isWholeAlias) {
-		let result = curExpr.value;
-		if (curExpr.known) {
-			for (const key in curExpr.known) if (!includes(binding.excludeProperties, key)) result = concat(result, curExpr.known[key].value);
-		}
-		return result;
-	}
-	return curExpr.value;
-}
 function callStatement(id, ...args) {
 	return _marko_compiler.types.expressionStatement(callExpression(id, ...args));
 }
@@ -7730,10 +7762,11 @@ function getCollapsibleIntersectionSource(intersection, section) {
 	const source = sources.state || sources.param;
 	return source && !Array.isArray(source) && source.section === section && !source.scopeOffset ? source : void 0;
 }
-function setBindingDownstream(binding, expr) {
+function setBindingDownstream(binding, expr, exprs) {
 	getBindingValueExprs().set(binding, expr || false);
 	if (expr && expr !== true) forEach(expr, (expr) => {
 		expr.downstream = bindingUtil.add(expr.downstream, binding);
+		if (exprs) expr.downstreamExprs = exprs;
 	});
 }
 const [getResolvedSources] = createProgramState(() => /* @__PURE__ */ new Set());
@@ -8301,7 +8334,12 @@ function getAllSerializeReasonsForExtra(extra) {
 		else {
 			serializeReasonCache.set(extra, false);
 			forEach(extra.downstream, (binding) => {
-				reason = mergeSerializeReasons(reason, getAllSerializeReasonsForBinding(binding, true));
+				let linked = getAllSerializeReasonsForBinding(binding, true);
+				if (linked && linked !== true) {
+					const exprs = extra.downstreamExprs;
+					if (exprs) linked = mapDownstreamReason(binding.section.program, linked, exprs);
+				}
+				reason = mergeSerializeReasons(reason, linked);
 			});
 		}
 		if (reason) serializeReasonCache.set(extra, reason);
@@ -8383,6 +8421,41 @@ function setReadsOwner(from, to) {
 		cur = cur.parent;
 	}
 }
+function mapParamReasonToExpr(exprs, reason) {
+	if (reason) {
+		if (reason === true) return true;
+		const result = /* @__PURE__ */ new Set();
+		forEach(reason, (prop) => {
+			forEach(mapParamBindingToExpr(exprs, prop), (expr) => {
+				result.add(expr);
+			});
+		});
+		return fromIter(result);
+	}
+}
+function mapParamBindingToExpr(exprs, binding) {
+	const isWholeAlias = binding.property === void 0 && binding.upstreamAlias !== void 0;
+	const props = [];
+	let curBinding = isWholeAlias ? binding.upstreamAlias : binding;
+	while (curBinding && (curBinding.property !== void 0 || curBinding.upstreamAlias)) {
+		if (curBinding.property !== void 0) props.push(curBinding.property);
+		curBinding = curBinding.upstreamAlias;
+	}
+	let curExpr = exprs;
+	for (let i = props.length; i--;) {
+		const nestedExpr = curExpr.known?.[props[i]];
+		if (!nestedExpr) return curExpr.value;
+		curExpr = nestedExpr;
+	}
+	if (isWholeAlias) {
+		let result = curExpr.value;
+		if (curExpr.known) {
+			for (const key in curExpr.known) if (!includes(binding.excludeProperties, key)) result = concat(result, curExpr.known[key].value);
+		}
+		return result;
+	}
+	return curExpr.value;
+}
 //#endregion
 //#region src/translator/core/await.ts
 const kDOMBinding$2 = Symbol("await tag dom binding");
@@ -9811,6 +9884,7 @@ var import_declaration_default = {
 			const { file } = importDecl.hub;
 			const loadFile = tagImport && (0, _marko_compiler_babel_utils.loadFileForImport)(file, value);
 			if (!loadFile) throw importDecl.buildCodeFrameError("Unable to resolve marko file for load import.");
+			(file.path.node.extra.loadImports ??= /* @__PURE__ */ new Set()).add(loadFile.opts.filename);
 			if (loadFile.ast.program.extra?.featureType === "class") throw importDecl.buildCodeFrameError(`The [\`load\` import attribute](https://markojs.com/docs/reference/lazy-loading) is not supported for the Marko 5 (class API) tag \`${value}\`. Import it without \`load\`, or migrate the tag to the tags API.`);
 		}
 	},
@@ -10173,7 +10247,7 @@ var scriptlet_default = {
 			return;
 		}
 		mergeReferences(getOrCreateSection(scriptlet), scriptlet.node, scriptlet.node.body);
-		if (scriptlet.node.target === "client") (0, _marko_compiler_babel_utils.getProgram)().node.extra.isInteractive = true;
+		if (scriptlet.node.target === "client") (0, _marko_compiler_babel_utils.getProgram)().node.extra.hasClientStatement = true;
 	},
 	translate: { exit(scriptlet) {
 		const { node } = scriptlet;
@@ -10335,10 +10409,18 @@ function getTagRelativePath(tag) {
 	if (!relativePath) throw tagNotFoundError(tag);
 	return relativePath;
 }
+const staticHint = "To declare module level JavaScript, prefix the statement with `static`.";
 const knownWrongTags = /* @__PURE__ */ new Map([
 	["slot", "To render content passed to this tag, use a [dynamic tag](https://markojs.com/docs/reference/language#dynamic-tags): `<${input.content}/>`."],
 	["state", "Reactive state is declared with the [`<let>` tag](https://markojs.com/docs/reference/core-tag#let): `<let/name=initialValue>`."],
-	["fragment", "Marko templates and tag bodies may have multiple root nodes; no fragment wrapper is needed."]
+	["fragment", "Marko templates and tag bodies may have multiple root nodes; no fragment wrapper is needed."],
+	["async", staticHint],
+	["class", staticHint],
+	["declare", staticHint],
+	["enum", staticHint],
+	["function", staticHint],
+	["interface", staticHint],
+	["type", staticHint]
 ]);
 function tagNotFoundError(tag) {
 	const tagName = getTagName(tag);
@@ -10352,7 +10434,7 @@ function tagNotFoundError(tag) {
 		const closestTag = (0, fastest_levenshtein.closest)(tagName, Object.keys((0, _marko_compiler_babel_utils.getTaglibLookup)(tag.hub.file).merged.tags));
 		if ((0, fastest_levenshtein.distance)(tagName, closestTag) < 4) didYouMean = ` Did you mean \`<${closestTag}>\`?`;
 	}
-	return tag.get("name").buildCodeFrameError(`Unable to find entry point for [custom tag](https://markojs.com/docs/reference/custom-tag#relative-custom-tags) \`<${tagName}>\`.${didYouMean}`);
+	return tag.get("name").buildCodeFrameError(`Unable to find entry point for [custom tag](https://markojs.com/docs/reference/custom-tag#relative-custom-tags) \`<${tagName ?? getStaticTagName(tag.node)}>\`.${didYouMean}`);
 }
 const wordReg = /^[A-Za-z]+$/;
 function getProseText(tag) {
@@ -10720,7 +10802,7 @@ var text_default = {
 function buildAggregateError(file, rootMsg, ...paths) {
 	const err = /* @__PURE__ */ new SyntaxError();
 	const fileName = path.default.relative(_marko_compiler_modules.cwd, file.opts.filename);
-	const finalMsg = `${rootMsg}:\n\n${paths.map(([msg, path$14]) => `\x1b[90m${msg} at ${getFileNameWithLoc(fileName, path$14)}:\x1b[0m\n${getFrame(file, path$14)}`).join("\n\n")}`;
+	const finalMsg = `${rootMsg}:\n\n${paths.map(([msg, path$13]) => `\x1b[90m${msg} at ${getFileNameWithLoc(fileName, path$13)}:\x1b[0m\n${getFrame(file, path$13)}`).join("\n\n")}`;
 	if (!("MARKO_DEBUG" in process.env)) err.stack = finalMsg;
 	Object.defineProperty(err, "message", {
 		get() {
@@ -10884,24 +10966,30 @@ function createInteropTranslator(translate5) {
 						})));
 					};
 					return [
-						importHydrateProgram("6", entry_builder_default.build(entryFile, true)),
+						...state.needsCompat ? [_marko_compiler.types.importDeclaration([], _marko_compiler.types.stringLiteral(getCompatRuntimeFile()))] : [],
+						...Array.from(state.compatFiles, (compatFile) => _marko_compiler.types.importDeclaration([], _marko_compiler.types.stringLiteral(compatFile))),
+						importHydrateProgram("6", builder.build(entryFile, true)),
 						importHydrateProgram("5", translate5.internalEntryBuilder.build(entryFile, true)),
 						_marko_compiler.types.expressionStatement(_marko_compiler.types.callExpression(_marko_compiler.types.identifier("init6"), [])),
 						_marko_compiler.types.expressionStatement(_marko_compiler.types.callExpression(_marko_compiler.types.identifier("init5"), []))
 					];
 				} else return translate5.internalEntryBuilder.build(entryFile);
-				else return entry_builder_default.build(entryFile);
+				else return builder.build(entryFile);
 			},
 			visit(file, entryFile, visitChild) {
 				const state = entryFile[kState] ||= {
 					has5: false,
-					has6: false
+					has6: false,
+					needsCompat: false,
+					compatFiles: /* @__PURE__ */ new Set()
 				};
 				if (isTagsAPI(file)) {
 					state.has6 = true;
-					entry_builder_default.visit(file, entryFile, visitChild);
+					builder.visit(file, entryFile, visitChild);
 				} else {
 					state.has5 = true;
+					if (file.path.node.extra?.resumesCompat) state.needsCompat = true;
+					if (file.path.node.extra?.resumesClassFns) state.compatFiles.add((0, _marko_compiler_babel_utils.resolveRelativePath)(entryFile, file.opts.filename));
 					translate5.internalEntryBuilder.visit(file, entryFile, visitChild);
 				}
 			}
@@ -10914,13 +11002,13 @@ function createInteropTranslator(translate5) {
 					const entryFile = program.hub.file;
 					const { output, entry } = entryFile.markoOpts;
 					if (!(output === "dom" && entry === "page" || output === "hydrate")) return enterProgram?.call(this, program, state);
-					const visitedFiles = /* @__PURE__ */ new Set([(0, _marko_compiler_babel_utils.resolveRelativePath)(entryFile, entryFile.opts.filename)]);
-					entryBuilder.visit(entryFile, entryFile, function visitChild(resolved) {
-						if (!visitedFiles.has(resolved)) {
-							visitedFiles.add(resolved);
-							const file = (0, _marko_compiler_babel_utils.loadFileForImport)(entryFile, resolved);
-							if (file) entryBuilder.visit(file, entryFile, (id) => visitChild(resolveRelativeToEntry(entryFile, file, id)));
-						}
+					const visitedFiles = /* @__PURE__ */ new Map([[(0, _marko_compiler_babel_utils.resolveRelativePath)(entryFile, entryFile.opts.filename), false]]);
+					entryBuilder.visit(entryFile, entryFile, function visitChild(resolved, bundled = false) {
+						const seenBundled = visitedFiles.get(resolved);
+						if (seenBundled === false || seenBundled && bundled) return;
+						visitedFiles.set(resolved, bundled);
+						const file = (0, _marko_compiler_babel_utils.loadFileForImport)(entryFile, resolved);
+						if (file) entryBuilder.visit(file, entryFile, (id, childBundled = false) => visitChild(resolveRelativeToEntry(entryFile, file, id), childBundled || bundled));
 					});
 					program.node.body = entryBuilder.build(entryFile);
 					program.skip();
@@ -10936,13 +11024,13 @@ function mergeVisitors(visitor5, visitor6) {
 function mergeVisit(visit5, visit6) {
 	const enter5 = getVisitorEnter(visit5);
 	const enter6 = getVisitorEnter(visit6);
-	const enter = (enter5 || enter6) && function enter(path$10, state) {
-		return (isTagsAPI() ? enter6 : enter5)?.call(this, path$10, state);
+	const enter = (enter5 || enter6) && function enter(path$9, state) {
+		return (isTagsAPI() ? enter6 : enter5)?.call(this, path$9, state);
 	};
 	const exit5 = getVisitorExit(visit5);
 	const exit6 = getVisitorExit(visit6);
-	const exit = (exit5 || exit6) && function exit(path$11, state) {
-		return (isTagsAPI() ? exit6 : exit5)?.call(this, path$11, state);
+	const exit = (exit5 || exit6) && function exit(path$10, state) {
+		return (isTagsAPI() ? exit6 : exit5)?.call(this, path$10, state);
 	};
 	return exit ? enter ? {
 		enter,
@@ -11025,17 +11113,17 @@ function sequenceVisit(first, second) {
 	if (!first || !second) return first || second;
 	const enterFirst = getVisitorEnter(first);
 	const enterSecond = getVisitorEnter(second);
-	const enter = (enterFirst || enterSecond) && function enter(path$12, state) {
-		const { node } = path$12;
-		enterFirst?.call(this, path$12, state);
-		if (path$12.node === node) enterSecond?.call(this, path$12, state);
+	const enter = (enterFirst || enterSecond) && function enter(path$11, state) {
+		const { node } = path$11;
+		enterFirst?.call(this, path$11, state);
+		if (path$11.node === node) enterSecond?.call(this, path$11, state);
 	};
 	const exitFirst = getVisitorExit(first);
 	const exitSecond = getVisitorExit(second);
-	const exit = (exitFirst || exitSecond) && function exit(path$13, state) {
-		const { node } = path$13;
-		exitFirst?.call(this, path$13, state);
-		if (path$13.node === node) exitSecond?.call(this, path$13, state);
+	const exit = (exitFirst || exitSecond) && function exit(path$12, state) {
+		const { node } = path$12;
+		exitFirst?.call(this, path$12, state);
+		if (path$12.node === node) exitSecond?.call(this, path$12, state);
 	};
 	return exit ? enter ? {
 		enter,
@@ -11083,7 +11171,7 @@ exports.analyze = analyze;
 exports.cheatsheet = cheatsheet;
 exports.createInteropTranslator = createInteropTranslator;
 exports.getRuntimeEntryFiles = getRuntimeEntryFiles;
-exports.internalEntryBuilder = entry_builder_default;
+exports.internalEntryBuilder = builder;
 exports.preferAPI = preferAPI;
 exports.tagDiscoveryDirs = tagDiscoveryDirs;
 exports.taglibs = taglibs;

package/dist/translator/interop/index.d.ts

@@ -1,4 +1,12 @@
 import { type Config, types as t } from "@marko/compiler";
+declare module "@marko/compiler/dist/types" {
+    interface ProgramExtra {
+        /** A Class API template that registers hoisted handlers for Tags resume. */
+        resumesClassFns?: boolean;
+        /** A Class API template whose Tags child revives through the compat runtime. */
+        resumesCompat?: boolean;
+    }
+}
 type Taglibs = [taglibId: string, taglib: Record<string, unknown>][];
 export declare function createInteropTranslator(translate5: any): {
     version: any;

package/dist/translator/util/entry-builder.d.ts

@@ -3,19 +3,33 @@ declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
         needsCompat?: boolean;
         isInteractive?: boolean;
+        hasClientStatement?: boolean;
         page?: boolean;
     }
 }
 interface EntryState {
     init: boolean;
+    load: boolean;
+    /** Depth of enclosing templates whose modules the bundle already loads:
+     * below a root everything arrives through its imports, and a lazy subtree
+     * is loaded by its own load entry. */
+    bundled: number;
+    roots: string[];
+    /** Assets of templates the bundle never loads; the entry imports them. */
     assets: Set<string>;
+    /** Assets that arrive through a bundled template's imports; the entry
+     * imports them itself only when it links nothing (a server only page). */
+    bundledAssets: Set<string>;
+    /** Whether each reached file was only ever seen below a bundled template. */
+    visited: Map<string, boolean>;
 }
 type EntryFile = t.BabelFile & {
     [kState]?: EntryState;
 };
+type VisitChild = (id: string, bundled?: boolean) => void;
 declare const kState: unique symbol;
-declare const _default: {
+declare const builder: {
     build(entryFile: EntryFile, exportInit?: boolean): t.Statement[];
-    visit(file: t.BabelFile, entryFile: EntryFile, visitChild: (id: string) => void): void;
+    visit(file: t.BabelFile, entryFile: EntryFile, visitChild?: VisitChild): void;
 };
-export default _default;
+export default builder;

package/dist/translator/util/known-tag.d.ts

@@ -1,11 +1,7 @@
 import { types as t } from "@marko/compiler";
 import { type BindingPropTree } from "./binding-prop-tree";
-import { type Binding } from "./references";
+import { type Binding, type KnownExprs } from "./references";
 import { type Section } from "./sections";
-interface KnownExprs {
-    known?: Record<string, KnownExprs>;
-    value?: t.NodeExtra;
-}
 declare const kContentSection: unique symbol;
 declare const kChildScopeBinding: unique symbol;
 declare const kChildOffsetScopeBinding: unique symbol;

package/dist/translator/util/references.d.ts

@@ -90,6 +90,9 @@ declare module "@marko/compiler/dist/types" {
         section?: Section;
         referencedBindings?: ReferencedBindings;
         downstream?: Opt<Binding>;
+        /** The tag-root `KnownExprs` of the call site that linked this expression
+         * to a downstream template's binding, for dereferencing its reasons. */
+        downstreamExprs?: KnownExprs;
         binding?: Binding;
         assignment?: Binding;
         assignmentTo?: Binding;
@@ -141,7 +144,7 @@ export declare const intersectionMeta: WeakMap<Intersection, {
     scopeOffset: Binding | undefined;
 }>;
 export declare const collapsedIntersectionSource: WeakMap<Intersection, Binding>;
-export declare function setBindingDownstream(binding: Binding, expr: boolean | Opt<t.NodeExtra>): void;
+export declare function setBindingDownstream(binding: Binding, expr: boolean | Opt<t.NodeExtra>, exprs?: KnownExprs): void;
 export declare function createSources(state: Sources["state"], param: Sources["param"], global?: Sources["global"]): Sources;
 export declare function compareSources(a: Sources, b: Sources): number;
 export declare function mergeSources(a: undefined | Sources, b: undefined | Sources): Sources | undefined;
@@ -191,3 +194,9 @@ export declare function isRegisteredFnExtra(extra: t.NodeExtra | undefined): ext
 export declare function getCanonicalExtra<T extends t.NodeExtra>(extra: T): T;
 export declare function getAllSerializeReasonsForExtra(extra: t.NodeExtra): undefined | SerializeReason;
 export declare function getAllSerializeReasonsForBinding(binding: Binding, properties?: Opt<string> | true): undefined | SerializeReason;
+export interface KnownExprs {
+    known?: Record<string, KnownExprs>;
+    value?: t.NodeExtra;
+}
+export declare function mapParamReasonToExpr(exprs: KnownExprs, reason: boolean | Opt<InputBinding | ParamBinding>): true | Many<t.NodeExtra> | t.NodeExtra | undefined;
+export declare function mapParamBindingToExpr(exprs: KnownExprs, binding: InputBinding | ParamBinding): Opt<t.NodeExtra>;

package/dist/translator/util/sections.d.ts

@@ -5,7 +5,7 @@ import * as ContentType from "./constants/content-type";
 import type * as Step from "./constants/step";
 import * as StructureKind from "./constants/structure-kind";
 import { type Opt, Sorted } from "./optional";
-import { type Binding, type InputBinding, type ParamBinding, type ReferencedBindings, type Sources } from "./references";
+import { type Binding, type InputBinding, type KnownExprs, type ParamBinding, type ReferencedBindings, type Sources } from "./references";
 import { type SerializeReason } from "./serialize-reasons";
 export interface ParamSerializeReasonGroup {
     id: symbol;
@@ -50,6 +50,7 @@ export interface Section {
     loc: t.SourceLocation | undefined;
     depth: number;
     parent: Section | undefined;
+    program: Section;
     sectionAccessor: {
         binding: Binding;
         prefix: AccessorPrefix;
@@ -71,6 +72,7 @@ export interface Section {
     downstreamBinding: {
         binding: Binding;
         properties: Opt<string>;
+        exprs: KnownExprs | undefined;
     } | false | undefined;
     hasAbortSignal: boolean;
     /** Count of distinct `$signal` expression roots; analyze allocates each

package/dist/translator/util/serialize-reasons.d.ts

@@ -1,7 +1,7 @@
 import { types as t } from "@marko/compiler";
 import { AccessorPrefix, AccessorProp } from "../../common/types";
 import { type Opt } from "./optional";
-import { type Binding, type ReferencedBindings, type Sources } from "./references";
+import { type Binding, type KnownExprs, type ReferencedBindings, type Sources } from "./references";
 import type { Section } from "./sections";
 export type SerializeReasons = true | [Sources, ...Sources[]];
 export type SerializeReason = true | Sources;
@@ -19,6 +19,8 @@ export declare function getSerializeReason(section: Section, prop?: Binding | Ac
 export declare function getSerializeSourcesForExpr(expr: t.NodeExtra): Sources | undefined;
 export declare function getSerializeSourcesForExprs(exprs: Opt<t.NodeExtra> | boolean): true | Sources | undefined;
 export declare function getSerializeSourcesForRef(ref: ReferencedBindings): Sources | undefined;
+export declare function mapCrossProgramReason(program: Section, reason: Sources, exprs: KnownExprs | undefined): SerializeReason | undefined;
+export declare function mapDownstreamReason(program: Section, reason: Sources, exprs: KnownExprs): SerializeReason | undefined;
 export declare function mergeSerializeReasons(a: SerializeReason, b: undefined | SerializeReason): SerializeReason;
 export declare function mergeSerializeReasons(a: undefined | SerializeReason, b: SerializeReason): SerializeReason;
 export declare function mergeSerializeReasons(a: undefined | SerializeReason, b: undefined | SerializeReason): SerializeReason | undefined;

package/dist/translator/util/set-tag-sections-downstream.d.ts

@@ -1,5 +1,5 @@
 import { types as t } from "@marko/compiler";
-import type { Binding } from "./references";
+import type { Binding, KnownExprs } from "./references";
 import { type Section } from "./sections";
-export declare function setTagDownstream(tag: t.NodePath<t.MarkoTag>, binding: undefined | Binding): void;
+export declare function setTagDownstream(tag: t.NodePath<t.MarkoTag>, binding: undefined | Binding, exprs?: KnownExprs): void;
 export declare function finalizeTagDownstreams(section: Section): void;

package/dist/translator/util/tag-name-type.d.ts

@@ -4,6 +4,8 @@ import * as TagNameType from "./constants/tag-name-type";
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
         featureType?: "class" | "tags";
+        /** Set by the Class API translator when Tags content resumes below here. */
+        hydratesTags?: boolean;
     }
     interface MarkoTagExtra {
         tagNameType?: TagNameType;

package/dist/translator/visitors/import-declaration.d.ts

@@ -2,6 +2,10 @@ import { types as t } from "@marko/compiler";
 import type { LoadTrigger } from "../../html/assets";
 import { type ResolvedExport } from "./function";
 declare module "@marko/compiler/dist/types" {
+    interface ProgramExtra {
+        /** Absolute filenames of templates this one imports with `load`. */
+        loadImports?: Set<string>;
+    }
     interface NodeExtra {
         tagImport?: string;
         loadImport?: LoadImportConfig;

package/dist/translator/visitors/program/index.d.ts

@@ -5,6 +5,7 @@ export declare let scopeIdentifier: t.Identifier;
 export declare let localsIdentifier: t.Identifier;
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
+        hasResumes?: boolean;
         domExports?: {
             template: string;
             walks: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.3.44",
+  "version": "6.3.45",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -51,14 +51,14 @@
     }
   },
   "dependencies": {
-    "@marko/compiler": "^5.42.2",
+    "@marko/compiler": "^5.42.3",
     "csstype": "^3.2.3",
     "fastest-levenshtein": "^1.0.16",
     "magic-string": "^0.30.21"
   },
   "devDependencies": {
-    "@marko/runtime-tags": "npm:marko@6.3.44",
-    "marko": "5.39.36"
+    "marko": "5.39.37",
+    "@marko/runtime-tags": "npm:marko@6.3.45"
   },
   "engines": {
     "node": ">=22"