larrylint 0.1.1 → 0.2.0

package/dist/_chunks/preset.mjs

@@ -1,7 +1,7 @@
 import { name, version } from "./package.mjs";
 import process from "node:process";
 import { loadConfig } from "c12";
-import { basename, dirname, join, normalize, parse, relative, resolve } from "pathe";
+import { dirname, join, normalize, parse, relative, resolve } from "pathe";
 import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import tsParser, { parse as parse$1 } from "@typescript-eslint/parser";
 import { parse as parse$2 } from "vue-eslint-parser";
@@ -17,76 +17,15 @@ async function loadLarrylintConfig(cwd = process.cwd()) {
 		globalRc: false,
 		dotenv: false
 	});
-	return {
-		sharedDomains: config.sharedDomains ?? [],
-		heavyPackages: config.heavyPackages ?? []
-	};
-}
-const EXTENSIONS = [
-	"",
-	".ts",
-	".mts",
-	".cts",
-	".js",
-	".mjs",
-	".cjs",
-	"/index.ts",
-	"/index.js"
-];
-const directories = /* @__PURE__ */ new Map();
-function cachedReader(parse) {
-	const cache = /* @__PURE__ */ new Map();
-	return (path) => {
-		let mtimeMs;
-		try {
-			mtimeMs = statSync(path).mtimeMs;
-		} catch {
-			return;
-		}
-		const cached = cache.get(path);
-		if (cached?.mtimeMs === mtimeMs) return cached.value;
-		const value = parse(readFileSync(path, "utf8"));
-		cache.set(path, {
-			mtimeMs,
-			value
-		});
-		return value;
-	};
+	return { heavyPackages: config.heavyPackages ?? [] };
 }
-function isDirectory(path) {
-	let result = directories.get(path);
-	if (result === void 0) {
-		try {
-			result = statSync(path).isDirectory();
-		} catch {
-			result = false;
-		}
-		directories.set(path, result);
-	}
-	return result;
-}
-function resolveImport(importer, source) {
-	if (!source.startsWith("./") && !source.startsWith("../")) return;
-	const target = resolve(dirname(importer), source.split("?")[0]);
-	return isDirectory(target) ? `${target}/index` : target;
-}
-function resolveModule(importer, source) {
-	if (!source.startsWith("./") && !source.startsWith("../")) return;
-	const target = resolve(dirname(importer), source.split("?")[0]);
-	return EXTENSIONS.map((extension) => `${target}${extension}`).find((path) => existsSync(path) && !isDirectory(path));
-}
-function findPackage(from, name) {
-	for (let folder = from;; folder = dirname(folder)) {
-		const candidate = join(folder, "node_modules", name);
-		if (existsSync(join(candidate, "package.json"))) return realpathSync(candidate);
-		if (dirname(folder) === folder) return;
-	}
-}
-const HANDLER_FILE = /\.(query|resolver|link|action|template|page-index)(?:\.[cm]?[jt]s)?$/;
+const HANDLER_FILE = /\.(query|resolver|link|action|templates?|page-index)(?:\.[cm]?[jt]s)?$/;
 const TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
 const APP_FOLDERS = {
 	"sections": "section",
+	"section": "section",
 	"blocks": "block",
+	"block": "block",
 	"components": "component",
 	"composables": "composable",
 	"utils": "app-util",
@@ -129,10 +68,6 @@ function classify(file) {
 		test
 	};
 }
-function domainOf(file) {
-	if (!file.domain || file.kind === "handler" || file.kind === "orchestr-file") return file.domain;
-	return isDirectory(`${file.root}/src/runtime/server/orchestr/${file.domain}`) ? file.domain : void 0;
-}
 function classifyRuntime(parts) {
 	const [side, folder = "", ...rest] = parts;
 	if (parts.length < 2 || side !== "app" && side !== "server" && side !== "shared") return { side: "other" };
@@ -144,27 +79,83 @@ function classifyRuntime(parts) {
 		side,
 		kind: APP_FOLDERS[folder] ?? "other"
 	};
-	const nested = rest.length > 1;
 	if (folder === "orchestr") {
-		if (nested && rest[0] === "plugins") return {
+		if (rest.length > 1 && rest[0] === "plugins") return {
 			side,
 			kind: "orchestr-plugin"
 		};
-		const handler = HANDLER_FILE.exec(parts.at(-1))?.[1];
+		const handler = HANDLER_FILE.exec(parts.at(-1))?.[1]?.replace("templates", "template");
 		return {
 			side,
 			kind: handler ? "handler" : "orchestr-file",
-			handler,
-			domain: nested ? rest[0] : void 0
+			handler
 		};
 	}
-	const kind = SERVER_FOLDERS[folder] ?? "other";
 	return {
 		side,
-		kind,
-		domain: kind === "server-util" && nested ? rest[0] : void 0
+		kind: SERVER_FOLDERS[folder] ?? "other"
 	};
 }
+const EXTENSIONS = [
+	"",
+	".ts",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs",
+	"/index.ts",
+	"/index.js"
+];
+const directories = /* @__PURE__ */ new Map();
+function cachedReader(parse) {
+	const cache = /* @__PURE__ */ new Map();
+	return (path) => {
+		let mtimeMs;
+		try {
+			mtimeMs = statSync(path).mtimeMs;
+		} catch {
+			return;
+		}
+		const cached = cache.get(path);
+		if (cached?.mtimeMs === mtimeMs) return cached.value;
+		const value = parse(readFileSync(path, "utf8"));
+		cache.set(path, {
+			mtimeMs,
+			value
+		});
+		return value;
+	};
+}
+function isDirectory(path) {
+	let result = directories.get(path);
+	if (result === void 0) {
+		try {
+			result = statSync(path).isDirectory();
+		} catch {
+			result = false;
+		}
+		directories.set(path, result);
+	}
+	return result;
+}
+function resolveImport(importer, source) {
+	if (!source.startsWith("./") && !source.startsWith("../")) return;
+	const target = resolve(dirname(importer), source.split("?")[0]);
+	return isDirectory(target) ? `${target}/index` : target;
+}
+function resolveModule(importer, source) {
+	if (!source.startsWith("./") && !source.startsWith("../")) return;
+	const target = resolve(dirname(importer), source.split("?")[0]);
+	return EXTENSIONS.map((extension) => `${target}${extension}`).find((path) => existsSync(path) && !isDirectory(path));
+}
+function findPackage(from, name) {
+	for (let folder = from;; folder = dirname(folder)) {
+		const candidate = join(folder, "node_modules", name);
+		if (existsSync(join(candidate, "package.json"))) return realpathSync(candidate);
+		if (dirname(folder) === folder) return;
+	}
+}
 const BASELINE_FILE = "larrylint-baseline.json";
 const readBaselineFile = cachedReader((text) => JSON.parse(text));
 function readBaseline(root) {
@@ -257,47 +248,6 @@ function defineRule(rule) {
 		}
 	};
 }
-function findProperty(object, key) {
-	for (const entry of object.properties) if (entry.type === "Property" && !entry.computed && (entry.key.type === "Identifier" && entry.key.name === key || entry.key.type === "Literal" && entry.key.value === key)) return entry.value;
-}
-function findStringProperty(object, key) {
-	const value = findProperty(object, key);
-	return value?.type === "Literal" && typeof value.value === "string" ? {
-		value: value.value,
-		node: value
-	} : void 0;
-}
-function objectElements(node) {
-	if (node?.type !== "ArrayExpression") return [];
-	return node.elements.filter((element) => element?.type === "ObjectExpression");
-}
-const ISO_4217 = /^[A-Z]{3}$/;
-var money_default = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Require money amounts in minor units and ISO 4217 currency codes." },
-		schema: [],
-		messages: {
-			minorUnits: "Money amounts are in minor units, e.g. 1999 for 19.99, so this price is off by a factor of 100.",
-			currency: "Money currencies are ISO 4217 codes like 'EUR', and formatters show '{{currency}}' as it is."
-		}
-	},
-	applies: (file) => file.side === "app" || file.side === "server" || file.side === "shared",
-	create: ({ report }) => ({ ObjectExpression: (node) => {
-		const amount = findProperty(node, "amount");
-		const currency = findProperty(node, "currency");
-		if (!amount || !currency) return;
-		if (amount.type === "Literal" && typeof amount.value === "number" && !Number.isInteger(amount.value)) report({
-			node: amount,
-			messageId: "minorUnits"
-		});
-		if (currency.type === "Literal" && typeof currency.value === "string" && !ISO_4217.test(currency.value)) report({
-			node: currency,
-			messageId: "currency",
-			data: { currency: currency.value }
-		});
-	} })
-});
 const WRAPPERS = /* @__PURE__ */ new Set([
 	"ChainExpression",
 	"TSNonNullExpression",
@@ -314,15 +264,6 @@ function chainRoot(node) {
 	else if (current.type === "MemberExpression") current = current.object;
 	else return current.type === "Identifier" ? current : void 0;
 }
-function chainMethods(node) {
-	const methods = [];
-	let current = node;
-	while (current?.type === "CallExpression" && current.callee.type === "MemberExpression" && current.callee.property.type === "Identifier") {
-		methods.push(current.callee.property.name);
-		current = current.callee.object;
-	}
-	return methods;
-}
 function memberPath(node) {
 	if (node.type === "Identifier") return [node.name];
 	if (node.type !== "MemberExpression") return [];
@@ -359,6 +300,37 @@ function followPromise(promise) {
 		end = call;
 	}
 }
+const TEST_DIRECTIVES = /* @__PURE__ */ new Set([
+	"if",
+	"else-if",
+	"show"
+]);
+function isReference(node) {
+	const { parent } = node;
+	if (parent?.type === "MemberExpression") return parent.property !== node || parent.computed;
+	return parent?.type !== "Property" || parent.key !== node || parent.computed || parent.shorthand;
+}
+function isNullish(node) {
+	return node.type === "Identifier" && node.name === "undefined" || node.type === "Literal" && node.value === null && !("regex" in node);
+}
+function canBeNullish(value) {
+	if (isNullish(value)) return true;
+	if (value.type === "LogicalExpression" && value.operator === "??") return canBeNullish(value.right);
+	if (value.type === "ConditionalExpression") return canBeNullish(value.consequent) || canBeNullish(value.alternate);
+	return false;
+}
+function isTested(node) {
+	const parent = node.parent;
+	switch (parent?.type) {
+		case "IfStatement":
+		case "WhileStatement":
+		case "ConditionalExpression": return parent.test === node;
+		case "LogicalExpression": return parent.left === node;
+		case "UnaryExpression": return parent.operator === "!";
+		case "VExpressionContainer": return parent.parent?.type === "VAttribute" && TEST_DIRECTIVES.has(parent.parent.key?.name?.name ?? "");
+		default: return false;
+	}
+}
 const SKIPPED = /* @__PURE__ */ new Set([
 	"parent",
 	"loc",
@@ -412,16 +384,28 @@ function isCaught(node) {
 	}
 	return false;
 }
+function canReturnNullish(fn, value) {
+	if (fn.body.type !== "BlockStatement") return fn.body !== value && canBeNullish(fn.body);
+	let nullish = false;
+	walkBody(fn, (node) => {
+		nullish ||= node.type === "ReturnStatement" && node.argument !== value && (!node.argument || canBeNullish(node.argument));
+	});
+	const last = fn.body.body.at(-1);
+	return nullish || last?.type !== "ReturnStatement" && last?.type !== "ThrowStatement";
+}
 var mutations_default = defineRule({
 	meta: {
 		type: "problem",
 		docs: { description: "Require error handling where a mutateAsync() promise is awaited or dropped, since a rejected mutation takes down its whole section or block." },
 		schema: [],
-		messages: { unhandled: "If this mutation fails, frontend-core replaces the whole section or block with its \"Retry\" state. Catch the error here with try/catch or .catch()." }
+		messages: {
+			unhandled: "If this mutation fails, frontend-core replaces the whole section or block with its \"Retry\" state, unless every caller catches the error. Catch it here with try/catch or .catch().",
+			dropped: "Nothing handles this promise, so a failed mutation ends up as an unhandled rejection without any feedback. Catch it with try/catch or .catch()."
+		}
 	},
 	applies: (file) => file.side === "app",
 	create: ({ report, visitTemplate }) => {
-		const check = (call) => {
+		const check = (call, template) => {
 			if (nameOf(call.callee) !== "mutateAsync") return;
 			const { end, handled } = followPromise(call);
 			const { parent } = end;
@@ -431,146 +415,40 @@ var mutations_default = defineRule({
 			if (!awaited && !dropped || awaited && isCaught(parent)) return;
 			report({
 				node: call.callee.type === "MemberExpression" ? call.callee.property : call.callee,
-				messageId: "unhandled"
+				messageId: dropped && !template ? "dropped" : "unhandled"
 			});
 		};
-		visitTemplate({ CallExpression: check });
-		return { CallExpression: check };
+		visitTemplate({ CallExpression: (node) => check(node, true) });
+		return { CallExpression: (node) => check(node, false) };
 	}
 });
-const COMPONENTS = /* @__PURE__ */ new Set([
-	"section",
-	"block",
-	"component",
-	"override"
-]);
-var store_default = defineRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Keep useOrchestrStore() out of components, in composables." },
-		schema: [],
-		messages: { store: "Read orchestr data through a composable, so every component that shows it reads and refreshes it the same way. Move useOrchestrStore() into one." }
-	},
-	applies: (file) => COMPONENTS.has(file.kind ?? ""),
-	create: ({ report }) => ({ CallExpression: (node) => {
-		if (node.callee.type === "Identifier" && node.callee.name === "useOrchestrStore") report({
-			node,
-			messageId: "store"
-		});
-	} })
-});
+const METHODS = /* @__PURE__ */ new Set(["resolve", "resolveOrThrow"]);
+function destructuredResolvers(declarator) {
+	const methods = /* @__PURE__ */ new Map();
+	if (declarator.id.type !== "ObjectPattern" || !declarator.init || nameOf(declarator.init) !== "linkResolver") return methods;
+	for (const property of declarator.id.properties) {
+		const method = property.type === "Property" ? nameOf(property.key) : void 0;
+		if (method && METHODS.has(method) && property.type === "Property" && property.value.type === "Identifier") methods.set(property.value.name, method);
+	}
+	return methods;
+}
+function linkResolverMethod(call, destructured) {
+	const { callee } = call;
+	if (callee.type === "Identifier") return destructured.get(callee.name);
+	const method = callee.type === "MemberExpression" ? nameOf(callee) : void 0;
+	return method && METHODS.has(method) && callee.type === "MemberExpression" && nameOf(callee.object) === "linkResolver" ? method : void 0;
+}
+const NOT_PAGES = /^\/(?:\/|api\/|_|app-|\.well-known\/)/;
 function isInternalPath(path) {
-	return path?.startsWith("/") === true && !path.startsWith("//") && !path.startsWith("/api/");
+	return path?.startsWith("/") === true && !NOT_PAGES.test(path);
 }
 function isHandBuiltPath(node) {
 	if (node?.type === "TemplateLiteral") return node.expressions.length > 0 && isInternalPath(node.quasis[0]?.value.cooked);
 	return node?.type === "BinaryExpression" && node.operator === "+" && node.left.type === "Literal" && typeof node.left.value === "string" && isInternalPath(node.left.value);
 }
-function renderedRoots(template) {
-	return template.children.filter((child) => child.type === "VElement" && !child.startTag.attributes.some((attribute) => attribute.directive && (attribute.key.name.name === "else" || attribute.key.name.name === "else-if")));
-}
-function findAttribute(element, name) {
-	return element.startTag.attributes.find((attribute) => attribute.directive ? attribute.key.name.name === "bind" && attribute.key.argument?.type === "VIdentifier" && attribute.key.argument.name === name : attribute.key.name === name);
-}
-function valueStart(attribute) {
-	if (!attribute.directive) return attribute.value?.value;
-	const expression = attribute.value?.expression;
-	if (expression?.type === "Literal" && typeof expression.value === "string") return expression.value;
-	return expression?.type === "TemplateLiteral" ? expression.quasis[0]?.value.cooked ?? void 0 : void 0;
-}
-var anchors_default = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Disallow plain `<a>` tags for internal links, which reload the page and break Studio's navigation sync." },
-		schema: [],
-		messages: { anchor: "A plain <a> reloads the whole page and breaks Studio's navigation sync. Use <NuxtLink> for internal links." }
-	},
-	applies: (file) => file.side === "app" && file.path.endsWith(".vue"),
-	create: ({ report, visitTemplate }) => {
-		visitTemplate({ VElement: (node) => {
-			if (node.rawName !== "a") return;
-			const href = findAttribute(node, "href");
-			const target = findAttribute(node, "target");
-			const external = target && !target.directive && target.value?.value === "_blank";
-			if (href && isInternalPath(valueStart(href)) && !external) report({
-				loc: href.loc,
-				messageId: "anchor"
-			});
-		} });
-		return {};
-	}
-});
-const LINK_NAMES = /* @__PURE__ */ new Set([
-	"to",
-	"href",
-	"link"
-]);
-const NAVIGATE = /* @__PURE__ */ new Set([
-	"navigateTo",
-	"push",
-	"replace"
-]);
-var paths_default = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Disallow hand-built internal paths, which break when a page type's route changes." },
-		schema: [],
-		messages: { path: "This path breaks when the page type's route changes, and Studio can't follow it. Resolve the link with linkResolver instead." }
-	},
-	applies: (file) => file.side === "app",
-	create: ({ report, visitTemplate }) => {
-		visitTemplate({ VAttribute: (node) => {
-			const argument = node.directive && node.key.name.name === "bind" ? node.key.argument : null;
-			const expression = node.directive ? node.value?.expression : void 0;
-			if (argument?.type === "VIdentifier" && LINK_NAMES.has(argument.name) && isHandBuiltPath(expression)) report({
-				node: expression,
-				messageId: "path"
-			});
-		} });
-		return {
-			CallExpression: (node) => {
-				const [target] = node.arguments;
-				if (NAVIGATE.has(nameOf(node.callee) ?? "") && isHandBuiltPath(target)) report({
-					node: target,
-					messageId: "path"
-				});
-			},
-			Property: (node) => {
-				if (node.key.type === "Identifier" && LINK_NAMES.has(node.key.name) && isHandBuiltPath(node.value)) report({
-					node: node.value,
-					messageId: "path"
-				});
-			}
-		};
-	}
-});
-const TEST_DIRECTIVES = /* @__PURE__ */ new Set([
-	"if",
-	"else-if",
-	"show"
-]);
-function isReference(node) {
-	const { parent } = node;
-	if (parent?.type === "MemberExpression") return parent.property !== node || parent.computed;
-	return parent?.type !== "Property" || parent.key !== node || parent.computed || parent.shorthand;
-}
-function canBeNullish(value) {
-	if (value.type === "Identifier" && value.name === "undefined" || value.type === "Literal" && value.value === null && !("regex" in value)) return true;
-	if (value.type === "LogicalExpression" && value.operator === "??") return canBeNullish(value.right);
-	if (value.type === "ConditionalExpression") return canBeNullish(value.consequent) || canBeNullish(value.alternate);
-	return false;
-}
-function isTested(node) {
-	const parent = node.parent;
-	switch (parent?.type) {
-		case "IfStatement":
-		case "WhileStatement":
-		case "ConditionalExpression": return parent.test === node;
-		case "LogicalExpression": return parent.left === node;
-		case "UnaryExpression": return parent.operator === "!";
-		case "VExpressionContainer": return parent.parent?.type === "VAttribute" && TEST_DIRECTIVES.has(parent.parent.key?.name?.name ?? "");
-		default: return false;
-	}
+function isRouter(node) {
+	const name = nameOf(node.type === "CallExpression" ? node.callee : node);
+	return node.type === "CallExpression" ? name === "useRouter" : name === "router" || name === "$router";
 }
 const parseFile = cachedReader((text) => {
 	try {
@@ -611,6 +489,22 @@ function findFunction(statements, name) {
 		}
 	}
 }
+function findConstant(statements, name) {
+	for (const statement of statements) {
+		const declaration = statement.type === "ExportNamedDeclaration" && statement.declaration ? statement.declaration : statement;
+		if (declaration.type !== "VariableDeclaration" || declaration.kind !== "const") continue;
+		const declarator = declaration.declarations.find((item) => item.id.type === "Identifier" && item.id.name === name);
+		if (declarator?.init) return declarator.init;
+	}
+}
+function resolveConstant(name, program, filename) {
+	const local = findConstant(program.body, name);
+	if (local) return local;
+	const imported = findImport(program, name);
+	const file = imported && imported.name !== "*" ? resolveModule(filename, imported.source) : void 0;
+	const module = file ? parseFile(file) : void 0;
+	return module && imported ? findConstant(module.body, imported.name) : void 0;
+}
 function findExport(program, name) {
 	for (const statement of program.body) {
 		if (statement.type === "ExportDefaultDeclaration" && name === "default") {
@@ -665,33 +559,138 @@ function usedProps(node) {
 }
 function findHolder(node) {
 	let value = node;
+	let fn;
 	const { parent } = node;
 	if (parent?.type === "ReturnStatement") {
-		let fn = parent.parent;
-		while (fn && !isFunction(fn)) fn = fn.parent;
-		value = fn ?? value;
-	} else if (parent && isFunction(parent) && parent.body === node) value = parent;
+		let current = parent.parent;
+		while (current && !isFunction(current)) current = current.parent;
+		fn = current ?? void 0;
+		value = current ?? value;
+	} else if (parent && isFunction(parent) && parent.body === node) {
+		fn = parent;
+		value = parent;
+	}
 	const computed = value.parent?.type === "CallExpression" && value.parent.callee.type === "Identifier" && value.parent.callee.name === "computed" ? value.parent : void 0;
 	const declarator = (computed ?? value).parent;
 	return declarator?.type === "VariableDeclarator" && declarator.id.type === "Identifier" ? {
 		name: declarator.id.name,
-		computed: computed !== void 0
+		computed: computed !== void 0,
+		fn
 	} : void 0;
 }
 function importedComponent(program, filename, name) {
 	const imported = findImport(program, name);
 	return imported?.name === "default" && imported.source.endsWith(".vue") ? resolveModule(filename, imported.source) : void 0;
 }
+function renderedRoots(template) {
+	return template.children.filter((child) => child.type === "VElement" && !child.startTag.attributes.some((attribute) => attribute.directive && (attribute.key.name.name === "else" || attribute.key.name.name === "else-if")));
+}
+function findAttribute(element, name) {
+	return element.startTag.attributes.find((attribute) => attribute.directive ? attribute.key.name.name === "bind" && attribute.key.argument?.type === "VIdentifier" && attribute.key.argument.name === name : attribute.key.name === name);
+}
+function valueStart(attribute) {
+	if (!attribute.directive) return attribute.value?.value;
+	const expression = attribute.value?.expression;
+	if (expression?.type === "Literal" && typeof expression.value === "string") return expression.value;
+	return expression?.type === "TemplateLiteral" ? expression.quasis[0]?.value.cooked ?? void 0 : void 0;
+}
+function rendersTag(element, tag) {
+	const is = element.rawName === "component" ? findAttribute(element, "is") : void 0;
+	if (element.rawName === tag || is && !is.directive && is.value?.value === tag) return true;
+	const expression = is?.directive ? is.value?.expression : void 0;
+	let found = false;
+	if (expression) walk(expression, (node) => {
+		found ||= node.type === "Literal" && node.value === tag;
+	});
+	return found;
+}
+var anchors_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow plain `<a>` tags for internal and resolved links, which reload the page and break Studio's navigation sync." },
+		schema: [],
+		messages: { anchor: "A plain <a> reloads the whole page and breaks Studio's navigation sync. Use <NuxtLink> for internal links." }
+	},
+	applies: (file) => file.side === "app" && file.path.endsWith(".vue"),
+	create: ({ report, visitTemplate }) => {
+		const destructured = /* @__PURE__ */ new Map();
+		const resolved = /* @__PURE__ */ new Set();
+		const resolves = (node) => node.type === "CallExpression" && (linkResolverMethod(node, destructured) !== void 0 || nameOf(node.callee) === "useResolvedLink");
+		visitTemplate({ VElement: (node) => {
+			const href = rendersTag(node, "a") ? findAttribute(node, "href") : void 0;
+			const target = findAttribute(node, "target");
+			if (!href || findAttribute(node, "download") || target && !target.directive && target.value?.value === "_blank") return;
+			const expression = href.directive ? href.value?.expression : void 0;
+			if (expression && (resolves(expression) || expression.type === "Identifier" && resolved.has(expression.name)) || isInternalPath(valueStart(href))) report({
+				loc: href.loc,
+				messageId: "anchor"
+			});
+		} });
+		return {
+			VariableDeclarator: (node) => {
+				destructuredResolvers(node).forEach((method, local) => destructured.set(local, method));
+			},
+			CallExpression: (node) => {
+				const holder = resolves(node) ? findHolder(node) : void 0;
+				if (holder) resolved.add(holder.name);
+			}
+		};
+	}
+});
+const LINK_NAMES = /* @__PURE__ */ new Set([
+	"to",
+	"href",
+	"link"
+]);
+const ROUTER_METHODS = /* @__PURE__ */ new Set(["push", "replace"]);
+var paths_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow hand-built paths to pages, which miss the per-language paths and market prefixes Studio sets." },
+		schema: [],
+		messages: { path: "Page paths are set per page and language in Studio, and each market adds its own prefix, e.g. /en, so this path can lead to the wrong page. Resolve the link with linkResolver instead." }
+	},
+	applies: (file) => file.side === "app",
+	create: ({ report, visitTemplate }) => {
+		visitTemplate({ VAttribute: (node) => {
+			const argument = node.directive && node.key.name.name === "bind" ? node.key.argument : null;
+			const expression = node.directive ? node.value?.expression : void 0;
+			if (argument?.type === "VIdentifier" && LINK_NAMES.has(argument.name) && isHandBuiltPath(expression)) report({
+				node: expression,
+				messageId: "path"
+			});
+		} });
+		return {
+			CallExpression: (node) => {
+				const { callee } = node;
+				const [target] = node.arguments;
+				if ((callee.type === "Identifier" ? callee.name === "navigateTo" : callee.type === "MemberExpression" && ROUTER_METHODS.has(nameOf(callee) ?? "") && isRouter(callee.object)) && isHandBuiltPath(target)) report({
+					node: target,
+					messageId: "path"
+				});
+			},
+			Property: (node) => {
+				if (node.key.type === "Identifier" && LINK_NAMES.has(node.key.name) && isHandBuiltPath(node.value)) report({
+					node: node.value,
+					messageId: "path"
+				});
+			}
+		};
+	}
+});
 var resolve_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallow testing the result of linkResolver.resolve(), which is never empty." },
+		docs: { description: "Disallow testing the result of linkResolver.resolve(), which falls back to a '#…' string instead of an empty value." },
 		schema: [],
-		messages: { tested: "linkResolver.resolve() never returns an empty value: a link it can't resolve comes back as a '#missing-required-params…' string, so this check always passes. Use resolveOrThrow() in a try/catch to tell an unresolvable link apart." }
+		messages: {
+			tested: "linkResolver.resolve() returns a '#…' fallback instead of an empty value when it can't resolve a link, so this check doesn't catch broken links. Use resolveOrThrow() (frontend-core 0.42+) in a try/catch to tell them apart.",
+			branch: "When it can't resolve the link, linkResolver.resolve() returns a '#…' fallback here, so the checks on {{name}} treat a broken link as a working one. Use resolveOrThrow() (frontend-core 0.42+) in a try/catch and return undefined instead."
+		}
 	},
 	applies: (file) => file.side === "app",
 	create: ({ report, visitTemplate }) => {
-		const resolveNames = /* @__PURE__ */ new Set();
+		const destructured = /* @__PURE__ */ new Map();
 		const calls = [];
 		const scriptIdentifiers = [];
 		const templateIdentifiers = [];
@@ -700,8 +699,7 @@ var resolve_default = defineRule({
 		} });
 		return {
 			"VariableDeclarator": (node) => {
-				if (node.id.type !== "ObjectPattern" || !node.init || nameOf(node.init) !== "linkResolver") return;
-				for (const property of node.id.properties) if (property.type === "Property" && nameOf(property.key) === "resolve" && property.value.type === "Identifier") resolveNames.add(property.value.name);
+				destructuredResolvers(node).forEach((method, local) => destructured.set(local, method));
 			},
 			"CallExpression": (node) => {
 				calls.push(node);
@@ -711,26 +709,38 @@ var resolve_default = defineRule({
 			},
 			"Program:exit": () => {
 				const holders = /* @__PURE__ */ new Map();
+				const reported = /* @__PURE__ */ new Set();
 				for (const call of calls) {
-					const { callee } = call;
-					if (!(callee.type === "MemberExpression" && nameOf(callee) === "resolve" && nameOf(callee.object) === "linkResolver") && !(callee.type === "Identifier" && resolveNames.has(callee.name))) continue;
+					if (linkResolverMethod(call, destructured) !== "resolve") continue;
 					if (isTested(call)) report({
 						node: call,
 						messageId: "tested"
 					});
 					const holder = findHolder(call);
-					if (holder) holders.set(holder.name, holder.computed);
+					if (holder) holders.set(holder.name, {
+						computed: holder.computed,
+						branch: holder.fn && canReturnNullish(holder.fn, call) ? call : void 0
+					});
 				}
 				const check = (identifier, template) => {
-					const computed = holders.get(identifier.name);
+					const holder = holders.get(identifier.name);
 					const { parent } = identifier;
-					if (computed === void 0 || !isReference(identifier)) return;
+					if (!holder || !isReference(identifier)) return;
 					const readsValue = parent.type === "MemberExpression" && parent.object === identifier && nameOf(parent) === "value";
-					const value = computed && !template ? readsValue ? parent : void 0 : identifier;
-					if (value && isTested(value)) report({
+					const value = holder.computed && !template ? readsValue ? parent : void 0 : identifier;
+					if (!value || !isTested(value)) return;
+					if (!holder.branch) report({
 						node: value,
 						messageId: "tested"
 					});
+					else if (!reported.has(holder.branch)) {
+						reported.add(holder.branch);
+						report({
+							node: holder.branch,
+							messageId: "branch",
+							data: { name: identifier.name }
+						});
+					}
 				};
 				scriptIdentifiers.forEach((identifier) => check(identifier, false));
 				templateIdentifiers.forEach((identifier) => check(identifier, true));
@@ -741,24 +751,27 @@ var resolve_default = defineRule({
 function kebabCase(name) {
 	return name.replace(/([a-z\d])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
 }
-function prefixName(name, prefix) {
-	return `${prefix}${name.endsWith(prefix) ? name.slice(0, -prefix.length) : name}`;
-}
 function camelCase(name) {
 	return name.replace(/[-_\s]+(.)?/g, (_, char) => char?.toUpperCase() ?? "").replace(/^[A-Z]/, (char) => char.toLowerCase());
 }
-const UI_KIT_BUTTON = /(?:^#ui-kit|@laioutr-core\/ui-kit)\/.*\/Button\.vue$/;
+const UI_KIT_BUTTON = /(?:^#ui-kit|@laioutr-core\/ui-kit)\/.*\/(?:Icon|BackgroundAware|Animated)?Button\.vue$/;
+const BUTTONS = [
+	"LButton",
+	"LIconButton",
+	"LBackgroundAwareButton",
+	"LAnimatedButton"
+];
 var button_default = defineRule({
 	meta: {
 		type: "problem",
 		fixable: "code",
-		docs: { description: "Disallow `type` on the ui-kit button, which silently renders its `button-type` prop instead." },
+		docs: { description: "Disallow `type` on the ui-kit buttons, which silently render their `button-type` prop instead." },
 		schema: [],
-		messages: { buttonType: "l-button ignores type and always renders its button-type prop, which defaults to \"button\". Use button-type." }
+		messages: { buttonType: "<{{tag}}> ignores type and always renders its button-type prop, which defaults to \"button\". Use button-type." }
 	},
 	applies: (file) => file.path.endsWith(".vue"),
 	create: ({ report, visitTemplate }) => {
-		const buttons = /* @__PURE__ */ new Set(["LButton", "l-button"]);
+		const buttons = new Set(BUTTONS.flatMap((name) => [name, kebabCase(name)]));
 		visitTemplate({ VElement: (node) => {
 			if (!buttons.has(node.rawName)) return;
 			for (const attribute of node.startTag.attributes) {
@@ -767,6 +780,7 @@ var button_default = defineRule({
 					report({
 						loc: key.loc,
 						messageId: "buttonType",
+						data: { tag: node.rawName },
 						fix: (fixer) => fixer.replaceTextRange(key.range, "button-type")
 					});
 				}
@@ -774,6 +788,7 @@ var button_default = defineRule({
 				if (attribute.directive && attribute.key.name.name === "bind" && argument?.type === "VIdentifier" && argument.rawName === "type") report({
 					loc: argument.loc,
 					messageId: "buttonType",
+					data: { tag: node.rawName },
 					fix: (fixer) => fixer.replaceTextRange(argument.range, "button-type")
 				});
 			}
@@ -788,101 +803,6 @@ var button_default = defineRule({
 		} };
 	}
 });
-function nuxtName(folders, stem) {
-	const parts = [...folders];
-	while (parts.length > 0 && kebabCase(stem).startsWith(kebabCase(parts.at(-1)))) parts.pop();
-	return [...parts, stem].join("");
-}
-const PACKAGES = ["@laioutr-core/ui-kit", "@laioutr-core/ui"];
-const cache$1 = /* @__PURE__ */ new Map();
-function uiKitTags(root) {
-	let tags = cache$1.get(root);
-	if (!tags) {
-		tags = /* @__PURE__ */ new Set();
-		for (const name of PACKAGES) {
-			const folder = findPackage(root, name);
-			if (!folder) throw new Error(`larrylint can't find ${name} from ${root}, which it reads the <l-*> components from. Install the app's dependencies first.`);
-			for (const file of readdirSync(join(folder, "dist/runtime"), {
-				recursive: true,
-				encoding: "utf8"
-			})) {
-				if (!file.endsWith(".vue")) continue;
-				const { dir, name: stem } = parse(file);
-				const segments = dir.split("/");
-				const folders = segments.slice(segments.lastIndexOf("components") + 1);
-				tags.add(`l-${kebabCase(stem)}`);
-				tags.add(`l-${kebabCase(nuxtName(folders, stem))}`);
-			}
-		}
-		cache$1.set(root, tags);
-	}
-	return tags;
-}
-var tags_default = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Require `<l-*>` tags to be ui-kit or ui components." },
-		schema: [],
-		messages: { unknown: "<{{tag}}> isn't a ui-kit or ui component, so it renders nothing. Only their components have the l- prefix; use your own components by their own name." }
-	},
-	applies: (file) => file.path.endsWith(".vue"),
-	create: ({ file, report, visitTemplate }) => {
-		const imported = /* @__PURE__ */ new Set();
-		visitTemplate({ VElement: (node) => {
-			const tag = kebabCase(node.rawName);
-			if (tag.startsWith("l-") && !imported.has(tag) && !uiKitTags(file.root).has(tag)) report({
-				loc: node.startTag.loc,
-				messageId: "unknown",
-				data: { tag: node.rawName }
-			});
-		} });
-		return { ImportDeclaration: (node) => {
-			for (const specifier of node.specifiers) imported.add(kebabCase(specifier.local.name));
-		} };
-	}
-});
-const COOKIE_SETTERS = /* @__PURE__ */ new Set(["setCookie", "deleteCookie"]);
-const REDIRECTS = /* @__PURE__ */ new Set(["sendRedirect", "navigateTo"]);
-const HEADER_SETTERS = /* @__PURE__ */ new Set([
-	"setHeader",
-	"setHeaders",
-	"appendHeader",
-	"setResponseHeader",
-	"setResponseHeaders",
-	"appendResponseHeader"
-]);
-function responseEffect(call) {
-	const name = nameOf(call.callee) ?? "";
-	if (COOKIE_SETTERS.has(name)) return "cookie";
-	if (REDIRECTS.has(name)) return "redirect";
-	const header = HEADER_SETTERS.has(name) ? call.arguments.find((argument) => argument.type === "Literal" && typeof argument.value === "string") : void 0;
-	const value = header?.type === "Literal" ? String(header.value).toLowerCase() : void 0;
-	return value === "set-cookie" ? "cookie" : value === "location" ? "redirect" : void 0;
-}
-function thrownStatus(error) {
-	if (error.type !== "CallExpression" && error.type !== "NewExpression") return;
-	for (const argument of error.arguments) {
-		const status = argument.type === "ObjectExpression" ? findProperty(argument, "status") ?? findProperty(argument, "statusCode") : void 0;
-		if (status?.type === "Literal" && typeof status.value === "number") return status.value;
-	}
-}
-var errors_default = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Require actions to return client errors as a status instead of throwing them." },
-		schema: [],
-		messages: { status: "The client never sees this {{status}}: orchestr's action transport drops status codes, so it arrives as a failed action. Return it as a status in the action's output instead." }
-	},
-	applies: (file) => file.handler === "action",
-	create: ({ report }) => ({ ThrowStatement: (node) => {
-		const status = thrownStatus(node.argument);
-		if (status !== void 0 && status >= 400 && status < 500) report({
-			node,
-			messageId: "status",
-			data: { status: String(status) }
-		});
-	} })
-});
 function readMiddleware(call) {
 	const { callee } = call;
 	if (callee.type !== "MemberExpression" || callee.computed || callee.property.type !== "Identifier") return;
@@ -894,42 +814,78 @@ function readMiddleware(call) {
 		callback
 	} : void 0;
 }
-function readMetaApp(call) {
-	const { callee } = call;
-	const [options] = call.arguments;
-	if (callee.type !== "MemberExpression" || callee.property.type !== "Identifier" || callee.property.name !== "meta" || chainRoot(callee.object)?.name !== "defineOrchestr" || options?.type !== "ObjectExpression") return;
-	return findStringProperty(options, "app");
-}
-function inMiddleware(node) {
-	for (let parent = node.parent; parent; parent = parent.parent) if (isFunction(parent) && parent.parent?.type === "CallExpression" && readMiddleware(parent.parent)?.callback === parent) return true;
-	return false;
-}
-function componentObjects(value) {
-	if (value.type === "ObjectExpression") return [value];
-	if (!isFunction(value)) return [];
-	if (value.body.type === "ObjectExpression") return [value.body];
-	const objects = [];
-	walkBody(value, (node) => {
-		if (node.type === "ReturnStatement" && node.argument?.type === "ObjectExpression") objects.push(node.argument);
-	});
-	return objects;
-}
+function enclosingMiddleware(node) {
+	for (let parent = node.parent; parent; parent = parent.parent) {
+		const middleware = isFunction(parent) && parent.parent?.type === "CallExpression" ? readMiddleware(parent.parent) : void 0;
+		if (middleware?.callback === parent) return middleware;
+	}
+}
+const COOKIE_WRITES = /* @__PURE__ */ new Set([
+	"setCookie",
+	"deleteCookie",
+	"setManagedCookie",
+	"deleteManagedCookie"
+]);
+const HEADER_WRITES = /* @__PURE__ */ new Set([
+	"setHeader",
+	"setHeaders",
+	"appendHeader",
+	"appendHeaders",
+	"setResponseHeader",
+	"setResponseHeaders",
+	"appendResponseHeader",
+	"appendResponseHeaders",
+	"setResponseStatus",
+	"sendRedirect"
+]);
+function responseWrite(call) {
+	const name = call.callee.type === "Identifier" ? call.callee.name : "";
+	if (COOKIE_WRITES.has(name)) return {
+		name,
+		kind: "cookie"
+	};
+	return HEADER_WRITES.has(name) ? {
+		name,
+		kind: "header"
+	} : void 0;
+}
+const STREAMED = /* @__PURE__ */ new Set([
+	"query",
+	"link",
+	"resolver"
+]);
+const MANAGED = {
+	setCookie: "setManagedCookie",
+	deleteCookie: "deleteManagedCookie"
+};
 var cookies_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallow Set-Cookie and redirects from orchestr handlers and middleware, which cached pages replay to every visitor." },
+		docs: { description: "Write cookies and headers only where orchestr allows it: in extendRequest() and action handlers, with frontend-core's managed cookie functions." },
 		schema: [],
 		messages: {
-			cookie: "ISR caches this response for every visitor, Set-Cookie included, so one visitor's cookie reaches the next. Set cookies from an API route or a Nitro middleware that skips cached pages.",
-			redirect: "ISR caches this redirect for every visitor. Redirect from an API route or on the client instead."
+			streamed: "Orchestr may have sent the response headers by the time {{name}}() runs here, so the browser never gets it. Write cookies and headers in extendRequest() or an action handler.",
+			managed: "Use {{managed}}() instead. It applies Laioutr's cookie policy, which the Studio preview needs (SameSite=None and Partitioned), and {{name}}() skips it."
 		}
 	},
 	applies: (file) => file.side === "server",
 	create: ({ file, report }) => ({ CallExpression: (node) => {
-		const effect = responseEffect(node);
-		if (effect && (file.kind === "handler" || inMiddleware(node))) report({
+		const write = responseWrite(node);
+		if (!write) return;
+		const method = enclosingMiddleware(node)?.method;
+		const managed = MANAGED[write.name];
+		if (method === "use" || !method && STREAMED.has(file.handler)) report({
 			node,
-			messageId: effect
+			messageId: "streamed",
+			data: { name: write.name }
+		});
+		else if (managed && (method === "extendRequest" || !method && file.handler === "action")) report({
+			node,
+			messageId: "managed",
+			data: {
+				name: write.name,
+				managed
+			}
 		});
 	} })
 });
@@ -946,9 +902,9 @@ const FILE_START = {
 var files_default$1 = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Keep orchestr/ to handler files, since Laioutr loads every file in it as a server plugin." },
+		docs: { description: "Keep orchestr/ to handler files, since Laioutr loads every file in it as a Nitro plugin." },
 		schema: [],
-		messages: { notAHandler: "Laioutr loads every file in orchestr/ as a server plugin. Name handlers *.query.ts, *.resolver.ts, *.link.ts, *.action.ts, *.template.ts or *.page-index.ts, and move everything else to server/utils/." }
+		messages: { notAHandler: "Laioutr loads every file in orchestr/ as a Nitro plugin, so a helper here runs at startup or breaks the build. Move it to server/utils/, and name handlers *.query.ts, *.resolver.ts, *.link.ts, *.action.ts, *.template.ts or *.page-index.ts." }
 	},
 	applies: (file) => file.kind === "orchestr-file",
 	create: ({ report }) => ({ Program: () => {
@@ -958,54 +914,12 @@ var files_default$1 = defineRule({
 		});
 	} })
 });
-var context_default = defineRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Require handlers to take config, clients and the request from their arguments and middleware context." },
-		schema: [],
-		messages: {
-			runtimeConfig: "Handlers get their config and clients from the middleware context. Read the config once in the builder's middleware.",
-			event: "Handlers get the request as `event` in their arguments, not from useEvent()."
-		}
-	},
-	applies: (file) => file.kind === "handler",
-	create: ({ report }) => ({ CallExpression: (node) => {
-		if (node.callee.type !== "Identifier") return;
-		if (node.callee.name === "useRuntimeConfig") report({
-			node,
-			messageId: "runtimeConfig"
-		});
-		else if (node.callee.name === "useEvent") report({
-			node,
-			messageId: "event"
-		});
-	} })
-});
-var domains_default = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Keep orchestr handlers in domain folders." },
-		schema: [],
-		messages: { noDomain: "Put handlers in a domain folder, e.g. orchestr/<domain>/{{file}}." }
-	},
-	applies: (file) => file.kind === "handler" && !file.domain,
-	create: ({ file, report }) => ({ Program: () => {
-		report({
-			loc: FILE_START,
-			messageId: "noDomain",
-			data: { file: basename(file.path) }
-		});
-	} })
-});
 var exports_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Require handler files to export their handler as default, and nothing else." },
+		docs: { description: "Require handler files to export their handler as default." },
 		schema: [],
-		messages: {
-			namedExport: "Handler files only export their handler. Laioutr registers the default export; move everything else to server/utils/.",
-			missingDefault: "Handler files export their handler as default, otherwise laioutr registers nothing."
-		}
+		messages: { missingDefault: "Laioutr loads every file in orchestr/ as a Nitro plugin from its default export, so without one the build fails. Export the handler as default." }
 	},
 	applies: (file) => file.kind === "handler",
 	create: ({ report }) => {
@@ -1014,22 +928,8 @@ var exports_default = defineRule({
 			"ExportDefaultDeclaration": () => {
 				hasDefault = true;
 			},
-			"ExportNamedDeclaration": (node) => {
-				const others = node.specifiers.filter((specifier) => {
-					const name = specifier.exported.type === "Identifier" ? specifier.exported.name : specifier.exported.value;
-					if (name === "default") hasDefault = true;
-					return name !== "default";
-				});
-				if (node.declaration || others.length > 0) report({
-					node,
-					messageId: "namedExport"
-				});
-			},
-			"ExportAllDeclaration": (node) => {
-				report({
-					node,
-					messageId: "namedExport"
-				});
+			"ExportSpecifier": (node) => {
+				hasDefault ||= (node.exported.type === "Identifier" ? node.exported.name : node.exported.value) === "default";
 			},
 			"Program:exit": () => {
 				if (!hasDefault) report({
@@ -1073,42 +973,6 @@ var files_default = defineRule({
 		};
 	}
 });
-const readPackageFile = cachedReader((text) => {
-	const json = JSON.parse(text);
-	return {
-		name: json.name,
-		dependencies: new Set([
-			json.dependencies,
-			json.devDependencies,
-			json.peerDependencies,
-			json.optionalDependencies
-		].flatMap((deps) => Object.keys(deps ?? {})))
-	};
-});
-function readPackage(root) {
-	return readPackageFile(join(root, "package.json"));
-}
-var meta_default = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Require `meta({ app })` of an orchestr builder to be the package name." },
-		schema: [],
-		messages: { app: "meta({ app }) is '{{actual}}', but the package is '{{expected}}'. Traces use this name to tell which app's middleware ran." }
-	},
-	applies: (file) => file.side === "server",
-	create: ({ file, report }) => ({ CallExpression: (node) => {
-		const app = readMetaApp(node);
-		const expected = app && readPackage(file.root)?.name;
-		if (app && expected && app.value !== expected) report({
-			node: app.node,
-			messageId: "app",
-			data: {
-				actual: app.value,
-				expected
-			}
-		});
-	} })
-});
 var throws_default = defineRule({
 	meta: {
 		type: "problem",
@@ -1149,42 +1013,6 @@ var throws_default = defineRule({
 		});
 	} })
 });
-var passthrough_default = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Disallow passthrough.require() in component resolvers." },
-		schema: [],
-		messages: { require: "Other queries for this entity may not set this passthrough, and require() then fails the whole resolver. Use passthrough.get() and handle a missing value." }
-	},
-	applies: (file) => file.handler === "resolver",
-	create: ({ report }) => ({ CallExpression: (node) => {
-		const { callee } = node;
-		if (callee.type === "MemberExpression" && nameOf(callee) === "require" && nameOf(callee.object) === "passthrough") report({
-			node: callee.property,
-			messageId: "require"
-		});
-	} })
-});
-var returns_default = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Require component resolvers to resolve fields to empty values rather than undefined or null." },
-		schema: [],
-		messages: { empty: "Studio shows a literal \"...\" for a field that resolves to undefined or null. Resolve to an empty value instead, e.g. ''." }
-	},
-	applies: (file) => file.handler === "resolver",
-	create: ({ report }) => ({ CallExpression: (node) => {
-		const [entity] = node.arguments;
-		if (node.callee.type !== "Identifier" || node.callee.name !== "$entity" || entity?.type !== "ObjectExpression") return;
-		for (const component of entity.properties) {
-			if (component.type !== "Property" || component.key.type === "Identifier" && component.key.name === "id") continue;
-			for (const object of componentObjects(component.value)) for (const field of object.properties) if (field.type === "Property" && canBeNullish(field.value)) report({
-				node: field.value,
-				messageId: "empty"
-			});
-		}
-	} })
-});
 const PACKAGE = "@laioutr-core/canonical-types";
 const TOKEN_ID = /define\w*Token\(\s*["'`]([a-z0-9-]+)\//g;
 const cache = /* @__PURE__ */ new Map();
@@ -1208,7 +1036,7 @@ var namespaces_default = defineRule({
 		type: "problem",
 		docs: { description: "Keep your own token ids out of the namespaces of Laioutr's canonical types." },
 		schema: [],
-		messages: { canonical: "'{{namespace}}/' belongs to Laioutr's canonical types. Put your own tokens under your app's namespace; otherwise registration order decides which handler wins." }
+		messages: { canonical: "'{{namespace}}/' belongs to Laioutr's canonical types, and a later canonical-types release or another app can take this id. Token metadata is last-write-wins, so put your own tokens under your app's namespace." }
 	},
 	applies: (file) => file.side === "app" || file.side === "server" || file.side === "shared",
 	create: ({ file, report }) => ({ CallExpression: (node) => {
@@ -1222,46 +1050,40 @@ var namespaces_default = defineRule({
 		});
 	} })
 });
-function objectShape(schema) {
-	let current = schema;
-	while (current?.type === "CallExpression" && current.callee.type === "MemberExpression" && current.callee.property.type === "Identifier") {
-		const [shape] = current.arguments;
-		if (current.callee.property.name === "object" && shape?.type === "ObjectExpression") return shape;
-		current = current.callee.object;
-	}
+function findProperty(object, key) {
+	for (const entry of object.properties) if (entry.type === "Property" && !entry.computed && (entry.key.type === "Identifier" && entry.key.name === key || entry.key.type === "Literal" && entry.key.value === key)) return entry.value;
+}
+function findStringProperty(object, key) {
+	const value = findProperty(object, key);
+	return value?.type === "Literal" && typeof value.value === "string" ? {
+		value: value.value,
+		node: value
+	} : void 0;
 }
-function isNullable(schema) {
-	return chainMethods(schema).some((method) => method === "nullable" || method === "nullish");
+function objectElements(node) {
+	if (node?.type !== "ArrayExpression") return [];
+	return node.elements.filter((element) => element?.type === "ObjectExpression");
 }
-var nullable_default = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Disallow nullable top-level fields in entity component tokens, which Studio can't bind." },
-		schema: [],
-		messages: { nullable: "Studio can't bind a nullable field. Resolve it to an empty value instead, e.g. '' or []." }
-	},
-	applies: (file) => file.side === "app" || file.side === "server" || file.side === "shared",
-	create: ({ report }) => ({ CallExpression: (node) => {
-		const options = node.arguments[1];
-		if (node.callee.type !== "Identifier" || node.callee.name !== "defineEntityComponentToken" || options?.type !== "ObjectExpression") return;
-		for (const field of objectShape(findProperty(options, "schema"))?.properties ?? []) if (field.type === "Property" && isNullable(field.value)) report({
-			node: field,
-			messageId: "nullable"
-		});
-	} })
-});
 const DEFINERS = {
 	defineSection: {
 		kind: "section",
-		folder: "sections",
-		prefix: "Section"
+		folder: "sections"
 	},
 	defineBlock: {
 		kind: "block",
-		folder: "blocks",
-		prefix: "Block"
+		folder: "blocks"
 	}
 };
+const PICKERS = /* @__PURE__ */ new Set([
+	"select",
+	"radio",
+	"toggle_button"
+]);
+const TEXTS$1 = /* @__PURE__ */ new Set([
+	"text",
+	"textarea",
+	"secret"
+]);
 function readDefinition(call) {
 	if (call.callee.type !== "Identifier" || !Object.hasOwn(DEFINERS, call.callee.name)) return;
 	const [options] = call.arguments;
@@ -1277,7 +1099,6 @@ function readGroups(owner) {
 	const node = "call" in owner ? owner.options : owner.node;
 	return objectElements(node && findProperty(node, "schema")).map((group) => ({
 		node: group,
-		label: findStringProperty(group, "label"),
 		fields: objectElements(findProperty(group, "fields")).map(readField)
 	}));
 }
@@ -1301,15 +1122,42 @@ function readAllFields(definition) {
 	readFields(definition).forEach(visit);
 	return fields;
 }
+function conditionFields(definition) {
+	const names = /* @__PURE__ */ new Set();
+	for (const field of readAllFields(definition)) {
+		const condition = findProperty(field.node, "if");
+		if (condition) walk(condition, (node) => {
+			const [operator, name] = node.type === "ArrayExpression" ? node.elements : [];
+			if (operator?.type === "Literal" && operator.value === "get" && name?.type === "Literal" && typeof name.value === "string") names.add(name.value.split(".")[0]);
+		});
+	}
+	return names;
+}
 function expectedDefiner(kind) {
 	return Object.keys(DEFINERS).find((definer) => DEFINERS[definer].kind === kind);
 }
+function fillValue(field, program, filename) {
+	if (field.type === "checkbox") return { value: field.as === "visibility" };
+	if (TEXTS$1.has(field.type ?? "")) return { value: "" };
+	if (field.type === "content_alignment") {
+		const axis = findStringProperty(field.node, "axis")?.value;
+		return { value: !axis || axis === "both" ? "center-center" : "center" };
+	}
+	if (!PICKERS.has(field.type ?? "")) return;
+	const property = findProperty(field.node, "options");
+	const declared = property?.type === "Identifier" ? resolveConstant(property.name, program, filename) : property;
+	let options = declared && unwrap(declared);
+	if (options?.type === "CallExpression") options = options.arguments[0];
+	const first = options?.type === "ArrayExpression" ? options.elements[0] : void 0;
+	const value = first?.type === "ObjectExpression" ? findProperty(first, "value") : first;
+	return value?.type === "Literal" ? { value: value.value } : void 0;
+}
 var description_default = defineRule({
 	meta: {
 		type: "suggestion",
 		docs: { description: "Require a studio.description on section and block definitions." },
 		schema: [],
-		messages: { description: "Studio shows studio.description in its section and block picker. Add one." }
+		messages: { description: "Studio shows studio.description in its section picker, and AI agents read it through Laioutr's MCP server. Add one." }
 	},
 	applies: (file) => file.side === "app",
 	create: ({ report }) => ({ CallExpression: (node) => {
@@ -1330,7 +1178,7 @@ var folder_default = defineRule({
 		docs: { description: "Keep defineSection() in app/sections/ and defineBlock() in app/blocks/, and every .vue there defined." },
 		schema: [],
 		messages: {
-			notDefined: "Laioutr registers every .vue in {{folder}}/ as a Studio {{kind}}, but this file has no {{definer}}(). Move it to components/.",
+			notDefined: "Laioutr loads every .vue in {{folder}}/ as a {{kind}}, but this file has no {{definer}}(), so frontend-core warns about it. Move it to components/.",
 			wrongFolder: "{{definer}}() belongs in app/{{folder}}/."
 		}
 	},
@@ -1391,118 +1239,100 @@ var name_default = defineRule({
 		});
 	} })
 });
-var prefix_default = defineRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Name sections Section*.vue and blocks Block*.vue." },
-		schema: [],
-		messages: { prefix: "Name {{kind}}s {{prefix}}*.vue, e.g. {{suggestion}}.vue." }
-	},
-	applies: (file) => file.kind === "section" || file.kind === "block",
-	create: ({ file, report }) => ({ CallExpression: (node) => {
-		const definition = readDefinition(node);
-		if (!definition) return;
-		const { kind, prefix } = DEFINERS[definition.definer];
-		const { name } = parse(file.path);
-		if (file.kind === kind && !name.startsWith(prefix)) report({
-			node: node.callee,
-			messageId: "prefix",
-			data: {
-				kind,
-				prefix,
-				suggestion: prefixName(name, prefix)
-			}
-		});
-	} })
-});
-const FALSE_WHEN_UNSET = /* @__PURE__ */ new Set([
-	"checkbox",
-	"select",
-	"radio",
-	"toggle_button"
+const TEXTS = /* @__PURE__ */ new Set([
+	"text",
+	"textarea",
+	"secret"
 ]);
-const EMPTY_WHEN_UNSET = /* @__PURE__ */ new Set(["text", "textarea"]);
 var fallbacks_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallow fallbacks for props that never arrive as undefined: unset picker fields arrive as false, unset text fields as ''." },
+		docs: { description: "Disallow ?? fallbacks that never apply, because frontend-core fills unset fields: pickers with their first option, checkboxes with false and text with ''." },
 		schema: [],
 		messages: {
-			checkbox: "An unset checkbox arrives as false, not undefined, so this {{check}} never sees a missing value. Name the field so that unchecked is the default.",
-			picker: "An unset {{type}} field arrives as false, not undefined, so this {{check}} never sees a missing value. Use || for a fallback.",
-			text: "Studio passes '' for an unset {{type}} field, so ?? never falls back. Use ||."
+			picker: "frontend-core fills an unset {{type}} field with its first option, {{fill}}, so this fallback never applies. Make {{fallback}} the first option if it should be the default.",
+			checkbox: "frontend-core fills an unset checkbox with false, so this fallback never applies. Name the field so that unchecked is the default.",
+			text: "frontend-core fills an unset {{type}} field with '', so ?? never falls back. Use || if an empty field should fall back."
 		}
 	},
 	applies: (file) => file.side === "app" && file.path.endsWith(".vue"),
 	create: ({ context, report, visitTemplate }) => {
-		const types = /* @__PURE__ */ new Map();
-		const propsVariable = findPropsVariable(context.sourceCode.ast);
-		const reads = [];
+		const program = context.sourceCode.ast;
+		const propsVariable = findPropsVariable(program);
+		const fills = /* @__PURE__ */ new Map();
+		const fallbacks = [];
 		const propOf = (node, template) => {
 			if (template && node.type === "Identifier") return node.name;
 			const props = node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier" && node.object.type === "Identifier" ? node.object.name : void 0;
 			return props && (props === propsVariable || template && props === "$props") && node.type === "MemberExpression" && node.property.type === "Identifier" ? node.property.name : void 0;
 		};
-		const collect = (template) => ({
-			LogicalExpression: (node) => {
-				const prop = node.operator === "??" ? propOf(node.left, template) : void 0;
-				if (prop) reads.push({
-					node,
-					prop,
-					check: "??"
-				});
-			},
-			BinaryExpression: (node) => {
-				if (node.operator !== "!==" && node.operator !== "===" && node.operator !== "!=" && node.operator !== "==") return;
-				for (const [side, other] of [[node.left, node.right], [node.right, node.left]]) {
-					const prop = propOf(side, template);
-					const value = other.type === "Identifier" && other.name === "undefined" ? "undefined" : other.type === "Literal" && other.value === null && !("regex" in other) ? "null" : other.type === "Literal" && other.value === false && node.operator === "!==" ? "false" : void 0;
-					if (prop && value) reads.push({
-						node,
-						prop,
-						check: `${node.operator} ${value}`
-					});
-				}
-			}
-		});
+		const collect = (template) => ({ LogicalExpression: (node) => {
+			const prop = node.operator === "??" ? propOf(node.left, template) : void 0;
+			if (prop && !isNullish(node.right)) fallbacks.push({
+				node,
+				prop
+			});
+		} });
 		visitTemplate(collect(true));
 		return {
 			...collect(false),
 			"CallExpression": (node) => {
 				const definition = readDefinition(node);
-				for (const { name, type, as } of definition ? readFields(definition) : []) if (name && type && !as) types.set(name.value, type);
+				for (const field of definition ? readFields(definition) : []) {
+					const fill = field.name && field.type && !field.as ? fillValue(field, program, context.filename) : void 0;
+					if (fill) fills.set(field.name.value, {
+						type: field.type,
+						value: fill.value
+					});
+				}
 			},
 			"Program:exit": () => {
-				for (const { node, prop, check } of reads) {
-					const type = types.get(prop);
-					if (type === "checkbox") report({
-						node,
-						messageId: "checkbox",
-						data: { check }
-					});
-					else if (type && FALSE_WHEN_UNSET.has(type)) report({
+				for (const { node, prop } of fallbacks) {
+					const field = fills.get(prop);
+					if (!field || node.right.type === "Literal" && node.right.value === field.value) continue;
+					const messageId = field.type === "checkbox" ? "checkbox" : TEXTS.has(field.type) ? "text" : "picker";
+					const fill = typeof field.value === "string" ? `'${field.value}'` : String(field.value);
+					report({
 						node,
-						messageId: "picker",
+						messageId,
 						data: {
-							type,
-							check
+							type: field.type,
+							fill,
+							fallback: context.sourceCode.getText(node.right)
 						}
 					});
-					else if (type && EMPTY_WHEN_UNSET.has(type) && check === "??") report({
-						node,
-						messageId: "text",
-						data: { type }
-					});
 				}
 			}
 		};
 	}
 });
 const PROP_READ = /\.props\??\.([A-Z_$][\w$]*)|\.props\??\.?\[\s*['"]([^'"]+)['"]\s*\]|['"]([^'"]+)['"]\s+in\s+[\w$.?]+\.props\b/gi;
-const readPropNames = cachedReader((text) => [...text.matchAll(PROP_READ)].map((match) => match[1] ?? match[2] ?? match[3]));
+const PROPS_ALIAS = /\b(?:const|let|var)\s+([\w$]+)\s*=\s*[\w$.?]+\.props\b(?!\s*(?:\?\.|[.[]))/g;
+const PROPS_DESTRUCTURING = /\{([^{}]*)\}\s*=\s*[\w$.?]+\.props\b(?!\s*(?:\?\.|[.[]))/g;
+const PROPS_SPREAD = /\.\.\.\s*[\w$.?]+\.props\b(?!\s*(?:\?\.|[.[]))/;
+const readSlotProps = cachedReader((text) => {
+	const names = [...text.matchAll(PROP_READ)].map((match) => match[1] ?? match[2] ?? match[3]);
+	let all = PROPS_SPREAD.test(text);
+	for (const [, alias] of text.matchAll(PROPS_ALIAS)) {
+		const name = alias.replaceAll("$", "\\$");
+		const reads = new RegExp(`\\b${name}\\??\\.([A-Z_$][\\w$]*)|\\b${name}\\??\\.?\\[\\s*['"]([^'"]+)['"]\\s*\\]`, "gi");
+		for (const match of text.matchAll(reads)) names.push(match[1] ?? match[2]);
+	}
+	for (const [, list] of text.matchAll(PROPS_DESTRUCTURING)) for (const entry of list.split(",").map((item) => item.trim()).filter(Boolean)) {
+		all ||= entry.startsWith("...");
+		names.push(entry.split(/[:=]/)[0].trim());
+	}
+	return {
+		names,
+		all
+	};
+});
 function slotProps(root) {
 	const folder = join(root, "src/runtime/app");
-	const names = /* @__PURE__ */ new Set();
+	const result = {
+		names: /* @__PURE__ */ new Set(),
+		all: false
+	};
 	let files;
 	try {
 		files = readdirSync(folder, {
@@ -1510,10 +1340,14 @@ function slotProps(root) {
 			encoding: "utf8"
 		}).filter((file) => /\.(?:vue|[cm]?[jt]s)$/.test(file));
 	} catch {
-		return names;
+		return result;
 	}
-	for (const file of files) readPropNames(join(folder, file))?.forEach((name) => names.add(name));
-	return names;
+	for (const file of files) {
+		const read = readSlotProps(join(folder, file));
+		read?.names.forEach((name) => result.names.add(name));
+		result.all ||= read?.all ?? false;
+	}
+	return result;
 }
 const NOT_READ = /* @__PURE__ */ new Set([
 	"info",
@@ -1533,6 +1367,7 @@ var unused_default = defineRule({
 		const used = /* @__PURE__ */ new Set();
 		const propsVariable = findPropsVariable(context.sourceCode.ast);
 		let hasProps = false;
+		let block = false;
 		let escapes = false;
 		const track = (node) => {
 			const names = usedProps(node);
@@ -1551,7 +1386,10 @@ var unused_default = defineRule({
 			"CallExpression": (node) => {
 				hasProps ||= isDefineProps(node);
 				const definition = readDefinition(node);
-				for (const { name, type, as } of definition ? readFields(definition) : []) if (name && !as && !NOT_READ.has(type ?? "")) fields.set(name.value, name.node);
+				if (!definition) return;
+				block ||= definition.definer === "defineBlock";
+				conditionFields(definition).forEach((name) => used.add(name));
+				for (const { name, type, as } of readFields(definition)) if (name && !as && !NOT_READ.has(type ?? "")) fields.set(name.value, name.node);
 			},
 			"Identifier": (node) => {
 				const declaration = node.parent.type === "VariableDeclarator" && node.parent.id === node;
@@ -1560,8 +1398,9 @@ var unused_default = defineRule({
 			"Program:exit": () => {
 				if (!hasProps || escapes) return;
 				const unused = [...fields].filter(([name]) => !used.has(name));
-				const readBySection = unused.length > 0 && file.kind === "block" ? slotProps(file.root) : /* @__PURE__ */ new Set();
-				for (const [name, node] of unused) if (!readBySection.has(name)) report({
+				const readBySection = unused.length > 0 && block ? slotProps(file.root) : void 0;
+				if (readBySection?.all) return;
+				for (const [name, node] of unused) if (!readBySection?.names.has(name)) report({
 					node,
 					messageId: "unused",
 					data: { name }
@@ -1570,59 +1409,32 @@ var unused_default = defineRule({
 		};
 	}
 });
-const CAMEL_CASE = /^[a-z][a-zA-Z0-9]*$/;
 var casing_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Require camelCase names for top-level schema fields, which become props." },
-		schema: [],
-		messages: { casing: "Name the field {{suggestion}}. It becomes a prop, and Vue only passes props by their camelCase name." }
-	},
-	applies: (file) => file.side === "app",
-	create: ({ report }) => ({ CallExpression: (node) => {
-		const definition = readDefinition(node);
-		for (const { name } of definition ? readFields(definition) : []) if (name && !CAMEL_CASE.test(name.value)) report({
-			node: name.node,
-			messageId: "casing",
-			data: { suggestion: camelCase(name.value) }
-		});
-	} })
-});
-const PANELS = [
-	"Content",
-	"Design",
-	"Rules"
-];
-var groups_default = defineRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Require schema groups to be Studio's panels, in the order Content, Design, Rules." },
+		docs: { description: "Disallow top-level schema field names that Vue renames or rejects as props." },
 		schema: [],
 		messages: {
-			panel: "Studio's schema has the panels Content, Design and Rules. Move these fields into one of them.",
-			order: "'{{label}}' goes before '{{previous}}': the panels are Content, Design, Rules."
+			hyphen: "Vue camelizes '{{name}}' to {{suggestion}}, so the prop never arrives under the field's name. Name the field {{suggestion}}.",
+			dollar: "Vue rejects prop names that start with $, so '{{name}}' never arrives as a prop. Pick another name."
 		}
 	},
 	applies: (file) => file.side === "app",
 	create: ({ report }) => ({ CallExpression: (node) => {
 		const definition = readDefinition(node);
-		let previous;
-		for (const { label } of definition ? readGroups(definition) : []) {
-			if (!label) continue;
-			if (!PANELS.includes(label.value)) report({
-				node: label.node,
-				messageId: "panel"
-			});
-			else if (previous && PANELS.indexOf(label.value) < PANELS.indexOf(previous)) report({
-				node: label.node,
-				messageId: "order",
-				data: {
-					label: label.value,
-					previous
-				}
-			});
-			else previous = label.value;
-		}
+		for (const { name } of definition ? readFields(definition) : []) if (name?.value.startsWith("$")) report({
+			node: name.node,
+			messageId: "dollar",
+			data: { name: name.value }
+		});
+		else if (name?.value.includes("-")) report({
+			node: name.node,
+			messageId: "hyphen",
+			data: {
+				name: name.value,
+				suggestion: camelCase(name.value)
+			}
+		});
 	} })
 });
 var required_default = defineRule({
@@ -1645,21 +1457,22 @@ var required_default = defineRule({
 	} })
 });
 const RESERVED = /* @__PURE__ */ new Set([
-	"style",
-	"class",
 	"key",
 	"ref",
-	"is",
-	"slot",
-	"refFor",
-	"refKey"
+	"ref_for",
+	"ref_key",
+	"class",
+	"style"
 ]);
 var reserved_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallow top-level schema field names that Vue swallows before they reach the component's props." },
+		docs: { description: "Disallow top-level schema field names that never reach the component's props." },
 		schema: [],
-		messages: { reserved: "Vue consumes '{{name}}' before it reaches the component, so this field never arrives as a prop. Pick another name, e.g. variant for a style selector." }
+		messages: {
+			reserved: "'{{name}}' never arrives as a prop: Vue handles key, ref, ref_for and ref_key itself, and merges class and style into the root element. Pick another name, e.g. variant for a style selector.",
+			slots: "frontend-core passes a section's blocks in its slots prop, so a field named slots is overwritten. Pick another name."
+		}
 	},
 	applies: (file) => file.side === "app",
 	create: ({ report }) => ({ CallExpression: (node) => {
@@ -1669,36 +1482,12 @@ var reserved_default = defineRule({
 			messageId: "reserved",
 			data: { name: name.value }
 		});
+		else if (name?.value === "slots" && definition?.definer === "defineSection") report({
+			node: name.node,
+			messageId: "slots"
+		});
 	} })
 });
-var id_default = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Disallow an id on the root element of a section or block, which frontend-core replaces with its own." },
-		schema: [],
-		messages: { rootId: "frontend-core gives the root element of every section and block its own id, so this one never reaches the page. Put it on an inner element." }
-	},
-	applies: (file) => file.side === "app" && file.path.endsWith(".vue"),
-	create: ({ context, report }) => {
-		let defined = false;
-		return {
-			"CallExpression": (node) => {
-				defined ||= readDefinition(node) !== void 0;
-			},
-			"Program:exit": () => {
-				const template = context.sourceCode.ast.templateBody;
-				if (!defined || !template) return;
-				for (const root of template.children) {
-					const id = root.type === "VElement" ? findAttribute(root, "id") : void 0;
-					if (id) report({
-						loc: id.loc,
-						messageId: "rootId"
-					});
-				}
-			}
-		};
-	}
-});
 const parseVueFile = cachedReader((text) => {
 	try {
 		return {
@@ -1713,6 +1502,7 @@ const parseVueFile = cachedReader((text) => {
 		return;
 	}
 });
+const OWN_ATTRS = /inheritAttrs\s*:\s*false/;
 var root_default = defineRule({
 	meta: {
 		type: "problem",
@@ -1733,7 +1523,7 @@ var root_default = defineRule({
 			"Program:exit": () => {
 				const program = context.sourceCode.ast;
 				const template = program.templateBody;
-				if (!defined || !template) return;
+				if (!defined || !template || OWN_ATTRS.test(context.sourceCode.text)) return;
 				const [root, second] = renderedRoots(template);
 				if (second) {
 					report({
@@ -1745,7 +1535,7 @@ var root_default = defineRule({
 				const file = root && importedComponent(program, context.filename, root.rawName);
 				const component = file ? parseVueFile(file) : void 0;
 				const componentTemplate = component?.ast.templateBody;
-				if (root && componentTemplate && renderedRoots(componentTemplate).length > 1 && !/inheritAttrs\s*:\s*false/.test(component.text)) report({
+				if (root && componentTemplate && renderedRoots(componentTemplate).length > 1 && !OWN_ATTRS.test(component.text)) report({
 					loc: root.startTag.loc,
 					messageId: "componentRoots",
 					data: { name: root.rawName }
@@ -1757,9 +1547,9 @@ var root_default = defineRule({
 var slots_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallow counting slot children, since Studio passes all blocks of a slot as one Fragment." },
+		docs: { description: "Disallow counting slot children, since frontend-core passes all blocks of a slot as one Fragment." },
 		schema: [],
-		messages: { length: "Studio passes all blocks of a slot as one Fragment, so this length is 1. Count the rendered blocks with a helper that flattens Fragments." }
+		messages: { length: "frontend-core passes all blocks of a slot as one Fragment, so this length is 1. Count the rendered blocks with a helper that flattens Fragments." }
 	},
 	applies: (file) => file.side === "app",
 	create: ({ report, visitTemplate }) => {
@@ -1797,7 +1587,7 @@ var bundle_default = defineRule({
 			} },
 			additionalProperties: false
 		}],
-		messages: { heavy: "Laioutr registers sections, blocks and plugins globally, so '{{name}}' lands in the chunk every page loads. Load it with import() or defineAsyncComponent() instead." }
+		messages: { heavy: "frontend-core imports every section and block up front, and plugins run on every page, so '{{name}}' lands in the chunk every page loads. Load it with import() or defineAsyncComponent() instead." }
 	},
 	applies: (file) => file.kind === "section" || file.kind === "block" || file.kind === "app-plugin",
 	create: ({ context, report }) => {
@@ -1812,6 +1602,21 @@ var bundle_default = defineRule({
 		} };
 	}
 });
+const readPackageFile = cachedReader((text) => {
+	const json = JSON.parse(text);
+	return {
+		name: json.name,
+		dependencies: new Set([
+			json.dependencies,
+			json.devDependencies,
+			json.peerDependencies,
+			json.optionalDependencies
+		].flatMap((deps) => Object.keys(deps ?? {})))
+	};
+});
+function readPackage(root) {
+	return readPackageFile(join(root, "package.json"));
+}
 function isRuntimeConfig(node, variables) {
 	if (node.type === "CallExpression") return node.callee.type === "Identifier" && node.callee.name === "useRuntimeConfig";
 	if (node.type === "Identifier") return variables.has(node.name);
@@ -1856,7 +1661,7 @@ var public_default = defineRule({
 		type: "problem",
 		docs: { description: "Disallow copying module options into the public runtime config, which reaches the browser." },
 		schema: [],
-		messages: { options: "runtimeConfig.public reaches the browser, and with it every token or secret among the module options. Copy only the options meant to be public." }
+		messages: { options: "runtimeConfig.public reaches the browser, and with it every token or secret among the module options. Copy only the options meant to be public, e.g. options.storefrontUrl." }
 	},
 	applies: (file) => file.side === "build",
 	create: ({ report }) => ({ AssignmentExpression: (node) => {
@@ -1867,30 +1672,13 @@ var public_default = defineRule({
 		walk(node.right, (child) => {
 			if (child.type !== "Identifier" || child.name !== options || !isReference(child)) return;
 			const { parent } = child;
-			if (!(parent.type === "MemberExpression" && parent.object === child && nameOf(parent) === "public")) report({
+			if (parent.type !== "MemberExpression" || parent.object !== child) report({
 				node: child,
 				messageId: "options"
 			});
 		});
 	} })
 });
-var folders_default = defineRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Require runtime files to live in the folders of the Laioutr app layout." },
-		schema: [],
-		messages: { unknown: "larrylint doesn't know {{folder}}, so no rule checks what's in it. Move the file into one of the folders of the Laioutr app layout." }
-	},
-	applies: (file) => (file.side === "app" || file.side === "server") && file.kind === "other",
-	create: ({ file, report }) => ({ Program: () => {
-		const [side, folder] = file.path.slice(file.path.indexOf("/runtime/") + 9).split("/");
-		report({
-			loc: FILE_START,
-			messageId: "unknown",
-			data: { folder: `${side}/${folder}/` }
-		});
-	} })
-});
 const LABELS = {
 	"section": "section",
 	"block": "block",
@@ -1925,13 +1713,7 @@ const ABOVE_SERVER_UTILS = /* @__PURE__ */ new Set([
 	"orchestr-file",
 	"media-library"
 ]);
-const BUILDER_USERS = /* @__PURE__ */ new Set([
-	"handler",
-	"orchestr-file",
-	"middleware",
-	"media-library"
-]);
-function findViolation(importer, target, typeOnly, sharedDomains) {
+function findViolation(importer, target, typeOnly) {
 	if (importer.side === "app" && target.side === "server") return { messageId: "appImportsServer" };
 	if (importer.side === "server" && target.side === "app") return { messageId: "serverImportsApp" };
 	if (importer.side === "shared" && (target.side === "app" || target.side === "server")) return {
@@ -1942,25 +1724,10 @@ function findViolation(importer, target, typeOnly, sharedDomains) {
 	if (target.kind === "handler") return { messageId: "handlerImported" };
 	if (typeOnly) return;
 	if (target.kind === "client" && importer.kind === "handler") return { messageId: "clientInHandler" };
-	if (target.kind === "client" && importer.kind === "server-util") return { messageId: "clientInUtil" };
-	if (target.kind === "middleware" && !BUILDER_USERS.has(importer.kind)) return { messageId: "middlewareImported" };
 	if (importer.kind === "server-util" && ABOVE_SERVER_UTILS.has(target.kind)) return {
 		messageId: "serverUtilImportsUp",
 		data: { kind: LABELS[target.kind] }
 	};
-	const from = domainOf(importer);
-	const to = domainOf(target);
-	if (from && to && from !== to && !sharedDomains.includes(to)) return {
-		messageId: "crossDomain",
-		data: {
-			from,
-			to
-		}
-	};
-	if (importer.kind === "server-util" && !from && to && !sharedDomains.includes(to)) return {
-		messageId: "sharedImportsDomain",
-		data: { to }
-	};
 	if (importer.kind === "app-util" && ABOVE_APP_UTILS.has(target.kind)) return {
 		messageId: "appUtilImportsUp",
 		data: { kind: LABELS[target.kind] }
@@ -1974,15 +1741,8 @@ function findViolation(importer, target, typeOnly, sharedDomains) {
 var layers_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Enforce the layers of a Laioutr app: app, server and shared code, orchestr handlers, middleware, clients, utils and domains." },
-		schema: [{
-			type: "object",
-			properties: { sharedDomains: {
-				type: "array",
-				items: { type: "string" }
-			} },
-			additionalProperties: false
-		}],
+		docs: { description: "Enforce the layers of a Laioutr app: app, server and shared code, build-time code, orchestr handlers, API clients and utils." },
+		schema: [],
 		messages: {
 			appImportsServer: "App code can't import server code. Move what both sides need to src/runtime/shared/.",
 			serverImportsApp: "Server code can't import app code. Move what both sides need to src/runtime/shared/.",
@@ -1990,11 +1750,7 @@ var layers_default = defineRule({
 			runtimeImportsBuild: "Runtime code can't import build-time code from src/; it isn't part of the runtime bundle. Type imports are fine.",
 			handlerImported: "Orchestr handlers are registered by laioutr, never imported. Move the shared code to server/utils/.",
 			clientInHandler: "Handlers read API clients from the orchestr context. server/client/ only holds clients; move constants and helpers to server/utils/.",
-			clientInUtil: "Server utils get API clients passed in. server/client/ only holds clients; move constants and helpers to server/utils/.",
-			middlewareImported: "Only orchestr handlers and media libraries import middleware. Move helpers like this to server/utils/.",
 			serverUtilImportsUp: "Server utils are the bottom layer and can't import {{kind}} code.",
-			crossDomain: "The {{from}} domain can't import from the {{to}} domain. Move the shared code out of the {{to}} folders into server/utils/, or add '{{to}}' to sharedDomains.",
-			sharedImportsDomain: "Shared server utils can't import from the {{to}} domain, or every domain that uses them depends on {{to}}. Move the shared code out of the {{to}} folders, or add '{{to}}' to sharedDomains.",
 			appUtilImportsUp: "App utils are the bottom layer and can't import a {{kind}}. Type imports are fine.",
 			composableImportsUp: "Composables can't import a {{kind}}. Type imports are fine.",
 			componentImportsSection: "Components can't import sections; sections compose components.",
@@ -2003,7 +1759,6 @@ var layers_default = defineRule({
 	},
 	applies: (file) => file.side === "app" || file.side === "server" || file.side === "shared",
 	create: ({ context, file: importer, report }) => {
-		const { sharedDomains = [] } = context.options[0] ?? {};
 		const checkImport = (node, source, typeOnly) => {
 			if (typeof source !== "string") return;
 			if (source.startsWith("node:")) {
@@ -2016,7 +1771,7 @@ var layers_default = defineRule({
 			}
 			const path = resolveImport(context.filename, source);
 			const target = path ? classify(path) : void 0;
-			const violation = target && findViolation(importer, target, typeOnly, sharedDomains);
+			const violation = target && findViolation(importer, target, typeOnly);
 			if (violation) report({
 				node,
 				...violation
@@ -2045,55 +1800,40 @@ const plugin = {
 	},
 	rules: {
 		"layers": layers_default,
-		"known-folders": folders_default,
 		"heavy-imports": bundle_default,
 		"config-keys": keys_default,
 		"public-config": public_default,
 		"orchestr-files": files_default$1,
 		"orchestr-cookies": cookies_default,
-		"handler-domains": domains_default,
 		"handler-exports": exports_default,
-		"handler-context": context_default,
-		"resolver-undefined": returns_default,
-		"resolver-passthrough": passthrough_default,
-		"action-errors": errors_default,
 		"middleware-files": files_default,
 		"initware-throws": throws_default,
-		"orchestr-meta": meta_default,
 		"token-namespaces": namespaces_default,
-		"token-nullable": nullable_default,
 		"definition-folder": folder_default,
-		"definition-prefix": prefix_default,
 		"component-name": name_default,
 		"definition-description": description_default,
-		"root-id": id_default,
 		"single-root": root_default,
 		"slot-children": slots_default,
 		"reserved-field-names": reserved_default,
 		"field-name-case": casing_default,
 		"required-fields": required_default,
-		"schema-groups": groups_default,
 		"unused-fields": unused_default,
 		"dead-fallbacks": fallbacks_default,
 		"button-type": button_default,
-		"ui-kit-tags": tags_default,
 		"mutation-errors": mutations_default,
-		"orchestr-store": store_default,
 		"resolve-result": resolve_default,
 		"hand-built-links": paths_default,
-		"internal-anchors": anchors_default,
-		"money": money_default
+		"internal-anchors": anchors_default
 	}
 };
 async function larrylint(options = {}) {
-	const { sharedDomains, heavyPackages } = await loadLarrylintConfig(options.cwd);
+	const { heavyPackages } = await loadLarrylintConfig(options.cwd);
 	return [{
 		name: "larrylint",
 		files: ["**/src/**/*.{ts,mts,cts,js,mjs,cjs,vue}"],
 		plugins: { larrylint: plugin },
 		rules: {
 			...Object.fromEntries(Object.keys(plugin.rules).map((id) => [`larrylint/${id}`, "error"])),
-			"larrylint/layers": ["error", { sharedDomains }],
 			"larrylint/heavy-imports": ["error", { packages: heavyPackages }]
 		}
 	}];