larrylint 0.1.0 → 0.1.1

package/dist/_chunks/preset.mjs

@@ -1,8 +1,10 @@
 import { name, version } from "./package.mjs";
 import process from "node:process";
 import { loadConfig } from "c12";
-import { readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, normalize, resolve } from "pathe";
+import { basename, 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";
 function defineLarrylintConfig(config) {
 	return config;
 }
@@ -15,56 +17,42 @@ async function loadLarrylintConfig(cwd = process.cwd()) {
 		globalRc: false,
 		dotenv: false
 	});
-	return { sharedDomains: config.sharedDomains ?? [] };
-}
-const BASELINE_FILE = "larrylint-baseline.json";
-const cache = /* @__PURE__ */ new Map();
-function readBaseline(root) {
-	const file = join(root, BASELINE_FILE);
-	let mtimeMs;
-	try {
-		mtimeMs = statSync(file).mtimeMs;
-	} catch {
-		return {};
-	}
-	const cached = cache.get(file);
-	if (cached?.mtimeMs === mtimeMs) return cached.baseline;
-	const baseline = JSON.parse(readFileSync(file, "utf8"));
-	cache.set(file, {
-		mtimeMs,
-		baseline
-	});
-	return baseline;
-}
-function writeBaseline(root, baseline) {
-	const file = join(root, BASELINE_FILE);
-	const files = Object.keys(baseline).sort();
-	if (files.length === 0) {
-		rmSync(file, { force: true });
-		return;
-	}
-	const sorted = {};
-	for (const path of files) sorted[path] = Object.fromEntries(Object.entries(baseline[path]).sort(([a], [b]) => a.localeCompare(b)));
-	writeFileSync(file, `${JSON.stringify(sorted, null, 2)}\n`);
-}
-function countViolations(baseline) {
-	return Object.values(baseline).flatMap((rules) => Object.values(rules)).reduce((sum, count) => sum + count, 0);
-}
-function createReporter(context, file) {
-	const reports = [];
 	return {
-		report: (descriptor) => {
-			reports.push(descriptor);
-		},
-		flush: () => {
-			const settings = context.settings.larrylint;
-			const allowed = file && settings?.baseline !== false ? readBaseline(file.root)[file.path]?.[context.id] ?? 0 : 0;
-			if (reports.length > allowed) for (const descriptor of reports) context.report(descriptor);
-			reports.length = 0;
-		}
+		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;
+	};
+}
 function isDirectory(path) {
 	let result = directories.get(path);
 	if (result === void 0) {
@@ -82,16 +70,30 @@ function resolveImport(importer, source) {
 	const target = resolve(dirname(importer), source.split("?")[0]);
 	return isDirectory(target) ? `${target}/index` : target;
 }
-const HANDLER_FILE = /\.(?:query|resolver|link|action|template|page-index)(?:\.[cm]?[jt]s)?$/;
+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 TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
 const APP_FOLDERS = {
-	sections: "section",
-	blocks: "block",
-	components: "component",
-	composables: "composable",
-	utils: "app-util",
-	plugins: "app-plugin",
-	overrides: "override"
+	"sections": "section",
+	"blocks": "block",
+	"components": "component",
+	"composables": "composable",
+	"utils": "app-util",
+	"plugins": "app-plugin",
+	"overrides": "override",
+	"theme": "theme",
+	"shared-fields": "shared-field"
 };
 const SERVER_FOLDERS = {
 	"middleware": "middleware",
@@ -148,9 +150,11 @@ function classifyRuntime(parts) {
 			side,
 			kind: "orchestr-plugin"
 		};
+		const handler = HANDLER_FILE.exec(parts.at(-1))?.[1];
 		return {
 			side,
-			kind: HANDLER_FILE.test(parts.at(-1)) ? "handler" : "orchestr-file",
+			kind: handler ? "handler" : "orchestr-file",
+			handler,
 			domain: nested ? rest[0] : void 0
 		};
 	}
@@ -161,14 +165,590 @@ function classifyRuntime(parts) {
 		domain: kind === "server-util" && nested ? rest[0] : void 0
 	};
 }
+const BASELINE_FILE = "larrylint-baseline.json";
+const readBaselineFile = cachedReader((text) => JSON.parse(text));
+function readBaseline(root) {
+	return readBaselineFile(join(root, "larrylint-baseline.json")) ?? {};
+}
+function writeBaseline(root, baseline) {
+	const file = join(root, BASELINE_FILE);
+	const files = Object.keys(baseline).sort();
+	if (files.length === 0) {
+		rmSync(file, { force: true });
+		return;
+	}
+	const sorted = {};
+	for (const path of files) sorted[path] = Object.fromEntries(Object.entries(baseline[path]).sort(([a], [b]) => a.localeCompare(b)));
+	writeFileSync(file, `${JSON.stringify(sorted, null, 2)}\n`);
+}
+function countViolations(baseline) {
+	return Object.values(baseline).flatMap((rules) => Object.values(rules)).reduce((sum, count) => sum + count, 0);
+}
+function applyBaseline(cwd, results) {
+	const baseline = readBaseline(cwd);
+	const violations = {};
+	let baselined = 0;
+	let improved = 0;
+	const filtered = results.map((result) => {
+		const path = relative(cwd, result.filePath);
+		const perRule = {};
+		const relevant = result.messages.filter((message) => message.fatal || message.ruleId?.startsWith("larrylint/"));
+		for (const { ruleId } of relevant) if (ruleId) perRule[ruleId] = (perRule[ruleId] ?? 0) + 1;
+		if (Object.keys(perRule).length > 0) violations[path] = perRule;
+		const messages = relevant.filter(({ ruleId }) => !ruleId || perRule[ruleId] > (baseline[path]?.[ruleId] ?? 0));
+		baselined += relevant.length - messages.length;
+		return {
+			...result,
+			messages,
+			errorCount: messages.filter((message) => message.severity === 2).length,
+			fatalErrorCount: messages.filter((message) => message.fatal).length,
+			warningCount: messages.filter((message) => message.severity === 1).length,
+			fixableErrorCount: messages.filter((message) => message.severity === 2 && message.fix).length,
+			fixableWarningCount: messages.filter((message) => message.severity === 1 && message.fix).length
+		};
+	});
+	for (const [path, rules] of Object.entries(baseline)) for (const [rule, allowed] of Object.entries(rules)) if ((violations[path]?.[rule] ?? 0) < allowed) improved++;
+	return {
+		results: filtered,
+		violations,
+		baselined,
+		improved
+	};
+}
+function defineRule(rule) {
+	return {
+		meta: rule.meta,
+		create(context) {
+			const file = classify(context.filename);
+			if (!file || file.test || !rule.applies(file)) return {};
+			const reports = [];
+			let template;
+			const { "Program:exit": programExit, ...script } = rule.create({
+				context,
+				file,
+				report: (descriptor) => {
+					reports.push(descriptor);
+				},
+				visitTemplate: (listener) => {
+					template = listener;
+				}
+			});
+			const program = context.sourceCode.ast;
+			const finish = () => {
+				programExit?.(program);
+				const allowed = context.settings.larrylint?.baseline === false ? 0 : readBaseline(file.root)[file.path]?.[context.id] ?? 0;
+				if (reports.length > allowed) for (const descriptor of reports) context.report(descriptor);
+			};
+			const services = context.sourceCode.parserServices;
+			if (template && program.templateBody && services?.defineTemplateBodyVisitor) {
+				const { "VElement:exit": elementExit, ...listener } = template;
+				return services.defineTemplateBodyVisitor({
+					...listener,
+					"VElement:exit": (node) => {
+						elementExit?.(node);
+						if (node === program.templateBody) finish();
+					}
+				}, script);
+			}
+			return {
+				...script,
+				"Program:exit": finish
+			};
+		}
+	};
+}
+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",
+	"TSAsExpression",
+	"TSSatisfiesExpression"
+]);
+function nameOf(node) {
+	if (node.type === "Identifier") return node.name;
+	return node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier" ? node.property.name : void 0;
+}
+function chainRoot(node) {
+	let current = node;
+	for (;;) if (current.type === "CallExpression") current = current.callee;
+	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 [];
+	const property = !node.computed && node.property.type === "Identifier" ? node.property.name : "*";
+	return [...memberPath(node.object), property];
+}
+function unwrap(node) {
+	let current = node;
+	while (WRAPPERS.has(current.type)) current = current.expression;
+	return current;
+}
+function followPromise(promise) {
+	let end = promise;
+	for (;;) {
+		let member = end.parent;
+		while (member && WRAPPERS.has(member.type)) {
+			end = member;
+			member = end.parent;
+		}
+		const call = member?.parent;
+		if (member?.type !== "MemberExpression" || member.object !== end || member.property.type !== "Identifier" || call?.type !== "CallExpression" || call.callee !== member) return {
+			end,
+			handled: false
+		};
+		const method = member.property.name;
+		if (method === "catch" || method === "then" && call.arguments.length > 1) return {
+			end: call,
+			handled: true
+		};
+		if (method !== "then" && method !== "finally") return {
+			end,
+			handled: false
+		};
+		end = call;
+	}
+}
+const SKIPPED = /* @__PURE__ */ new Set([
+	"parent",
+	"loc",
+	"range",
+	"tokens",
+	"comments"
+]);
+function children(node) {
+	const result = [];
+	for (const [key, value] of Object.entries(node)) {
+		if (SKIPPED.has(key)) continue;
+		for (const child of Array.isArray(value) ? value : [value]) if (typeof child === "object" && child !== null && typeof child.type === "string") result.push(child);
+	}
+	return result;
+}
+function walk(node, enter) {
+	if (enter(node) === false) return;
+	for (const child of children(node)) walk(child, enter);
+}
+function isFunction(node) {
+	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function walkBody(fn, enter) {
+	const visit = (node, caught) => {
+		enter(node, caught);
+		if (isFunction(node)) return;
+		if (node.type === "TryStatement") {
+			visit(node.block, caught || Boolean(node.handler));
+			if (node.handler) visit(node.handler, caught);
+			if (node.finalizer) visit(node.finalizer, caught);
+			return;
+		}
+		for (const child of children(node)) visit(child, caught);
+	};
+	if (fn.body.type === "BlockStatement") for (const child of children(fn.body)) visit(child, false);
+	else visit(fn.body, false);
+}
+function uncaughtThrow(fn) {
+	let found;
+	walkBody(fn, (node, caught) => {
+		if (!found && !caught && node.type === "ThrowStatement") found = node;
+	});
+	return found;
+}
+function isCaught(node) {
+	let child = node;
+	for (let parent = node.parent; parent; parent = parent.parent) {
+		if (isFunction(parent)) return false;
+		if (parent.type === "TryStatement" && parent.block === child && parent.handler) return true;
+		child = parent;
+	}
+	return false;
+}
+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()." }
+	},
+	applies: (file) => file.side === "app",
+	create: ({ report, visitTemplate }) => {
+		const check = (call) => {
+			if (nameOf(call.callee) !== "mutateAsync") return;
+			const { end, handled } = followPromise(call);
+			const { parent } = end;
+			if (handled || !parent) return;
+			const awaited = parent.type === "AwaitExpression";
+			const dropped = parent.type === "ExpressionStatement" || parent.type === "UnaryExpression" && parent.operator === "void";
+			if (!awaited && !dropped || awaited && isCaught(parent)) return;
+			report({
+				node: call.callee.type === "MemberExpression" ? call.callee.property : call.callee,
+				messageId: "unhandled"
+			});
+		};
+		visitTemplate({ CallExpression: check });
+		return { CallExpression: check };
+	}
+});
+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"
+		});
+	} })
+});
+function isInternalPath(path) {
+	return path?.startsWith("/") === true && !path.startsWith("//") && !path.startsWith("/api/");
+}
+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;
+	}
+}
+const parseFile = cachedReader((text) => {
+	try {
+		return parse$1(text, {
+			range: true,
+			loc: true
+		});
+	} catch {
+		return;
+	}
+});
+function isTypeOnly(node) {
+	const { importKind, exportKind } = node;
+	if (importKind === "type" || exportKind === "type") return true;
+	return node.type === "ImportDeclaration" && node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.importKind === "type");
+}
+function findImport(program, local) {
+	for (const statement of program.body) {
+		const specifier = statement.type === "ImportDeclaration" ? statement.specifiers.find((item) => item.local.name === local) : void 0;
+		if (!specifier || statement.type !== "ImportDeclaration" || typeof statement.source.value !== "string") continue;
+		const source = statement.source.value;
+		if (specifier.type === "ImportSpecifier") return {
+			source,
+			name: specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value)
+		};
+		return {
+			source,
+			name: specifier.type === "ImportDefaultSpecifier" ? "default" : "*"
+		};
+	}
+}
+function findFunction(statements, name) {
+	for (const statement of statements) {
+		const declaration = statement.type === "ExportNamedDeclaration" && statement.declaration ? statement.declaration : statement;
+		if (declaration.type === "FunctionDeclaration" && declaration.id?.name === name) return declaration;
+		if (declaration.type === "VariableDeclaration") {
+			for (const declarator of declaration.declarations) if (declarator.id.type === "Identifier" && declarator.id.name === name && declarator.init && isFunction(declarator.init)) return declarator.init;
+		}
+	}
+}
+function findExport(program, name) {
+	for (const statement of program.body) {
+		if (statement.type === "ExportDefaultDeclaration" && name === "default") {
+			const { declaration } = statement;
+			return isFunction(declaration) ? declaration : declaration.type === "Identifier" ? findFunction(program.body, declaration.name) : void 0;
+		}
+		if (statement.type !== "ExportNamedDeclaration") continue;
+		const declared = statement.declaration && findFunction([statement.declaration], name);
+		if (declared) return declared;
+		const specifier = statement.source ? void 0 : statement.specifiers.find((item) => (item.exported.type === "Identifier" ? item.exported.name : item.exported.value) === name);
+		if (specifier?.local.type === "Identifier") return findFunction(program.body, specifier.local.name);
+	}
+}
+function resolveCallee(call, program, filename) {
+	if (call.callee.type !== "Identifier") return;
+	const { name } = call.callee;
+	const local = findFunction(program.body, name);
+	if (local) return {
+		node: local,
+		file: filename
+	};
+	const imported = findImport(program, name);
+	const file = imported && imported.name !== "*" ? resolveModule(filename, imported.source) : void 0;
+	const module = file ? parseFile(file) : void 0;
+	const node = module && imported && findExport(module, imported.name);
+	return file && node ? {
+		node,
+		file
+	} : void 0;
+}
+function findPropsVariable(program) {
+	for (const statement of program.body) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations) if (declarator.id.type === "Identifier" && declarator.init && isDefineProps(declarator.init)) return declarator.id.name;
+	}
+}
+function isDefineProps(node) {
+	if (node.type !== "CallExpression" || node.callee.type !== "Identifier") return false;
+	const [first] = node.arguments;
+	return node.callee.name === "defineProps" || node.callee.name === "withDefaults" && first !== void 0 && isDefineProps(first);
+}
+function usedProps(node) {
+	const { parent } = node;
+	if (parent.type === "MemberExpression" && parent.object === node) {
+		if (!parent.computed && parent.property.type === "Identifier") return [parent.property.name];
+		return parent.property.type === "Literal" && typeof parent.property.value === "string" ? [parent.property.value] : void 0;
+	}
+	if (parent.type === "VariableDeclarator" && parent.init === node && parent.id.type === "ObjectPattern") {
+		const names = parent.id.properties.map((property) => property.type === "Property" && property.key.type === "Identifier" && !property.computed ? property.key.name : void 0);
+		return names.every((name) => name !== void 0) ? names : void 0;
+	}
+}
+function findHolder(node) {
+	let value = node;
+	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;
+	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
+	} : 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;
+}
+var resolve_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow testing the result of linkResolver.resolve(), which is never empty." },
+		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." }
+	},
+	applies: (file) => file.side === "app",
+	create: ({ report, visitTemplate }) => {
+		const resolveNames = /* @__PURE__ */ new Set();
+		const calls = [];
+		const scriptIdentifiers = [];
+		const templateIdentifiers = [];
+		visitTemplate({ Identifier: (node) => {
+			templateIdentifiers.push(node);
+		} });
+		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);
+			},
+			"CallExpression": (node) => {
+				calls.push(node);
+			},
+			"Identifier": (node) => {
+				scriptIdentifiers.push(node);
+			},
+			"Program:exit": () => {
+				const holders = /* @__PURE__ */ new Map();
+				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 (isTested(call)) report({
+						node: call,
+						messageId: "tested"
+					});
+					const holder = findHolder(call);
+					if (holder) holders.set(holder.name, holder.computed);
+				}
+				const check = (identifier, template) => {
+					const computed = holders.get(identifier.name);
+					const { parent } = identifier;
+					if (computed === void 0 || !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({
+						node: value,
+						messageId: "tested"
+					});
+				};
+				scriptIdentifiers.forEach((identifier) => check(identifier, false));
+				templateIdentifiers.forEach((identifier) => check(identifier, true));
+			}
+		};
+	}
+});
 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 button = {
+var button_default = defineRule({
 	meta: {
 		type: "problem",
 		fixable: "code",
@@ -176,46 +756,183 @@ const button = {
 		schema: [],
 		messages: { buttonType: "l-button ignores type and always renders its button-type prop, which defaults to \"button\". Use button-type." }
 	},
-	create(context) {
-		const services = context.sourceCode.parserServices;
-		if (!services?.defineTemplateBodyVisitor) return {};
-		const file = classify(context.filename);
-		if (file?.test) return {};
-		const reporter = createReporter(context, file);
+	applies: (file) => file.path.endsWith(".vue"),
+	create: ({ report, visitTemplate }) => {
 		const buttons = /* @__PURE__ */ new Set(["LButton", "l-button"]);
-		return services.defineTemplateBodyVisitor({
-			"VElement": (node) => {
-				if (!buttons.has(node.rawName)) return;
-				for (const attribute of node.startTag.attributes) {
-					if (!attribute.directive && attribute.key.rawName === "type") {
-						const key = attribute.key;
-						reporter.report({
-							loc: key.loc,
-							messageId: "buttonType",
-							fix: (fixer) => fixer.replaceTextRange(key.range, "button-type")
-						});
-					}
-					const argument = attribute.directive ? attribute.key.argument : null;
-					if (attribute.directive && attribute.key.name.name === "bind" && argument?.type === "VIdentifier" && argument.rawName === "type") reporter.report({
-						loc: argument.loc,
+		visitTemplate({ VElement: (node) => {
+			if (!buttons.has(node.rawName)) return;
+			for (const attribute of node.startTag.attributes) {
+				if (!attribute.directive && attribute.key.rawName === "type") {
+					const key = attribute.key;
+					report({
+						loc: key.loc,
 						messageId: "buttonType",
-						fix: (fixer) => fixer.replaceTextRange(argument.range, "button-type")
+						fix: (fixer) => fixer.replaceTextRange(key.range, "button-type")
 					});
 				}
-			},
-			"VElement:exit": (node) => {
-				if (node.parent.type === "VDocumentFragment") reporter.flush();
+				const argument = attribute.directive ? attribute.key.argument : null;
+				if (attribute.directive && attribute.key.name.name === "bind" && argument?.type === "VIdentifier" && argument.rawName === "type") report({
+					loc: argument.loc,
+					messageId: "buttonType",
+					fix: (fixer) => fixer.replaceTextRange(argument.range, "button-type")
+				});
 			}
-		}, { ImportDeclaration: (node) => {
+		} });
+		return { ImportDeclaration: (node) => {
 			if (typeof node.source.value !== "string" || !UI_KIT_BUTTON.test(node.source.value)) return;
 			for (const specifier of node.specifiers) if (specifier.type === "ImportDefaultSpecifier") {
 				const kebab = kebabCase(specifier.local.name);
 				buttons.add(specifier.local.name);
 				if (kebab.includes("-")) buttons.add(kebab);
 			}
+		} };
+	}
+});
+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;
+	const method = callee.property.name;
+	if (method !== "extendRequest" && (method !== "use" || !/^define[A-Z]/.test(chainRoot(callee.object)?.name ?? ""))) return;
+	const [callback] = call.arguments;
+	return callback?.type === "ArrowFunctionExpression" || callback?.type === "FunctionExpression" ? {
+		method,
+		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;
+}
+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." },
+		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."
+		}
+	},
+	applies: (file) => file.side === "server",
+	create: ({ file, report }) => ({ CallExpression: (node) => {
+		const effect = responseEffect(node);
+		if (effect && (file.kind === "handler" || inMiddleware(node))) report({
+			node,
+			messageId: effect
+		});
+	} })
+});
 const FILE_START = {
 	start: {
 		line: 1,
@@ -225,21 +942,314 @@ const FILE_START = {
 		line: 1,
 		column: 0
 	}
-};
-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;
+};
+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." },
+		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/." }
+	},
+	applies: (file) => file.kind === "orchestr-file",
+	create: ({ report }) => ({ Program: () => {
+		report({
+			loc: FILE_START,
+			messageId: "notAHandler"
+		});
+	} })
+});
+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." },
+		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."
+		}
+	},
+	applies: (file) => file.kind === "handler",
+	create: ({ report }) => {
+		let hasDefault = false;
+		return {
+			"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"
+				});
+			},
+			"Program:exit": () => {
+				if (!hasDefault) report({
+					loc: FILE_START,
+					messageId: "missingDefault"
+				});
+			}
+		};
+	}
+});
+const MIDDLEWARE = /* @__PURE__ */ new Set([
+	"defineOrchestr",
+	"defineEventHandler",
+	"eventHandler",
+	"defineRequestMiddleware",
+	"fromNodeMiddleware"
+]);
+var files_default = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Keep server/middleware/ to orchestr and Nitro middleware." },
+		schema: [],
+		messages: { helper: "server/middleware/ holds orchestr and Nitro middleware. Move helpers like this to server/utils/." }
+	},
+	applies: (file) => file.kind === "middleware",
+	create: ({ report }) => {
+		let middleware = false;
+		return {
+			"Identifier": (node) => {
+				middleware ||= MIDDLEWARE.has(node.name);
+			},
+			"CallExpression": (node) => {
+				middleware ||= readMiddleware(node) !== void 0;
+			},
+			"Program:exit": () => {
+				if (!middleware) report({
+					loc: FILE_START,
+					messageId: "helper"
+				});
+			}
+		};
+	}
+});
+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",
+		docs: { description: "Disallow throwing in extendRequest(), which runs before every query, so a throw takes down every page." },
+		schema: [],
+		messages: {
+			throws: "extendRequest() runs before every query, so this throw takes down every page. Return a stand-in instead, e.g. a client that fails only when it's used.",
+			throwsInCall: "{{name}}() can throw ({{location}}). extendRequest() runs before every query, so that takes down every page. Catch it here or return a stand-in."
+		}
+	},
+	applies: (file) => file.side === "server",
+	create: ({ context, report }) => ({ CallExpression: (node) => {
+		const middleware = readMiddleware(node);
+		if (middleware?.method !== "extendRequest") return;
+		walkBody(middleware.callback, (child, caught) => {
+			if (caught) return;
+			if (child.type === "ThrowStatement") {
+				report({
+					node: child,
+					messageId: "throws"
+				});
+				return;
+			}
+			const callee = child.type === "CallExpression" ? resolveCallee(child, context.sourceCode.ast, context.filename) : void 0;
+			const thrown = callee && uncaughtThrow(callee.node);
+			if (callee && thrown && child.type === "CallExpression") {
+				const line = thrown.loc?.start.line;
+				const location = callee.file === context.filename ? `line ${line}` : `${relative(dirname(context.filename), callee.file)}:${line}`;
+				report({
+					node: child.callee,
+					messageId: "throwsInCall",
+					data: {
+						name: child.callee.name,
+						location
+					}
+				});
+			}
+		});
+	} })
+});
+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();
+function canonicalNamespaces(root) {
+	let namespaces = cache.get(root);
+	if (!namespaces) {
+		const frontendCore = findPackage(root, "@laioutr-core/frontend-core");
+		const folder = findPackage(root, PACKAGE) ?? (frontendCore && findPackage(frontendCore, PACKAGE));
+		if (!folder) throw new Error(`larrylint can't find ${PACKAGE} from ${root}, which it reads the canonical token namespaces from. Install the app's dependencies first.`);
+		namespaces = /* @__PURE__ */ new Set();
+		for (const file of readdirSync(join(folder, "dist"), {
+			recursive: true,
+			encoding: "utf8"
+		}).filter((file) => /\.[cm]?js$/.test(file))) for (const [, namespace] of readFileSync(join(folder, "dist", file), "utf8").matchAll(TOKEN_ID)) namespaces.add(namespace);
+		cache.set(root, namespaces);
+	}
+	return namespaces;
 }
-function findStringProperty(object, key) {
-	const value = findProperty(object, key);
-	return value?.type === "Literal" && typeof value.value === "string" ? {
-		value: value.value,
-		node: value
-	} : void 0;
+var namespaces_default = defineRule({
+	meta: {
+		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." }
+	},
+	applies: (file) => file.side === "app" || file.side === "server" || file.side === "shared",
+	create: ({ file, report }) => ({ CallExpression: (node) => {
+		const [id] = node.arguments;
+		if (node.callee.type !== "Identifier" || !/^define\w*Token$/.test(node.callee.name) || id?.type !== "Literal" || typeof id.value !== "string" || !id.value.includes("/")) return;
+		const namespace = id.value.slice(0, id.value.indexOf("/"));
+		if (canonicalNamespaces(file.root).has(namespace)) report({
+			node: id,
+			messageId: "canonical",
+			data: { namespace }
+		});
+	} })
+});
+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 objectElements(node) {
-	if (node?.type !== "ArrayExpression") return [];
-	return node.elements.filter((element) => element?.type === "ObjectExpression");
+function isNullable(schema) {
+	return chainMethods(schema).some((method) => method === "nullable" || method === "nullish");
 }
+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",
@@ -252,47 +1262,101 @@ const DEFINERS = {
 		prefix: "Block"
 	}
 };
-const FORBIDDEN_FIELD_NAMES = /* @__PURE__ */ new Set([
-	"style",
-	"class",
-	"key",
-	"ref",
-	"is",
-	"slot",
-	"refFor",
-	"refKey"
-]);
-const definition = {
+function readDefinition(call) {
+	if (call.callee.type !== "Identifier" || !Object.hasOwn(DEFINERS, call.callee.name)) return;
+	const [options] = call.arguments;
+	const inline = options?.type === "ObjectExpression" ? options : void 0;
+	return {
+		definer: call.callee.name,
+		call,
+		options: inline,
+		component: inline && findStringProperty(inline, "component")
+	};
+}
+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)
+	}));
+}
+function readField(node) {
+	return {
+		node,
+		name: findStringProperty(node, "name"),
+		type: findStringProperty(node, "type")?.value,
+		as: findStringProperty(node, "as")?.value
+	};
+}
+function readFields(definition) {
+	return readGroups(definition).flatMap((group) => group.fields);
+}
+function readAllFields(definition) {
+	const fields = [];
+	const visit = (field) => {
+		fields.push(field);
+		readGroups(field).flatMap((group) => group.fields).forEach(visit);
+	};
+	readFields(definition).forEach(visit);
+	return fields;
+}
+function expectedDefiner(kind) {
+	return Object.keys(DEFINERS).find((definer) => DEFINERS[definer].kind === kind);
+}
+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." }
+	},
+	applies: (file) => file.side === "app",
+	create: ({ report }) => ({ CallExpression: (node) => {
+		const options = readDefinition(node)?.options;
+		if (!options) return;
+		const studio = findProperty(options, "studio");
+		if (studio && studio.type !== "ObjectExpression") return;
+		const description = studio && findProperty(studio, "description");
+		if (!description || description.type === "Literal" && String(description.value ?? "").trim() === "") report({
+			node: node.callee,
+			messageId: "description"
+		});
+	} })
+});
+var folder_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Keep defineSection() in app/sections/Section*.vue and defineBlock() in app/blocks/Block*.vue, with a matching component name and schema fields that reach the component." },
+		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/.",
-			wrongFolder: "{{definer}}() belongs in app/{{folder}}/.",
-			prefix: "Name {{kind}}s {{prefix}}*.vue, e.g. {{suggestion}}.vue.",
-			componentName: "component: '{{actual}}' must match the file name '{{expected}}'.",
-			forbiddenFieldName: "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."
+			wrongFolder: "{{definer}}() belongs in app/{{folder}}/."
 		}
 	},
-	create(context) {
-		const file = classify(context.filename);
-		if (!file || file.test || file.side !== "app") return {};
-		const reporter = createReporter(context, file);
-		const name = basename(file.path).replace(/\.[^.]+$/, "");
-		const calls = [];
+	applies: (file) => file.side === "app",
+	create: ({ file, report }) => {
+		const definers = /* @__PURE__ */ new Set();
 		return {
 			"CallExpression": (node) => {
-				if (node.callee.type === "Identifier" && Object.hasOwn(DEFINERS, node.callee.name)) calls.push({
-					definer: node.callee.name,
-					node
+				const definition = readDefinition(node);
+				if (!definition) return;
+				const { kind, folder } = DEFINERS[definition.definer];
+				definers.add(definition.definer);
+				if (file.kind !== kind && file.kind !== "override") report({
+					node: node.callee,
+					messageId: "wrongFolder",
+					data: {
+						definer: definition.definer,
+						folder
+					}
 				});
 			},
 			"Program:exit": () => {
-				const expected = Object.keys(DEFINERS).find((definer) => DEFINERS[definer].kind === file.kind);
-				if (expected && file.path.endsWith(".vue") && !calls.some((call) => call.definer === expected)) {
+				const expected = expectedDefiner(file.kind);
+				if (expected && file.path.endsWith(".vue") && !definers.has(expected)) {
 					const { kind, folder } = DEFINERS[expected];
-					reporter.report({
+					report({
 						loc: FILE_START,
 						messageId: "notDefined",
 						data: {
@@ -302,115 +1366,531 @@ const definition = {
 						}
 					});
 				}
-				for (const { definer, node } of calls) {
-					const { kind, folder, prefix } = DEFINERS[definer];
-					if (file.kind !== kind && file.kind !== "override") reporter.report({
-						node: node.callee,
-						messageId: "wrongFolder",
-						data: {
-							definer,
-							folder
-						}
+			}
+		};
+	}
+});
+var name_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require the `component` of a section or block definition to match its file name." },
+		schema: [],
+		messages: { componentName: "component: '{{actual}}' must match the file name '{{expected}}'." }
+	},
+	applies: (file) => file.side === "app",
+	create: ({ file, report }) => ({ CallExpression: (node) => {
+		const component = readDefinition(node)?.component;
+		const { name } = parse(file.path);
+		if (component && component.value !== name) report({
+			node: component.node,
+			messageId: "componentName",
+			data: {
+				actual: component.value,
+				expected: name
+			}
+		});
+	} })
+});
+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 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 ''." },
+		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 ||."
+		}
+	},
+	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 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}`
 					});
-					else if (file.kind === kind && !name.startsWith(prefix)) reporter.report({
-						node: node.callee,
-						messageId: "prefix",
-						data: {
-							kind,
-							prefix,
-							suggestion: prefixName(name, prefix)
-						}
+				}
+			}
+		});
+		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);
+			},
+			"Program:exit": () => {
+				for (const { node, prop, check } of reads) {
+					const type = types.get(prop);
+					if (type === "checkbox") report({
+						node,
+						messageId: "checkbox",
+						data: { check }
 					});
-					const [options] = node.arguments;
-					if (options?.type !== "ObjectExpression") continue;
-					const component = findStringProperty(options, "component");
-					if (component && component.value !== name) reporter.report({
-						node: component.node,
-						messageId: "componentName",
+					else if (type && FALSE_WHEN_UNSET.has(type)) report({
+						node,
+						messageId: "picker",
 						data: {
-							actual: component.value,
-							expected: name
+							type,
+							check
 						}
 					});
-					for (const group of objectElements(findProperty(options, "schema"))) for (const field of objectElements(findProperty(group, "fields"))) {
-						const fieldName = findStringProperty(field, "name");
-						if (fieldName && FORBIDDEN_FIELD_NAMES.has(fieldName.value)) reporter.report({
-							node: fieldName.node,
-							messageId: "forbiddenFieldName",
-							data: { name: fieldName.value }
-						});
-					}
+					else if (type && EMPTY_WHEN_UNSET.has(type) && check === "??") report({
+						node,
+						messageId: "text",
+						data: { type }
+					});
 				}
-				reporter.flush();
 			}
 		};
 	}
-};
-const files = {
+});
+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]));
+function slotProps(root) {
+	const folder = join(root, "src/runtime/app");
+	const names = /* @__PURE__ */ new Set();
+	let files;
+	try {
+		files = readdirSync(folder, {
+			recursive: true,
+			encoding: "utf8"
+		}).filter((file) => /\.(?:vue|[cm]?[jt]s)$/.test(file));
+	} catch {
+		return names;
+	}
+	for (const file of files) readPropNames(join(folder, file))?.forEach((name) => names.add(name));
+	return names;
+}
+const NOT_READ = /* @__PURE__ */ new Set([
+	"info",
+	"separator",
+	"query"
+]);
+var unused_default = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow schema fields the section or block never reads." },
+		schema: [],
+		messages: { unused: "Studio shows '{{name}}' to editors, but the component never reads it. Use the field or remove it." }
+	},
+	applies: (file) => file.side === "app" && file.path.endsWith(".vue"),
+	create: ({ context, file, report, visitTemplate }) => {
+		const fields = /* @__PURE__ */ new Map();
+		const used = /* @__PURE__ */ new Set();
+		const propsVariable = findPropsVariable(context.sourceCode.ast);
+		let hasProps = false;
+		let escapes = false;
+		const track = (node) => {
+			const names = usedProps(node);
+			if (names) names.forEach((name) => used.add(name));
+			else escapes = true;
+		};
+		visitTemplate({
+			VExpressionContainer: (node) => {
+				for (const { id } of node.references) used.add(id.name);
+			},
+			Identifier: (node) => {
+				if ((node.name === "$props" || node.name === propsVariable) && isReference(node)) track(node);
+			}
+		});
+		return {
+			"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);
+			},
+			"Identifier": (node) => {
+				const declaration = node.parent.type === "VariableDeclarator" && node.parent.id === node;
+				if (node.name === propsVariable && !declaration && isReference(node)) track(node);
+			},
+			"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({
+					node,
+					messageId: "unused",
+					data: { name }
+				});
+			}
+		};
+	}
+});
+const CAMEL_CASE = /^[a-z][a-zA-Z0-9]*$/;
+var casing_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Keep orchestr/ to handler files in domain folders that only export their handler." },
+		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." },
 		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/.",
-			noDomain: "Put handlers in a domain folder, e.g. orchestr/<domain>/{{file}}.",
-			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."
+			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."
 		}
 	},
-	create(context) {
-		const file = classify(context.filename);
-		if (!file || file.test || file.side !== "server" || file.kind !== "handler" && file.kind !== "orchestr-file") return {};
-		const reporter = createReporter(context, file);
-		if (file.kind === "orchestr-file") return { "Program:exit": () => {
-			reporter.report({
-				loc: FILE_START,
-				messageId: "notAHandler"
+	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"
 			});
-			reporter.flush();
-		} };
-		let hasDefault = false;
+			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;
+		}
+	} })
+});
+var required_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow `required` on schema fields, which Studio doesn't support." },
+		schema: [],
+		messages: { required: "Schema fields have no required option, so Studio ignores it. Give the field a default instead." }
+	},
+	applies: (file) => file.side === "app",
+	create: ({ report }) => ({ CallExpression: (node) => {
+		const definition = readDefinition(node);
+		for (const field of definition ? readAllFields(definition) : []) {
+			const required = findProperty(field.node, "required");
+			if (required) report({
+				node: required,
+				messageId: "required"
+			});
+		}
+	} })
+});
+const RESERVED = /* @__PURE__ */ new Set([
+	"style",
+	"class",
+	"key",
+	"ref",
+	"is",
+	"slot",
+	"refFor",
+	"refKey"
+]);
+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." },
+		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." }
+	},
+	applies: (file) => file.side === "app",
+	create: ({ report }) => ({ CallExpression: (node) => {
+		const definition = readDefinition(node);
+		for (const { name } of definition ? readFields(definition) : []) if (name && RESERVED.has(name.value)) report({
+			node: name.node,
+			messageId: "reserved",
+			data: { name: name.value }
+		});
+	} })
+});
+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 {
-			"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) reporter.report({
-					node,
-					messageId: "namedExport"
-				});
+			"CallExpression": (node) => {
+				defined ||= readDefinition(node) !== void 0;
 			},
-			"ExportAllDeclaration": (node) => {
-				reporter.report({
-					node,
-					messageId: "namedExport"
-				});
+			"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 {
+			ast: parse$2(text, {
+				parser: tsParser,
+				sourceType: "module",
+				ecmaVersion: "latest"
+			}),
+			text
+		};
+	} catch {
+		return;
+	}
+});
+var root_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require sections and blocks to render one root element, which carries frontend-core's data-lfc-* markers." },
+		schema: [],
+		messages: {
+			roots: "frontend-core adds its data-lfc-* markers to the root element of a section or block, and Vue drops them when there's more than one root. Wrap the content in one element.",
+			componentRoots: "<{{name}}> renders more than one root element, so Vue drops the data-lfc-* markers frontend-core adds to this section or block. Give {{name}} one root, or wrap it here."
+		}
+	},
+	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": () => {
-				if (!file.domain) reporter.report({
-					loc: FILE_START,
-					messageId: "noDomain",
-					data: { file: basename(file.path) }
-				});
-				if (!hasDefault) reporter.report({
-					loc: FILE_START,
-					messageId: "missingDefault"
+				const program = context.sourceCode.ast;
+				const template = program.templateBody;
+				if (!defined || !template) return;
+				const [root, second] = renderedRoots(template);
+				if (second) {
+					report({
+						loc: second.startTag.loc,
+						messageId: "roots"
+					});
+					return;
+				}
+				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({
+					loc: root.startTag.loc,
+					messageId: "componentRoots",
+					data: { name: root.rawName }
 				});
-				reporter.flush();
 			}
 		};
 	}
-};
-function isTypeOnly(node) {
-	const { importKind, exportKind } = node;
-	if (importKind === "type" || exportKind === "type") return true;
-	return node.type === "ImportDeclaration" && node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.importKind === "type");
+});
+var slots_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow counting slot children, since Studio 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." }
+	},
+	applies: (file) => file.side === "app",
+	create: ({ report, visitTemplate }) => {
+		const slotVariables = /* @__PURE__ */ new Set(["slots", "$slots"]);
+		const isSlots = (node) => node.type === "Identifier" && slotVariables.has(node.name) || node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "useSlots";
+		const check = (node) => {
+			if (node.computed || node.property.type !== "Identifier" || node.property.name !== "length") return;
+			const call = unwrap(node.object);
+			const slot = call.type === "CallExpression" ? unwrap(call.callee) : void 0;
+			if (slot?.type === "MemberExpression" && isSlots(slot.object)) report({
+				node: node.property,
+				messageId: "length"
+			});
+		};
+		visitTemplate({ MemberExpression: check });
+		return {
+			VariableDeclarator: (node) => {
+				if (node.id.type === "Identifier" && node.init && isSlots(node.init)) slotVariables.add(node.id.name);
+			},
+			MemberExpression: (node) => {
+				check(node);
+			}
+		};
+	}
+});
+var bundle_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow static imports of heavy packages in sections, blocks and plugins, which every page loads." },
+		schema: [{
+			type: "object",
+			properties: { packages: {
+				type: "array",
+				items: { type: "string" }
+			} },
+			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." }
+	},
+	applies: (file) => file.kind === "section" || file.kind === "block" || file.kind === "app-plugin",
+	create: ({ context, report }) => {
+		const { packages = [] } = context.options[0] ?? {};
+		return { ImportDeclaration: (node) => {
+			const source = String(node.source.value);
+			if (!isTypeOnly(node) && packages.some((name) => source === name || source.startsWith(`${name}/`))) report({
+				node,
+				messageId: "heavy",
+				data: { name: source }
+			});
+		} };
+	}
+});
+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);
+	return node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier" && node.property.name === "public" && isRuntimeConfig(node.object, variables);
+}
+function setupOptions(node) {
+	for (let parent = node.parent; parent; parent = parent.parent) {
+		const [options] = isFunction(parent) ? parent.params : [];
+		const owner = parent.parent;
+		if (options?.type === "Identifier" && owner?.type === "Property" && owner.key.type === "Identifier" && owner.key.name === "setup") return options.name;
+	}
 }
+var keys_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require runtime config keys of apps to be the package itself or one of its dependencies." },
+		schema: [],
+		messages: { key: "'{{key}}' isn't this package or one of its dependencies, so its config is missing at runtime. Use the key of an installed app." }
+	},
+	applies: (file) => file.side === "app" || file.side === "server" || file.side === "shared",
+	create: ({ file, report }) => {
+		const variables = /* @__PURE__ */ new Set();
+		return {
+			VariableDeclarator: (node) => {
+				if (node.id.type === "Identifier" && node.init && isRuntimeConfig(node.init, variables)) variables.add(node.id.name);
+			},
+			MemberExpression: (node) => {
+				const key = node.computed && node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : void 0;
+				if (!key?.startsWith("@") || !isRuntimeConfig(node.object, variables)) return;
+				const pkg = readPackage(file.root);
+				if (pkg && key !== pkg.name && !pkg.dependencies.has(key)) report({
+					node: node.property,
+					messageId: "key",
+					data: { key }
+				});
+			}
+		};
+	}
+});
+var public_default = defineRule({
+	meta: {
+		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." }
+	},
+	applies: (file) => file.side === "build",
+	create: ({ report }) => ({ AssignmentExpression: (node) => {
+		const path = memberPath(node.left);
+		const index = path.indexOf("runtimeConfig");
+		const options = index !== -1 && path[index + 1] === "public" ? setupOptions(node) : void 0;
+		if (!options) return;
+		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({
+				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",
@@ -477,6 +1957,10 @@ function findViolation(importer, target, typeOnly, sharedDomains) {
 			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] }
@@ -487,100 +1971,131 @@ function findViolation(importer, target, typeOnly, sharedDomains) {
 	};
 	if (importer.kind === "component" && target.kind === "section") return { messageId: "componentImportsSection" };
 }
+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
+		}],
+		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/.",
+			sharedImportsSide: "Shared code runs in the app and on the server, so it can't import from {{side}}/.",
+			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.",
+			nodeBuiltin: "'{{name}}' only exists on the server. Keep it in server/."
+		}
+	},
+	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:")) {
+				if (importer.side !== "server" && !typeOnly) report({
+					node,
+					messageId: "nodeBuiltin",
+					data: { name: source }
+				});
+				return;
+			}
+			const path = resolveImport(context.filename, source);
+			const target = path ? classify(path) : void 0;
+			const violation = target && findViolation(importer, target, typeOnly, sharedDomains);
+			if (violation) report({
+				node,
+				...violation
+			});
+		};
+		return {
+			ImportDeclaration: (node) => {
+				checkImport(node, node.source.value, isTypeOnly(node));
+			},
+			ExportNamedDeclaration: (node) => {
+				if (node.source) checkImport(node, node.source.value, isTypeOnly(node));
+			},
+			ExportAllDeclaration: (node) => {
+				checkImport(node, node.source.value, isTypeOnly(node));
+			},
+			ImportExpression: (node) => {
+				if (node.source.type === "Literal") checkImport(node, node.source.value, false);
+			}
+		};
+	}
+});
 const plugin = {
 	meta: {
 		name,
 		version
 	},
 	rules: {
-		"layers": {
-			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
-				}],
-				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/.",
-					sharedImportsSide: "Shared code runs in the app and on the server, so it can't import from {{side}}/.",
-					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.",
-					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.",
-					nodeBuiltin: "'{{name}}' only exists on the server. Keep it in server/."
-				}
-			},
-			create(context) {
-				const importer = classify(context.filename);
-				if (!importer || importer.test || importer.side !== "app" && importer.side !== "server" && importer.side !== "shared") return {};
-				const { sharedDomains = [] } = context.options[0] ?? {};
-				const reporter = createReporter(context, importer);
-				const checkImport = (node, source, typeOnly) => {
-					if (typeof source !== "string") return;
-					if (source.startsWith("node:")) {
-						if (importer.side !== "server" && !typeOnly) reporter.report({
-							node,
-							messageId: "nodeBuiltin",
-							data: { name: source }
-						});
-						return;
-					}
-					const path = resolveImport(context.filename, source);
-					const target = path ? classify(path) : void 0;
-					const violation = target && findViolation(importer, target, typeOnly, sharedDomains);
-					if (violation) reporter.report({
-						node,
-						...violation
-					});
-				};
-				return {
-					"ImportDeclaration": (node) => {
-						checkImport(node, node.source.value, isTypeOnly(node));
-					},
-					"ExportNamedDeclaration": (node) => {
-						if (node.source) checkImport(node, node.source.value, isTypeOnly(node));
-					},
-					"ExportAllDeclaration": (node) => {
-						checkImport(node, node.source.value, isTypeOnly(node));
-					},
-					"ImportExpression": (node) => {
-						if (node.source.type === "Literal") checkImport(node, node.source.value, false);
-					},
-					"Program:exit": () => {
-						reporter.flush();
-					}
-				};
-			}
-		},
-		"orchestr-files": files,
-		"definitions": definition,
-		"button-type": button
+		"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
 	}
 };
 async function larrylint(options = {}) {
-	const { sharedDomains } = await loadLarrylintConfig(options.cwd);
+	const { sharedDomains, 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/orchestr-files": "error",
-			"larrylint/definitions": "error",
-			"larrylint/button-type": "error"
+			"larrylint/heavy-imports": ["error", { packages: heavyPackages }]
 		}
 	}];
 }
-export { BASELINE_FILE, countViolations, defineLarrylintConfig, larrylint, plugin, readBaseline, writeBaseline };
+export { BASELINE_FILE, applyBaseline, countViolations, defineLarrylintConfig, larrylint, plugin, writeBaseline };