marko 6.4.2 → 6.4.4

package/dist/translator/index.js

@@ -156,6 +156,7 @@ var accessor_prop_debug_exports = /* @__PURE__ */ __exportAll({
 	AbortScopes: () => AbortScopes$1,
 	AwaitCounter: () => AwaitCounter$1,
 	BranchAccessor: () => BranchAccessor$1,
+	BranchRenders: () => BranchRenders$1,
 	BranchScopes: () => BranchScopes$2,
 	CatchContent: () => CatchContent$1,
 	ClosestBranch: () => ClosestBranch$1,
@@ -189,6 +190,7 @@ const AbortControllers$1 = "#AbortControllers";
 const AbortScopes$1 = "#AbortScopes";
 const AwaitCounter$1 = "#AwaitCounter";
 const BranchAccessor$1 = "#BranchAccessor";
+const BranchRenders$1 = "#BranchRenders";
 const BranchScopes$2 = "#BranchScopes";
 const CatchContent$1 = "#CatchContent";
 const ClosestBranch$1 = "#ClosestBranch";
@@ -953,7 +955,7 @@ function createSectionState(key, init) {
 //#region src/translator/visitors/function.ts
 const kRegisteredExports = Symbol("registered exports");
 const [getReferencesByFn] = createProgramState(() => /* @__PURE__ */ new Map());
-const [getReferencesByImportedFn] = createProgramState(() => /* @__PURE__ */ new Map());
+const [getReferencesByImport] = createProgramState(() => /* @__PURE__ */ new Map());
 var function_default = { analyze(fn) {
 	const awaitNode = isMarkoAttribute(fn.parentPath) && _marko_compiler.types.isFunctionExpression(fn.node) && !fn.node.async && traverseFindAwait(fn.node.body);
 	if (awaitNode) {
@@ -987,24 +989,45 @@ function resolveFunctionReason() {
 }
 function finalizeFunctionRegistry() {
 	for (const fnExtra of getReferencesByFn().keys()) if (fnExtra.reason) registerFunction(fnExtra);
-	for (const [importedFn, exprExtras] of getReferencesByImportedFn()) if (resolveReason(exprExtras)) registerImportedFn(importedFn);
+	for (const [{ node, local, registered, fnRoots }, exprExtras] of getReferencesByImport()) {
+		const reason = fnRoots ? resolveTemplateReason(exprExtras) : resolveReason(exprExtras);
+		if (reason) {
+			if (!fnRoots || !isTemplateShipped(fnRoots, exprExtras)) {
+				const extra = node.extra ??= {};
+				extra.registeredImports ??= /* @__PURE__ */ new Map();
+				extra.registeredImports.set(local, registered);
+			}
+			markRegistrationInteractive(reason);
+		}
+	}
 }
 /**
-* Tracks a function imported from another template that reserved a register id.
-* The importing template registers it (under the reserved id) when client
+* Tracks a template imported as a default export. The server writes a template
+* only as a binding's value, so the importing template registers it when one may.
+*/
+function trackImportedTemplate(importDecl, local, templateFile) {
+	trackImport(importDecl, local, {
+		registerId: templateFile.metadata.marko.id,
+		exportName: "default",
+		filename: templateFile.opts.filename
+	}, /* @__PURE__ */ new Set());
+}
+/**
+* Tracks an export imported from another template that registers under an id,
+* if it does. The importing template registers it (under that id) when client
 * code reads its own references.
 */
-function trackImportedFn(importDecl, local, resolved) {
-	const binding = importDecl.scope.getBinding(local);
+function trackImport(importDecl, local, registered, fnRoots) {
+	const binding = registered && importDecl.scope.getBinding(local);
 	if (!binding) return;
-	const importedFn = {
-		...resolved,
-		node: importDecl.node,
-		local
-	};
 	const refs = /* @__PURE__ */ new Set();
-	addBindingRefs(binding, refs, /* @__PURE__ */ new Set());
-	if (refs.size) getReferencesByImportedFn().set(importedFn, refs);
+	addBindingRefs(binding, refs, /* @__PURE__ */ new Set(), fnRoots);
+	if (refs.size) getReferencesByImport().set({
+		node: importDecl.node,
+		local,
+		registered,
+		fnRoots
+	}, refs);
 }
 /**
 * Finds the id reserved for an export, following `export ... from` hops. Each
@@ -1013,15 +1036,11 @@ function trackImportedFn(importDecl, local, resolved) {
 * hand out an incomplete map if the ids were pushed ahead of time.
 */
 function resolveRegisteredExport(file, exportName, seen = /* @__PURE__ */ new Set()) {
-	const filename = file.opts.filename;
-	const key = `${filename}\0${exportName}`;
+	const key = `${file.opts.filename}\0${exportName}`;
 	if (seen.has(key)) return;
 	seen.add(key);
-	const reserved = file.ast.program.extra?.[kRegisteredExports]?.get(exportName);
-	if (reserved) return {
-		...reserved,
-		filename
-	};
+	const registered = file.ast.program.extra?.[kRegisteredExports]?.get(exportName);
+	if (registered) return registered;
 	for (const child of file.ast.program.body) {
 		if (child.type !== "ExportNamedDeclaration" && child.type !== "ExportAllDeclaration" || !child.source || (child.exportKind || "value") !== "value") continue;
 		const sourceFile = (0, _marko_compiler_babel_utils.loadFileForImport)(file, child.source.value);
@@ -1046,11 +1065,21 @@ function resolveReason(exprExtras) {
 	}
 	return reason;
 }
-function registerImportedFn({ node, ...importedFn }) {
-	const extra = node.extra ??= {};
-	extra.registeredImportedFns ??= [];
-	extra.registeredImportedFns.push(importedFn);
-	(0, _marko_compiler_babel_utils.getProgram)().node.extra.isInteractive = true;
+function resolveTemplateReason(exprExtras) {
+	let reason;
+	for (const exprExtra of exprExtras) {
+		const extra = getCanonicalExtra(exprExtra);
+		if (!extra.isEffect) reason = mergeReasons(reason, getReasonForExpr(extra));
+	}
+	return reason;
+}
+function isTemplateShipped(fnRoots, exprExtras) {
+	for (const fnRoot of fnRoots) if (isRegisteredFnExtra(fnRoot)) return true;
+	for (const exprExtra of exprExtras) if (getCanonicalExtra(exprExtra).isEffect) return true;
+	return false;
+}
+function markRegistrationInteractive(reason) {
+	(0, _marko_compiler_babel_utils.getProgram)().node.extra.isInteractive ||= isUnconditionalReason(reason);
 }
 function reserveExportRegisterId(fnExtra, fn, markoRoot) {
 	if (!isStatic(markoRoot)) return;
@@ -1060,12 +1089,14 @@ function reserveExportRegisterId(fnExtra, fn, markoRoot) {
 	const { markoOpts, opts: { filename } } = (0, _marko_compiler_babel_utils.getFile)();
 	const programExtra = (0, _marko_compiler_babel_utils.getProgram)().node.extra;
 	const registerId = (0, _marko_compiler_babel_utils.getTemplateId)(markoOpts, filename, `${fnExtra.section.id}/export/${exportName}`);
+	const registered = {
+		registerId,
+		exportName,
+		filename
+	};
 	fnExtra.exportRegisterId = registerId;
 	programExtra[kRegisteredExports] ??= /* @__PURE__ */ new Map();
-	for (const name of exportNames) programExtra[kRegisteredExports].set(name, {
-		registerId,
-		exportName
-	});
+	for (const name of exportNames) programExtra[kRegisteredExports].set(name, registered);
 }
 function getExportNames(fn, markoRoot) {
 	const localName = getExportableName(fn);
@@ -1093,31 +1124,35 @@ function getExportedName(specifier) {
 function canIgnoreRegister(markoRoot, exprRoot) {
 	return markoRoot.isMarkoPlaceholder() || markoRoot.isMarkoScriptlet() && (!markoRoot.node.static || markoRoot.node.target === "server") || markoRoot.isMarkoTag() && markoRoot.node.name == exprRoot.node;
 }
-function getStaticDeclRefs(path, refs = /* @__PURE__ */ new Set(), seen = /* @__PURE__ */ new Set()) {
+function getStaticDeclRefs(path, refs = /* @__PURE__ */ new Set(), seen = /* @__PURE__ */ new Set(), fnRoots) {
 	const decl = getDeclarationRoot(path);
 	if (decl && !seen.has(decl.node)) {
 		seen.add(decl.node);
 		const ids = decl.getOuterBindingIdentifiers();
 		if (ids) for (const name in ids) {
 			const binding = decl.scope.getBinding(name);
-			if (binding) addBindingRefs(binding, refs, seen);
+			if (binding) addBindingRefs(binding, refs, seen, fnRoots);
 		}
 	}
 	return refs;
 }
-function addBindingRefs(binding, refs, seen) {
+function addBindingRefs(binding, refs, seen, fnRoots) {
 	for (const ref of binding.referencePaths) {
 		if (isInvokedFunction(ref) || ref.parentPath.type === "Program") continue;
 		const exprRoot = getExprRoot(ref);
 		const markoRoot = getMarkoRoot(exprRoot);
 		if (!markoRoot || canIgnoreRegister(markoRoot, exprRoot)) continue;
-		if (isStatic(markoRoot)) getStaticDeclRefs(ref, refs, seen);
+		if (fnRoots) {
+			const fnRoot = getFnRoot(ref);
+			if (fnRoot) fnRoots.add(fnRoot.node.extra ??= {});
+		}
+		if (isStatic(markoRoot)) getStaticDeclRefs(ref, refs, seen, fnRoots);
 		else refs.add(exprRoot.node.extra ??= {});
 	}
 }
 function registerFunction(fnExtra) {
-	const { markoOpts, path: program, opts: { filename } } = (0, _marko_compiler_babel_utils.getFile)();
-	program.node.extra.isInteractive = true;
+	const { markoOpts, opts: { filename } } = (0, _marko_compiler_babel_utils.getFile)();
+	markRegistrationInteractive(fnExtra.reason);
 	fnExtra.name = generateUid(fnExtra.name);
 	fnExtra.registerId = fnExtra.exportRegisterId ?? (0, _marko_compiler_babel_utils.getTemplateId)(markoOpts, filename, `${fnExtra.section.id}/${fnExtra.name.slice(1)}`);
 }
@@ -1591,7 +1626,7 @@ function _escape(val) {
 	return val ? escapeXMLStr(val + "") : val === 0 ? "0" : "";
 }
 const unsafeScriptReg = /<(\/?script|!--)/gi;
-const escapeScriptStr = (str) => unsafeScriptReg.test(str) ? str.replace(unsafeScriptReg, "\\x3C$1") : str;
+const escapeScriptStr = (str) => unsafeScriptReg.test(str) ? str.replace(unsafeScriptReg, "\\u003C$1") : str;
 function _escape_script(val) {
 	return val ? escapeScriptStr(val + "") : val === 0 ? "0" : "";
 }
@@ -1660,6 +1695,7 @@ const pureDOMFunctions = /* @__PURE__ */ new Set([
 	"_dynamic_tag_content",
 	"_content_closures",
 	"_template",
+	"_return_setup",
 	"_closure",
 	"_closure_get",
 	"_or",
@@ -1887,19 +1923,20 @@ function escapeRegExp(str) {
 /**
 * Writes the registrations for module scoped functions: the ones this template
 * exports and registers itself, and the ones it imports from a template that
-* reserved a register id without registering it.
+* reserved a register id without registering it; and for templates it imports.
 */
 function writeModuleRegistrations(program) {
 	const file = (0, _marko_compiler_babel_utils.getFile)();
 	const statements = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const child of program.node.body) {
-		const registeredImportedFns = _marko_compiler.types.isImportDeclaration(child) && child.extra?.registeredImportedFns;
-		if (registeredImportedFns) for (const importedFn of registeredImportedFns) {
-			if (seen.has(importedFn.registerId)) continue;
-			seen.add(importedFn.registerId);
-			if (isOutputHTML()) statements.push(buildRegistration(importedFn.local, importedFn.registerId));
-			else (0, _marko_compiler_babel_utils.importDefault)(file, resolveRegisterModule(file, importedFn));
+		const registeredImports = _marko_compiler.types.isImportDeclaration(child) && child.extra?.registeredImports;
+		if (registeredImports) for (const [local, registered] of registeredImports) {
+			if (seen.has(registered.registerId)) continue;
+			seen.add(registered.registerId);
+			if (isOutputHTML()) {
+				if (registered.exportName !== "default") statements.push(buildRegistration(local, registered.registerId));
+			} else (0, _marko_compiler_babel_utils.importDefault)(file, resolveRegisterModule(file, registered));
 		}
 		else if (child.type === "ExportNamedDeclaration") addExportRegistrations(child, seen, statements);
 	}
@@ -1930,7 +1967,7 @@ function resolveRegisterModule(file, { filename, exportName, registerId }) {
 	const importer = file.opts.filename;
 	return getMarkoOpts().resolveVirtualDependency(importer, {
 		virtualPath: `${relativePath(importer, filename)}.register-${exportName}.js`,
-		code: `import { ${exportName} } from "./${path.default.basename(filename)}";\nimport { _resumed } from "${getRuntimePath("dom")}";\n_resumed${isValidPropertyIdentifier(registerId) ? `.${registerId}` : `[${JSON.stringify(registerId)}]`} = ${exportName};\n`
+		code: `import { ${exportName} as value } from "./${path.default.basename(filename)}";\nimport { _resumed } from "${getRuntimePath("dom")}";\n_resumed${isValidPropertyIdentifier(registerId) ? `.${registerId}` : `[${JSON.stringify(registerId)}]`} = value;\n`
 	});
 }
 function relativePath(from, to) {
@@ -1965,6 +2002,7 @@ var accessor_prop_exports = /* @__PURE__ */ __exportAll({
 	AbortScopes: () => "B",
 	AwaitCounter: () => "O",
 	BranchAccessor: () => "C",
+	BranchRenders: () => "BR",
 	BranchScopes: () => "D",
 	CatchContent: () => "E",
 	ClosestBranch: () => "F",
@@ -2153,7 +2191,7 @@ var import_declaration_default = {
 		if (tagImport) {
 			const tags = (0, _marko_compiler_babel_utils.getFile)().metadata.marko.tags;
 			if (!tags.includes(tagImport)) tags.push(tagImport);
-			trackImportedRegisteredFns(importDecl);
+			trackRegisteredImports(importDecl);
 		}
 		const loadAttrPath = getLoadAttr(importDecl);
 		if (loadAttrPath) {
@@ -2194,7 +2232,9 @@ var import_declaration_default = {
 				} else if (binding.referencePaths.every((ref) => _marko_compiler.types.isMarkoTag(ref.parent) && ref.parent.extra?.tagNameLoad)) importDecl.remove();
 				else {
 					importRuntimeFeature("catch");
-					importDecl.replaceWith(_marko_compiler.types.variableDeclaration("const", [_marko_compiler.types.variableDeclarator(local, callRuntime("_load_template", _marko_compiler.types.stringLiteral(loadFile.metadata.marko.id), _marko_compiler.types.arrowFunctionExpression([], dynamicImport((0, _marko_compiler_babel_utils.resolveRelativePath)(file, loadFile.opts.filename), _marko_compiler.types.arrowFunctionExpression([_marko_compiler.types.identifier("mod")], toMemberExpression(_marko_compiler.types.identifier("mod"), "default"))))))]));
+					const load = _marko_compiler.types.arrowFunctionExpression([], dynamicImport((0, _marko_compiler_babel_utils.resolveRelativePath)(file, loadFile.opts.filename), _marko_compiler.types.arrowFunctionExpression([_marko_compiler.types.identifier("mod")], toMemberExpression(_marko_compiler.types.identifier("mod"), "default"))));
+					const args = [_marko_compiler.types.stringLiteral(loadFile.metadata.marko.id), load];
+					importDecl.replaceWith(_marko_compiler.types.variableDeclaration("const", [_marko_compiler.types.variableDeclarator(local, extra.registeredImports?.has(local.name) ? _marko_compiler.types.callExpression(importRuntime("_load_template"), args) : callRuntime("_load_template", ...args))]));
 				}
 				return;
 			}
@@ -2226,17 +2266,19 @@ function getOrCreateHtmlLoadWrapped(readyId, originalIdentifier, filename, trigg
 	(0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.markoScriptlet([_marko_compiler.types.variableDeclaration("const", [_marko_compiler.types.variableDeclarator(_marko_compiler.types.identifier(wrappedName), callRuntime("withLoadAssets", originalIdentifier, (0, _marko_compiler_babel_utils.importNamed)((0, _marko_compiler_babel_utils.getFile)(), markoOpts.linkAssets.runtime, "flush"), _marko_compiler.types.stringLiteral(readyId), triggers ? _marko_compiler.types.valueToNode(triggers) : void 0))])], true));
 	return wrappedName;
 }
-function trackImportedRegisteredFns(importDecl) {
+function trackRegisteredImports(importDecl) {
 	const { node } = importDecl;
 	const childFile = (0, _marko_compiler_babel_utils.loadFileForImport)((0, _marko_compiler_babel_utils.getFile)(), node.source.value);
 	if (!childFile) return;
 	for (const specifier of importDecl.get("specifiers")) {
-		if (!specifier.isImportSpecifier()) continue;
-		const { imported } = specifier.node;
-		const importedName = imported.type === "Identifier" ? imported.name : imported.value;
-		if (importedName === "default") continue;
-		const resolved = resolveRegisteredExport(childFile, importedName);
-		if (resolved) trackImportedFn(importDecl, specifier.node.local.name, resolved);
+		let importedName = "default";
+		if (specifier.isImportSpecifier()) {
+			const { imported } = specifier.node;
+			importedName = imported.type === "Identifier" ? imported.name : imported.value;
+		} else if (!specifier.isImportDefaultSpecifier()) continue;
+		const local = specifier.node.local.name;
+		if (importedName === "default") trackImportedTemplate(importDecl, local, childFile);
+		else trackImport(importDecl, local, resolveRegisteredExport(childFile, importedName));
 	}
 }
 function getLoadAttr(importDecl) {
@@ -4295,8 +4337,7 @@ var dom_default = { translate: {
 						let renderer = callRuntime("_content", _marko_compiler.types.stringLiteral(registerId), ...replaceNullishAndEmptyFunctionsWith0([
 							writes,
 							walks,
-							setupIdentifier,
-							tagParamsIdentifier,
+							...markReturn(childSection, setupIdentifier, tagParamsIdentifier),
 							childSection.hoisted || childSection.isHoistThrough ? getSectionInstancesAccessorLiteral(childSection) : void 0
 						]));
 						if (!registerReason || registerWrapper) renderer = _marko_compiler.types.addComment(renderer, "leading", "@__PURE__");
@@ -4319,8 +4360,7 @@ var dom_default = { translate: {
 		program.node.body.push(_marko_compiler.types.exportDefaultDeclaration(callRuntime("_template", _marko_compiler.types.stringLiteral((0, _marko_compiler_babel_utils.getFile)().metadata.marko.id), ...replaceNullishAndEmptyFunctionsWith0([
 			templateIdentifier,
 			walksIdentifier,
-			section.hasSetupWork ? setupIdentifier : void 0,
-			programInputSignal?.identifier
+			...markReturn(section, section.hasSetupWork ? setupIdentifier : void 0, programInputSignal?.identifier)
 		]))));
 	}
 } };
@@ -4328,6 +4368,9 @@ function assertSetupWorkFound(program, section, written) {
 	const setup = getSetup(section);
 	if (!section.hasSetupWork && setup && written.has(setup)) throw program.buildCodeFrameError("Marko internal error: analysis found no setup work for a section whose translation produced setup statements. Please open an issue with a reproduction.");
 }
+function markReturn(section, setup, params) {
+	return section.returnValueExpr && !isOptimize() ? setup ? [callRuntime("_return_setup", setup), params] : [setup, callRuntime("_return_setup", params)] : [setup, params];
+}
 //#endregion
 //#region src/translator/visitors/program/html.ts
 function getTemplateContentName() {
@@ -4335,11 +4378,11 @@ function getTemplateContentName() {
 }
 var html_default = { translate: {
 	enter() {
+		const sectionDynamicSubscribers = /* @__PURE__ */ new Set();
 		forEachSection((section) => {
 			forEach(section.bindings, (binding) => {
 				for (const [hoistSection, hasReference] of binding.getters) if (hasReference) getHTMLSectionStatements(hoistSection || section).push(_marko_compiler.types.variableDeclaration("const", [hoistSection ? _marko_compiler.types.variableDeclarator(getBindingGetterIdentifier(binding, hoistSection), callRuntime("_hoist", getScopeIdIdentifier(hoistSection), _marko_compiler.types.stringLiteral(getResumeRegisterId(hoistSection, binding, "hoist")))) : _marko_compiler.types.variableDeclarator(_marko_compiler.types.identifier(binding.originalName), callRuntime("_el", getScopeIdIdentifier(section), _marko_compiler.types.stringLiteral(getResumeRegisterId(section, binding))))]));
 			});
-			const sectionDynamicSubscribers = /* @__PURE__ */ new Set();
 			forEach(section.hoisted, (binding) => {
 				let highestHoistSection;
 				forEach(binding.hoists, (hoistSection) => {
@@ -4815,7 +4858,10 @@ var custom_tag_default = {
 		const childSection = childExtra.section;
 		if (childSection === programSection && getOrCreateSection(tag) === programSection) throw tag.get("name").buildCodeFrameError(`A template that renders itself outside a branch never terminates. Render \`<${getStaticTagName(tag.node)}>\` inside a branch that eventually stops, such as \`<if>\`.`);
 		if (childExtra.page) programExtra.page ??= true;
-		if (tagExtra.tagNameLoad) tagExtra[kLoadTagBinding] = createBinding("#text", 0, getOrCreateSection(tag));
+		if (tagExtra.tagNameLoad) {
+			if (tag.node.var) throw tag.get("var").buildCodeFrameError(`The \`${getStaticTagName(tag.node)}\` tag is lazily loaded, so it does not support a [tag variable](https://markojs.com/docs/reference/language#tag-variables). Remove the variable, or import the tag without \`load\`.`);
+			tagExtra[kLoadTagBinding] = createBinding("#text", 0, getOrCreateSection(tag));
+		}
 		knownTagAnalyze(tag, childSection, childExtra.paramsTree);
 		const tagName = getStaticTagName(tag.node);
 		if (tagExtra.tagNameLoad) {
@@ -5865,6 +5911,7 @@ function knownTagAnalyze(tag, contentSection, childParamsTree) {
 		else exprs = analyzeKnownTagParams(tag, getParamsTree(contentSection));
 	} else exprs = analyzeKnownTagParams(tag, childParamsTree);
 	if (varBinding) {
+		if (!recursive) assertReturns(tag, contentSection);
 		addSetupExpr(section);
 		const mutatesTagVar = !!(tag.node.var.type === "Identifier" && tag.scope.getBinding(tag.node.var.name)?.constantViolations.length);
 		const varExpr = recursive || (tagExtra.defineBodySection ? contentSection.returnValueExpr : mapParamReasonToExpr(exprs, getReturnParams(contentSection)));
@@ -5877,7 +5924,11 @@ function knownTagAnalyze(tag, contentSection, childParamsTree) {
 	}
 }
 function analyzeRecursiveTags() {
-	for (const tag of getRecursiveTags()) analyzeKnownTagParams(tag, getParamsTree(tag.node.extra[kContentSection]));
+	for (const tag of getRecursiveTags()) {
+		const contentSection = tag.node.extra[kContentSection];
+		if (tag.node.var) assertReturns(tag, contentSection);
+		analyzeKnownTagParams(tag, getParamsTree(contentSection));
+	}
 }
 function getParamsTree(contentSection) {
 	return contentSection.params && getBindingPropTree(contentSection.params, true);
@@ -5892,9 +5943,12 @@ function analyzeKnownTagParams(tag, propTree) {
 	return exprs;
 }
 function getReturnParams(section) {
-	const sources = section.returnValueExpr && getSourcesForExpr(section.returnValueExpr);
+	const sources = getSourcesForExpr(section.returnValueExpr);
 	return sources && (sources.always || !!sources.state || sources.param);
 }
+function assertReturns(tag, contentSection) {
+	if (!contentSection.returnValueExpr) throw tag.get("var").buildCodeFrameError(`The \`${getStaticTagName(tag.node)}\` tag does not [\`<return>\`](https://markojs.com/docs/reference/core-tag#return) a value, so it does not support a [tag variable](https://markojs.com/docs/reference/language#tag-variables). Remove the variable, or add a \`<return>\` to the tag.`);
+}
 function isChildScopeResumed(tagExtra) {
 	return !!findSlot(tagExtra.nodeBinding)?.reason;
 }
@@ -6689,16 +6743,20 @@ function getWalkedBinding(op) {
 	return typeof op === "object" && (op.kind === "node" || op.kind === "child") ? op.binding : void 0;
 }
 function getLastOwnSourceReturn(intersection, section) {
-	let returnedBy;
-	for (const binding of intersection) if (binding.section === section && binding.sources) {
-		returnedBy = reduce(binding.sources.state, lastReturnedBy, returnedBy);
-		returnedBy = reduce(binding.sources.param, lastReturnedBy, returnedBy);
-	}
-	return returnedBy;
-}
-function lastReturnedBy(last, source) {
-	const { returnedBy } = source;
-	return returnedBy && (!last || last.id < returnedBy.id) ? returnedBy : last;
+	let last;
+	const seen = /* @__PURE__ */ new Set();
+	const track = (binding) => {
+		if (binding.section === section && !seen.has(binding)) {
+			seen.add(binding);
+			const { returnedBy } = getAliasRoot(binding) || binding;
+			if (returnedBy && (!last || last.id < returnedBy.id)) last = returnedBy;
+			if (binding.derivedFrom) forEach(getValueReferences(binding.derivedFrom), track);
+			forEach(binding.sources?.state, track);
+			forEach(binding.sources?.param, track);
+		}
+	};
+	forEach(intersection, track);
+	return last;
 }
 function getIntersectionSource(intersection, section, resolved) {
 	if (!resolved.has(intersection)) {
@@ -6742,11 +6800,6 @@ function resolveBindingSources(binding) {
 			binding.sources = globalSources;
 			return;
 	}
-	if (binding.localOf) {
-		resolveBindingSources(binding.localOf);
-		binding.sources = binding.localOf.sources;
-		return;
-	}
 	const aliasRoot = getAliasRoot(binding);
 	if (aliasRoot) {
 		if (!resolvedSources.has(aliasRoot)) {
@@ -7058,6 +7111,9 @@ function getValueReason(extra) {
 	}
 	return reason;
 }
+function getReasonForExpr(extra) {
+	return readersOfExtra(extra).reason;
+}
 function readersOfExtra(extra) {
 	if (extra.isEffect) return ALWAYS_READ;
 	const readers = extraReaders(extra);
@@ -7520,7 +7576,7 @@ function getOrCreateLocalClosure(local, section) {
 	while (section.parent !== local.section) section = section.parent;
 	let closure = local.localClosures?.get(section);
 	if (!closure) {
-		closure = createBinding(local.name, 4, section, void 0, void 0, void 0, local.loc);
+		closure = createBinding(local.name, 2, section, void 0, void 0, void 0, local.loc);
 		closure.localOf = local;
 		(local.localClosures ??= /* @__PURE__ */ new Map()).set(section, closure);
 	}
@@ -11038,6 +11094,7 @@ var dynamic_tag_default = {
 		if (tag.node.extra?.tagNameUnresolved) throw tagNotFoundError(tag);
 		(0, _marko_compiler_babel_utils.assertAttributesOrArgs)(tag);
 		const { node } = tag;
+		if (node.var && node.extra.featureType === "class") throw tag.get("var").buildCodeFrameError(`The Marko 5 (class API) tag \`${getStaticTagName(node)}\` cannot [\`<return>\`](https://markojs.com/docs/reference/core-tag#return) a value, so it does not support a [tag variable](https://markojs.com/docs/reference/language#tag-variables). Remove the variable, or migrate the tag to the tags API.`);
 		const definedBodySection = node.extra?.defineBodySection;
 		if (definedBodySection) {
 			knownTagAnalyze(tag, definedBodySection);
@@ -11159,7 +11216,8 @@ var dynamic_tag_default = {
 				flushInto(tag);
 				writeHTMLResumeStatements(tag.get("body"));
 				const markerGuard = getWriteGuard(tagSection, markerReason, true);
-				const dynamicTagExpr = hasTagArgs ? callRuntime("_dynamic_tag", getScopeIdIdentifier(tagSection), getScopeAccessorLiteral(nodeBinding), tagExpression, _marko_compiler.types.arrayExpression(args), contentProp ? contentProp.value : _marko_compiler.types.numericLiteral(0), _marko_compiler.types.numericLiteral(1), markerGuard) : callRuntime("_dynamic_tag", getScopeIdIdentifier(tagSection), getScopeAccessorLiteral(nodeBinding), tagExpression, args[0], args[1] || (markerGuard ? _marko_compiler.types.numericLiteral(0) : void 0), markerGuard ? _marko_compiler.types.numericLiteral(0) : void 0, markerGuard);
+				const debugTagVar = !isOptimize() && node.var && _marko_compiler.types.numericLiteral(1);
+				const dynamicTagExpr = hasTagArgs ? callRuntime("_dynamic_tag", getScopeIdIdentifier(tagSection), getScopeAccessorLiteral(nodeBinding), tagExpression, _marko_compiler.types.arrayExpression(args), contentProp ? contentProp.value : _marko_compiler.types.numericLiteral(0), _marko_compiler.types.numericLiteral(1), markerGuard, debugTagVar) : callRuntime("_dynamic_tag", getScopeIdIdentifier(tagSection), getScopeAccessorLiteral(nodeBinding), tagExpression, args[0], args[1] || (markerGuard ? _marko_compiler.types.numericLiteral(0) : void 0), markerGuard ? _marko_compiler.types.numericLiteral(0) : void 0, markerGuard, debugTagVar);
 				if (node.var && isTagVarResumed(tag)) {
 					const dynamicScopeIdentifier = generateUidIdentifier(tag.get("name").toString() + "_scope");
 					const mutatesTagVar = isTagVarAssigned(tag);
@@ -11174,10 +11232,10 @@ var dynamic_tag_default = {
 				const bodySection = getSectionForBody(tag.get("body"));
 				const signal = getSignal(section, nodeBinding, "dynamicTag");
 				let tagVarSignal;
-				if (tag.node.var) {
+				if (tag.node.var && isTagVarResumed(tag)) {
 					const varBinding = tag.node.var.extra.binding;
 					tagVarSignal = initValue(varBinding);
-					tagVarSignal.register = isTagVarResumed(tag);
+					tagVarSignal.register = true;
 					tagVarSignal.referenced = true;
 					tagVarSignal.buildAssignment = (valueSection, value) => {
 						const changeArgs = [_marko_compiler.types.memberExpression(getScopeExpression(tagVarSignal.section, valueSection), _marko_compiler.types.stringLiteral(getAccessorPrefix().BranchScopes + getScopeAccessor(nodeBinding)), true), value];
@@ -11195,9 +11253,9 @@ var dynamic_tag_default = {
 					const argsOrInput = hasTagArgs ? _marko_compiler.types.arrayExpression(args) : args[0];
 					if (!_marko_compiler.types.isObjectExpression(argsOrInput) || argsOrInput.properties.length) signal.extraArgs = [_marko_compiler.types.arrowFunctionExpression([], statements.length ? _marko_compiler.types.blockStatement(statements.concat(_marko_compiler.types.returnStatement(argsOrInput))) : argsOrInput)];
 				}
+				enableDynamicTagVar(tag);
 				if (!isClassAPI) {
 					enableDynamicTagResume(tag);
-					enableDynamicTagVar(tag);
 					enableDynamicTagControllables(tag);
 				}
 				addValue(section, getReferencedBindings(tagExtra), signal, tagExpression);
@@ -11216,9 +11274,9 @@ function enableDynamicTagControllables(tag) {
 	}
 }
 function enableDynamicTagVar(tag) {
-	if (!tag.node.var || !isTagVarResumed(tag) || analyzeTagNameType(tag, true) === 1) return;
+	if (!tag.node.var || !isTagVarResumed(tag)) return;
 	importRuntimeFeature("dynamic-tag-var");
-	if (!tag.node.var.extra.binding.pruned) {
+	if (analyzeTagNameType(tag, true) !== 1 && !tag.node.var.extra.binding.pruned) {
 		const accessor = getScopeAccessorLiteral(tag.node.extra.nodeBinding, true);
 		if (addRuntimeOnce(`_dynamic_tag_var_resume ${accessor.value}`)) (0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.expressionStatement(callRuntime("_dynamic_tag_var_resume", accessor)));
 	}

package/dist/translator/util/module-registrations.d.ts

@@ -2,6 +2,6 @@ import { types as t } from "@marko/compiler";
 /**
  * Writes the registrations for module scoped functions: the ones this template
  * exports and registers itself, and the ones it imports from a template that
- * reserved a register id without registering it.
+ * reserved a register id without registering it; and for templates it imports.
  */
 export declare function writeModuleRegistrations(program: t.NodePath<t.Program>): void;

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

@@ -6,5 +6,6 @@ import { type Section } from "./sections";
 export declare function solveReasons(intersectionsBySection: Map<Section, Intersection[]>): void;
 export declare function getReasonForBinding(binding: Binding, properties?: Opt<string> | true): undefined | Reason;
 export declare function getValueReason(extra: t.NodeExtra): undefined | Reason;
+export declare function getReasonForExpr(extra: t.NodeExtra): undefined | Reason;
 export declare function readsValuesOnResume(expr: t.NodeExtra): boolean;
 export declare function addAlwaysRead(binding: Binding): void;

package/dist/translator/visitors/function.d.ts

@@ -2,16 +2,16 @@ import { types as t } from "@marko/compiler";
 declare const kRegisteredExports: unique symbol;
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
-        [kRegisteredExports]?: Map<string, ReservedExport>;
+        [kRegisteredExports]?: Map<string, RegisteredExport>;
     }
 }
-/** The canonical name a reserved register id is exported under, and its id. */
-export interface ReservedExport {
+/**
+ * An export registered under an id: the template that declares it, and the
+ * canonical name it is exported under.
+ */
+export interface RegisteredExport {
     registerId: string;
     exportName: string;
-}
-/** A reserved export, plus the template that declares it. */
-export interface ResolvedExport extends ReservedExport {
     filename: string;
 }
 declare const _default: {
@@ -21,15 +21,20 @@ export default _default;
 export declare function resolveFunctionReason(): void;
 export declare function finalizeFunctionRegistry(): void;
 /**
- * Tracks a function imported from another template that reserved a register id.
- * The importing template registers it (under the reserved id) when client
+ * Tracks a template imported as a default export. The server writes a template
+ * only as a binding's value, so the importing template registers it when one may.
+ */
+export declare function trackImportedTemplate(importDecl: t.NodePath<t.ImportDeclaration>, local: string, templateFile: t.BabelFile): void;
+/**
+ * Tracks an export imported from another template that registers under an id,
+ * if it does. The importing template registers it (under that id) when client
  * code reads its own references.
  */
-export declare function trackImportedFn(importDecl: t.NodePath<t.ImportDeclaration>, local: string, resolved: ResolvedExport): void;
+export declare function trackImport(importDecl: t.NodePath<t.ImportDeclaration>, local: string, registered: RegisteredExport | undefined, fnRoots?: Set<t.NodeExtra>): void;
 /**
  * Finds the id reserved for an export, following `export ... from` hops. Each
  * template only records the exports it declares, so this resolves on demand:
  * a template in an import cycle is read while it is still analyzing, and would
  * hand out an incomplete map if the ids were pushed ahead of time.
  */
-export declare function resolveRegisteredExport(file: t.BabelFile, exportName: string, seen?: Set<string>): ResolvedExport | undefined;
+export declare function resolveRegisteredExport(file: t.BabelFile, exportName: string, seen?: Set<string>): RegisteredExport | undefined;

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

@@ -1,6 +1,6 @@
 import { types as t } from "@marko/compiler";
 import type { LoadTrigger } from "../../html/assets";
-import { type ResolvedExport } from "./function";
+import { type RegisteredExport } from "./function";
 declare module "@marko/compiler/dist/types" {
     interface ProgramExtra {
         /** Absolute filenames of templates this one imports with `load`. */
@@ -9,9 +9,8 @@ declare module "@marko/compiler/dist/types" {
     interface ImportDeclarationExtra {
         tagImport?: string;
         loadImport?: LoadImportConfig;
-        registeredImportedFns?: (ResolvedExport & {
-            local: string;
-        })[];
+        /** Each local binding the template registers -> the export it imports. */
+        registeredImports?: Map<string, RegisteredExport>;
     }
 }
 export type LoadImportConfig = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.4.2",
+  "version": "6.4.4",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -51,13 +51,13 @@
     }
   },
   "dependencies": {
-    "@marko/compiler": "^5.42.10",
+    "@marko/compiler": "^5.42.11",
     "csstype": "^3.2.3",
     "fastest-levenshtein": "^1.0.16",
     "magic-string": "^0.30.21"
   },
   "devDependencies": {
-    "@marko/runtime-tags": "npm:marko@6.4.2",
+    "@marko/runtime-tags": "npm:marko@6.4.4",
     "marko": "5.39.45"
   },
   "engines": {

package/tags-html.d.ts

@@ -2225,11 +2225,6 @@ declare global {
          */
         autocomplete?: AttrAutoComplete;
 
-        /**
-         * (Safari only). Controls the autocorrect behavior of the <textarea> element.
-         */
-        autocorrect?: AttrOnOff;
-
         /**
          * Specifies the visible width of the <textarea> element in terms of character width.
          * @see https://html.spec.whatwg.org/multipage/form-elements.html#attr-textarea-cols
@@ -4208,6 +4203,12 @@ declare global {
         | "sentences"
         | "words";
 
+      /**
+       * Controls whether user agents may autocorrect spelling while the user types.
+       * @see https://html.spec.whatwg.org/multipage/interaction.html#attr-autocorrect
+       */
+      autocorrect?: AttrOnOff;
+
       /**
        * Indicates whether the element should automatically get focus when the page loads.
        * @see https://html.spec.whatwg.org/multipage/interaction.html#the-autofocus-attribute
@@ -5938,10 +5939,11 @@ interface CommonAttributes<T extends Element> {
 type AttrMissing = undefined | null | false;
 type AttrClass =
   | AttrMissing
+  | 0
   | string
   | AttrClass[]
-  | Record<string, AttrMissing | boolean>;
-type AttrStyle = AttrMissing | string | Marko.CSS.Properties | AttrStyle[];
+  | Record<string, AttrMissing | boolean | number>;
+type AttrStyle = AttrMissing | 0 | string | Marko.CSS.Properties | AttrStyle[];
 type AttrCrossOrigin = AttrBoolean | "anonymous" | "use-credentials";
 type AttrEventHandler<Event, Target> =
   | AttrMissing