marko 6.4.3 → 6.4.4

package/dist/translator/index.js

@@ -955,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) {
@@ -989,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
@@ -1015,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);
@@ -1048,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;
@@ -1062,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);
@@ -1095,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)}`);
 }
@@ -1593,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" : "";
 }
@@ -1662,6 +1695,7 @@ const pureDOMFunctions = /* @__PURE__ */ new Set([
 	"_dynamic_tag_content",
 	"_content_closures",
 	"_template",
+	"_return_setup",
 	"_closure",
 	"_closure_get",
 	"_or",
@@ -1680,7 +1714,6 @@ const pureDOMFunctions = /* @__PURE__ */ new Set([
 	"_const",
 	"_load_signal",
 	"_load_setup",
-	"_load_setup_var",
 	"_load_template",
 	"_load_visible_trigger",
 	"_load_event_trigger",
@@ -1890,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);
 	}
@@ -1933,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) {
@@ -2157,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) {
@@ -2198,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;
 			}
@@ -2230,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) {
@@ -4299,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__");
@@ -4323,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)
 		]))));
 	}
 } };
@@ -4332,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() {
@@ -4339,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) => {
@@ -4819,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) {
@@ -4866,7 +4908,6 @@ function translateDOM$1(tag) {
 	const isLoad = !!loadConfig;
 	const tagName = getStaticTagName(node);
 	if (isLoad) {
-		if (node.var) importRuntimeFeature("dynamic-tag-var");
 		const childFileName = childFile.opts.filename;
 		const { triggers, signals, setups } = getLoadIdentifiers();
 		let triggerIdent = triggers.get(loadConfig);
@@ -4889,14 +4930,14 @@ function translateDOM$1(tag) {
 			}
 			return signalIdent;
 		}, (section, childBinding) => {
-			const setupKey = `${triggerIdent ? triggerIdent.name : ""}\0${childFileName}${node.var ? "\0var" : ""}`;
+			const setupKey = `${triggerIdent ? triggerIdent.name : ""}\0${childFileName}`;
 			let setupIdent = setups.get(setupKey);
 			if (!setupIdent) {
 				setupIdent = generateUidIdentifier(`load_${tagName}_setup`);
 				setups.set(setupKey, setupIdent);
 				const setupLoadExpr = _marko_compiler.types.arrowFunctionExpression([], dynamicImport(buildLoadSetupVirtualModule(file, childFileName, childExports)));
 				importRuntimeFeature("catch");
-				(0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.variableDeclaration("let", [_marko_compiler.types.variableDeclarator(setupIdent, callRuntime(node.var ? "_load_setup_var" : "_load_setup", triggerIdent ? _marko_compiler.types.addComment(_marko_compiler.types.callExpression(triggerIdent, [setupLoadExpr]), "leading", "@__PURE__") : setupLoadExpr))]));
+				(0, _marko_compiler_babel_utils.getProgram)().node.body.push(_marko_compiler.types.variableDeclaration("let", [_marko_compiler.types.variableDeclarator(setupIdent, callRuntime("_load_setup", triggerIdent ? _marko_compiler.types.addComment(_marko_compiler.types.callExpression(triggerIdent, [setupLoadExpr]), "leading", "@__PURE__") : setupLoadExpr))]));
 			}
 			addStatement("render", section, void 0, _marko_compiler.types.expressionStatement(_marko_compiler.types.callExpression(setupIdent, [
 				scopeIdentifier,
@@ -5870,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)));
@@ -5882,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);
@@ -5897,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;
 }
@@ -7062,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);
@@ -11164,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);

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.3",
+  "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.3",
+    "@marko/runtime-tags": "npm:marko@6.4.4",
     "marko": "5.39.45"
   },
   "engines": {

package/tags-html.d.ts

@@ -5939,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