larrylint 0.1.0 → 0.2.0

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 { 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,83 +17,22 @@ async function loadLarrylintConfig(cwd = process.cwd()) {
 		globalRc: false,
 		dotenv: false
 	});
-	return { sharedDomains: config.sharedDomains ?? [] };
+	return { heavyPackages: config.heavyPackages ?? [] };
 }
-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;
-		}
-	};
-}
-const directories = /* @__PURE__ */ new Map();
-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;
-}
-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",
-	blocks: "block",
-	components: "component",
-	composables: "composable",
-	utils: "app-util",
-	plugins: "app-plugin",
-	overrides: "override"
+	"sections": "section",
+	"section": "section",
+	"blocks": "block",
+	"block": "block",
+	"components": "component",
+	"composables": "composable",
+	"utils": "app-util",
+	"plugins": "app-plugin",
+	"overrides": "override",
+	"theme": "theme",
+	"shared-fields": "shared-field"
 };
 const SERVER_FOLDERS = {
 	"middleware": "middleware",
@@ -127,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" };
@@ -142,90 +79,977 @@ 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]?.replace("templates", "template");
+		return {
+			side,
+			kind: handler ? "handler" : "orchestr-file",
+			handler
+		};
+	}
+	return {
+		side,
+		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) {
+	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
+			};
+		}
+	};
+}
+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 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 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",
+	"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;
+}
+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, 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, template) => {
+			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: dropped && !template ? "dropped" : "unhandled"
+			});
+		};
+		visitTemplate({ CallExpression: (node) => check(node, true) });
+		return { CallExpression: (node) => check(node, false) };
+	}
+});
+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 && !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 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 {
+		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 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") {
+			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;
+	let fn;
+	const { parent } = node;
+	if (parent?.type === "ReturnStatement") {
+		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,
+		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 falls back to a '#…' string instead of an empty value." },
+		schema: [],
+		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 destructured = /* @__PURE__ */ new Map();
+		const calls = [];
+		const scriptIdentifiers = [];
+		const templateIdentifiers = [];
+		visitTemplate({ Identifier: (node) => {
+			templateIdentifiers.push(node);
+		} });
+		return {
+			"VariableDeclarator": (node) => {
+				destructuredResolvers(node).forEach((method, local) => destructured.set(local, method));
+			},
+			"CallExpression": (node) => {
+				calls.push(node);
+			},
+			"Identifier": (node) => {
+				scriptIdentifiers.push(node);
+			},
+			"Program:exit": () => {
+				const holders = /* @__PURE__ */ new Map();
+				const reported = /* @__PURE__ */ new Set();
+				for (const call of calls) {
+					if (linkResolverMethod(call, destructured) !== "resolve") continue;
+					if (isTested(call)) report({
+						node: call,
+						messageId: "tested"
+					});
+					const holder = findHolder(call);
+					if (holder) holders.set(holder.name, {
+						computed: holder.computed,
+						branch: holder.fn && canReturnNullish(holder.fn, call) ? call : void 0
+					});
+				}
+				const check = (identifier, template) => {
+					const holder = holders.get(identifier.name);
+					const { parent } = identifier;
+					if (!holder || !isReference(identifier)) return;
+					const readsValue = parent.type === "MemberExpression" && parent.object === identifier && nameOf(parent) === "value";
+					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));
+			}
+		};
+	}
+});
+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 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)\/.*\/(?: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 buttons, which silently render their `button-type` prop instead." },
+		schema: [],
+		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 = new Set(BUTTONS.flatMap((name) => [name, kebabCase(name)]));
+		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",
+						data: { tag: node.rawName },
+						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") report({
+					loc: argument.loc,
+					messageId: "buttonType",
+					data: { tag: node.rawName },
+					fix: (fixer) => fixer.replaceTextRange(argument.range, "button-type")
+				});
+			}
+		} });
+		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 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 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: "Write cookies and headers only where orchestr allows it: in extendRequest() and action handlers, with frontend-core's managed cookie functions." },
+		schema: [],
+		messages: {
+			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 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: "streamed",
+			data: { name: write.name }
+		});
+		else if (managed && (method === "extendRequest" || !method && file.handler === "action")) report({
+			node,
+			messageId: "managed",
+			data: {
+				name: write.name,
+				managed
+			}
+		});
+	} })
+});
+const FILE_START = {
+	start: {
+		line: 1,
+		column: 0
+	},
+	end: {
+		line: 1,
+		column: 0
+	}
+};
+var files_default$1 = defineRule({
+	meta: {
+		type: "problem",
+		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 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: () => {
+		report({
+			loc: FILE_START,
+			messageId: "notAHandler"
+		});
+	} })
+});
+var exports_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require handler files to export their handler as default." },
+		schema: [],
+		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 }) => {
+		let hasDefault = false;
+		return {
+			"ExportDefaultDeclaration": () => {
+				hasDefault = true;
+			},
+			"ExportSpecifier": (node) => {
+				hasDefault ||= (node.exported.type === "Identifier" ? node.exported.name : node.exported.value) === "default";
+			},
+			"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 {
-			side,
-			kind: HANDLER_FILE.test(parts.at(-1)) ? "handler" : "orchestr-file",
-			domain: nested ? rest[0] : void 0
+			"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 kind = SERVER_FOLDERS[folder] ?? "other";
-	return {
-		side,
-		kind,
-		domain: kind === "server-util" && nested ? rest[0] : void 0
-	};
-}
-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}`;
-}
-const UI_KIT_BUTTON = /(?:^#ui-kit|@laioutr-core\/ui-kit)\/.*\/Button\.vue$/;
-const button = {
+});
+var throws_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 throwing in extendRequest(), which runs before every query, so a throw takes down every page." },
 		schema: [],
-		messages: { buttonType: "l-button ignores type and always renders its button-type prop, which defaults to \"button\". Use button-type." }
+		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."
+		}
 	},
-	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);
-		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,
-						messageId: "buttonType",
-						fix: (fixer) => fixer.replaceTextRange(argument.range, "button-type")
-					});
-				}
-			},
-			"VElement:exit": (node) => {
-				if (node.parent.type === "VDocumentFragment") reporter.flush();
+	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;
 			}
-		}, { 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);
+			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
+					}
+				});
 			}
-		} });
+		});
+	} })
+});
+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);
 	}
-};
-const FILE_START = {
-	start: {
-		line: 1,
-		column: 0
+	return namespaces;
+}
+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, 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." }
 	},
-	end: {
-		line: 1,
-		column: 0
-	}
-};
+	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 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;
 }
@@ -243,56 +1067,144 @@ function objectElements(node) {
 const DEFINERS = {
 	defineSection: {
 		kind: "section",
-		folder: "sections",
-		prefix: "Section"
+		folder: "sections"
 	},
 	defineBlock: {
 		kind: "block",
-		folder: "blocks",
-		prefix: "Block"
+		folder: "blocks"
 	}
 };
-const FORBIDDEN_FIELD_NAMES = /* @__PURE__ */ new Set([
-	"style",
-	"class",
-	"key",
-	"ref",
-	"is",
-	"slot",
-	"refFor",
-	"refKey"
+const PICKERS = /* @__PURE__ */ new Set([
+	"select",
+	"radio",
+	"toggle_button"
+]);
+const TEXTS$1 = /* @__PURE__ */ new Set([
+	"text",
+	"textarea",
+	"secret"
 ]);
-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,
+		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 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 picker, and AI agents read it through Laioutr's MCP server. 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."
+			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}}/."
 		}
 	},
-	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 +1214,471 @@ 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
-						}
-					});
-					else if (file.kind === kind && !name.startsWith(prefix)) reporter.report({
-						node: node.callee,
-						messageId: "prefix",
-						data: {
-							kind,
-							prefix,
-							suggestion: prefixName(name, prefix)
-						}
+			}
+		};
+	}
+});
+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
+			}
+		});
+	} })
+});
+const TEXTS = /* @__PURE__ */ new Set([
+	"text",
+	"textarea",
+	"secret"
+]);
+var fallbacks_default = defineRule({
+	meta: {
+		type: "problem",
+		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: {
+			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 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 && !isNullish(node.right)) fallbacks.push({
+				node,
+				prop
+			});
+		} });
+		visitTemplate(collect(true));
+		return {
+			...collect(false),
+			"CallExpression": (node) => {
+				const definition = readDefinition(node);
+				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
 					});
-					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",
+				}
+			},
+			"Program:exit": () => {
+				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,
 						data: {
-							actual: component.value,
-							expected: name
+							type: field.type,
+							fill,
+							fallback: context.sourceCode.getText(node.right)
 						}
 					});
-					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 }
-						});
-					}
 				}
-				reporter.flush();
 			}
 		};
 	}
-};
-const files = {
+});
+const PROP_READ = /\.props\??\.([A-Z_$][\w$]*)|\.props\??\.?\[\s*['"]([^'"]+)['"]\s*\]|['"]([^'"]+)['"]\s+in\s+[\w$.?]+\.props\b/gi;
+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 result = {
+		names: /* @__PURE__ */ new Set(),
+		all: false
+	};
+	let files;
+	try {
+		files = readdirSync(folder, {
+			recursive: true,
+			encoding: "utf8"
+		}).filter((file) => /\.(?:vue|[cm]?[jt]s)$/.test(file));
+	} catch {
+		return result;
+	}
+	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",
+	"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 block = 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);
+				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;
+				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 && 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 }
+				});
+			}
+		};
+	}
+});
+var casing_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Keep orchestr/ to handler files in domain folders that only export their handler." },
+		docs: { description: "Disallow top-level schema field names that Vue renames or rejects as props." },
 		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."
+			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."
 		}
 	},
-	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);
+		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({
+	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"
 			});
-			reporter.flush();
-		} };
-		let hasDefault = false;
+		}
+	} })
+});
+const RESERVED = /* @__PURE__ */ new Set([
+	"key",
+	"ref",
+	"ref_for",
+	"ref_key",
+	"class",
+	"style"
+]);
+var reserved_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow top-level schema field names that never reach the component's props." },
+		schema: [],
+		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) => {
+		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 }
+		});
+		else if (name?.value === "slots" && definition?.definer === "defineSection") report({
+			node: name.node,
+			messageId: "slots"
+		});
+	} })
+});
+const parseVueFile = cachedReader((text) => {
+	try {
 		return {
-			"ExportDefaultDeclaration": () => {
-				hasDefault = true;
+			ast: parse$2(text, {
+				parser: tsParser,
+				sourceType: "module",
+				ecmaVersion: "latest"
+			}),
+			text
+		};
+	} catch {
+		return;
+	}
+});
+const OWN_ATTRS = /inheritAttrs\s*:\s*false/;
+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;
 			},
-			"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"
+			"Program:exit": () => {
+				const program = context.sourceCode.ast;
+				const template = program.templateBody;
+				if (!defined || !template || OWN_ATTRS.test(context.sourceCode.text)) 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 && !OWN_ATTRS.test(component.text)) report({
+					loc: root.startTag.loc,
+					messageId: "componentRoots",
+					data: { name: root.rawName }
 				});
+			}
+		};
+	}
+});
+var slots_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow counting slot children, since frontend-core passes all blocks of a slot as one Fragment." },
+		schema: [],
+		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 }) => {
+		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);
 			},
-			"ExportAllDeclaration": (node) => {
-				reporter.report({
-					node,
-					messageId: "namedExport"
-				});
+			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: "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 }) => {
+		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 }
+			});
+		} };
+	}
+});
+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);
+	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);
 			},
-			"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"
+			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 }
 				});
-				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 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, e.g. options.storefrontUrl." }
+	},
+	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) report({
+				node: child,
+				messageId: "options"
+			});
+		});
+	} })
+});
 const LABELS = {
 	"section": "section",
 	"block": "block",
@@ -445,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 {
@@ -462,21 +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 === "app-util" && ABOVE_APP_UTILS.has(target.kind)) return {
 		messageId: "appUtilImportsUp",
 		data: { kind: LABELS[target.kind] }
@@ -487,100 +1738,104 @@ 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, 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/.",
+			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/.",
+			serverUtilImportsUp: "Server utils are the bottom layer and can't import {{kind}} code.",
+			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 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);
+			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,
+		"heavy-imports": bundle_default,
+		"config-keys": keys_default,
+		"public-config": public_default,
+		"orchestr-files": files_default$1,
+		"orchestr-cookies": cookies_default,
+		"handler-exports": exports_default,
+		"middleware-files": files_default,
+		"initware-throws": throws_default,
+		"token-namespaces": namespaces_default,
+		"definition-folder": folder_default,
+		"component-name": name_default,
+		"definition-description": description_default,
+		"single-root": root_default,
+		"slot-children": slots_default,
+		"reserved-field-names": reserved_default,
+		"field-name-case": casing_default,
+		"required-fields": required_default,
+		"unused-fields": unused_default,
+		"dead-fallbacks": fallbacks_default,
+		"button-type": button_default,
+		"mutation-errors": mutations_default,
+		"resolve-result": resolve_default,
+		"hand-built-links": paths_default,
+		"internal-anchors": anchors_default
 	}
 };
 async function larrylint(options = {}) {
-	const { sharedDomains } = 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: {
-			"larrylint/layers": ["error", { sharedDomains }],
-			"larrylint/orchestr-files": "error",
-			"larrylint/definitions": "error",
-			"larrylint/button-type": "error"
+			...Object.fromEntries(Object.keys(plugin.rules).map((id) => [`larrylint/${id}`, "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 };