larrylint 0.0.1 → 0.1.1

package/dist/_chunks/preset.mjs

@@ -0,0 +1,2101 @@
+import { name, version } from "./package.mjs";
+import process from "node:process";
+import { loadConfig } from "c12";
+import { basename, dirname, join, normalize, parse, relative, resolve } from "pathe";
+import { 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;
+}
+async function loadLarrylintConfig(cwd = process.cwd()) {
+	const { config } = await loadConfig({
+		name: "larrylint",
+		cwd,
+		packageJson: true,
+		rcFile: false,
+		globalRc: false,
+		dotenv: false
+	});
+	return {
+		sharedDomains: config.sharedDomains ?? [],
+		heavyPackages: config.heavyPackages ?? []
+	};
+}
+const EXTENSIONS = [
+	"",
+	".ts",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs",
+	"/index.ts",
+	"/index.js"
+];
+const directories = /* @__PURE__ */ new Map();
+function cachedReader(parse) {
+	const cache = /* @__PURE__ */ new Map();
+	return (path) => {
+		let mtimeMs;
+		try {
+			mtimeMs = statSync(path).mtimeMs;
+		} catch {
+			return;
+		}
+		const cached = cache.get(path);
+		if (cached?.mtimeMs === mtimeMs) return cached.value;
+		const value = parse(readFileSync(path, "utf8"));
+		cache.set(path, {
+			mtimeMs,
+			value
+		});
+		return value;
+	};
+}
+function isDirectory(path) {
+	let result = directories.get(path);
+	if (result === void 0) {
+		try {
+			result = statSync(path).isDirectory();
+		} catch {
+			result = false;
+		}
+		directories.set(path, result);
+	}
+	return result;
+}
+function resolveImport(importer, source) {
+	if (!source.startsWith("./") && !source.startsWith("../")) return;
+	const target = resolve(dirname(importer), source.split("?")[0]);
+	return isDirectory(target) ? `${target}/index` : target;
+}
+function resolveModule(importer, source) {
+	if (!source.startsWith("./") && !source.startsWith("../")) return;
+	const target = resolve(dirname(importer), source.split("?")[0]);
+	return EXTENSIONS.map((extension) => `${target}${extension}`).find((path) => existsSync(path) && !isDirectory(path));
+}
+function findPackage(from, name) {
+	for (let folder = from;; folder = dirname(folder)) {
+		const candidate = join(folder, "node_modules", name);
+		if (existsSync(join(candidate, "package.json"))) return realpathSync(candidate);
+		if (dirname(folder) === folder) return;
+	}
+}
+const HANDLER_FILE = /\.(query|resolver|link|action|template|page-index)(?:\.[cm]?[jt]s)?$/;
+const 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",
+	"theme": "theme",
+	"shared-fields": "shared-field"
+};
+const SERVER_FOLDERS = {
+	"middleware": "middleware",
+	"client": "client",
+	"utils": "server-util",
+	"api": "route",
+	"routes": "route",
+	"plugins": "nitro-plugin",
+	"media-library": "media-library",
+	"media-libraries": "media-library"
+};
+function classify(file) {
+	const absolute = normalize(file);
+	const test = TEST_FILE.test(absolute);
+	const runtimeIndex = absolute.lastIndexOf("/src/runtime/");
+	if (runtimeIndex !== -1) {
+		const root = absolute.slice(0, runtimeIndex);
+		return {
+			root,
+			path: absolute.slice(root.length + 1),
+			test,
+			...classifyRuntime(absolute.slice(runtimeIndex + 13).split("/"))
+		};
+	}
+	const srcIndex = absolute.lastIndexOf("/src/");
+	if (srcIndex === -1) return;
+	const root = absolute.slice(0, srcIndex);
+	const path = absolute.slice(root.length + 1);
+	return {
+		root,
+		path,
+		side: path.startsWith("src/types/") ? "other" : "build",
+		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" };
+	if (side === "shared") return {
+		side,
+		kind: "shared"
+	};
+	if (side === "app") return {
+		side,
+		kind: APP_FOLDERS[folder] ?? "other"
+	};
+	const nested = rest.length > 1;
+	if (folder === "orchestr") {
+		if (nested && rest[0] === "plugins") return {
+			side,
+			kind: "orchestr-plugin"
+		};
+		const handler = HANDLER_FILE.exec(parts.at(-1))?.[1];
+		return {
+			side,
+			kind: handler ? "handler" : "orchestr-file",
+			handler,
+			domain: nested ? rest[0] : void 0
+		};
+	}
+	const kind = SERVER_FOLDERS[folder] ?? "other";
+	return {
+		side,
+		kind,
+		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$/;
+var button_default = defineRule({
+	meta: {
+		type: "problem",
+		fixable: "code",
+		docs: { description: "Disallow `type` on the ui-kit button, which silently renders its `button-type` prop instead." },
+		schema: [],
+		messages: { buttonType: "l-button ignores type and always renders its button-type prop, which defaults to \"button\". Use button-type." }
+	},
+	applies: (file) => file.path.endsWith(".vue"),
+	create: ({ report, visitTemplate }) => {
+		const buttons = /* @__PURE__ */ new Set(["LButton", "l-button"]);
+		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(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",
+					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 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,
+		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 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;
+}
+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 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",
+		folder: "sections",
+		prefix: "Section"
+	},
+	defineBlock: {
+		kind: "block",
+		folder: "blocks",
+		prefix: "Block"
+	}
+};
+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/ 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}}/."
+		}
+	},
+	applies: (file) => file.side === "app",
+	create: ({ file, report }) => {
+		const definers = /* @__PURE__ */ new Set();
+		return {
+			"CallExpression": (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 = expectedDefiner(file.kind);
+				if (expected && file.path.endsWith(".vue") && !definers.has(expected)) {
+					const { kind, folder } = DEFINERS[expected];
+					report({
+						loc: FILE_START,
+						messageId: "notDefined",
+						data: {
+							folder,
+							kind,
+							definer: expected
+						}
+					});
+				}
+			}
+		};
+	}
+});
+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}`
+					});
+				}
+			}
+		});
+		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 }
+					});
+					else if (type && FALSE_WHEN_UNSET.has(type)) report({
+						node,
+						messageId: "picker",
+						data: {
+							type,
+							check
+						}
+					});
+					else if (type && EMPTY_WHEN_UNSET.has(type) && check === "??") report({
+						node,
+						messageId: "text",
+						data: { type }
+					});
+				}
+			}
+		};
+	}
+});
+const PROP_READ = /\.props\??\.([A-Z_$][\w$]*)|\.props\??\.?\[\s*['"]([^'"]+)['"]\s*\]|['"]([^'"]+)['"]\s+in\s+[\w$.?]+\.props\b/gi;
+const readPropNames = cachedReader((text) => [...text.matchAll(PROP_READ)].map((match) => match[1] ?? match[2] ?? match[3]));
+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: "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: {
+			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."
+		}
+	},
+	applies: (file) => file.side === "app",
+	create: ({ report }) => ({ CallExpression: (node) => {
+		const definition = readDefinition(node);
+		let previous;
+		for (const { label } of definition ? readGroups(definition) : []) {
+			if (!label) continue;
+			if (!PANELS.includes(label.value)) report({
+				node: label.node,
+				messageId: "panel"
+			});
+			else if (previous && PANELS.indexOf(label.value) < PANELS.indexOf(previous)) report({
+				node: label.node,
+				messageId: "order",
+				data: {
+					label: label.value,
+					previous
+				}
+			});
+			else previous = label.value;
+		}
+	} })
+});
+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 {
+			"CallExpression": (node) => {
+				defined ||= readDefinition(node) !== void 0;
+			},
+			"Program:exit": () => {
+				const template = context.sourceCode.ast.templateBody;
+				if (!defined || !template) return;
+				for (const root of template.children) {
+					const id = root.type === "VElement" ? findAttribute(root, "id") : void 0;
+					if (id) report({
+						loc: id.loc,
+						messageId: "rootId"
+					});
+				}
+			}
+		};
+	}
+});
+const parseVueFile = cachedReader((text) => {
+	try {
+		return {
+			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": () => {
+				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 }
+				});
+			}
+		};
+	}
+});
+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",
+	"component": "component",
+	"composable": "composable",
+	"app-plugin": "plugin",
+	"override": "override",
+	"route": "API route",
+	"nitro-plugin": "Nitro plugin",
+	"orchestr-plugin": "orchestr plugin",
+	"orchestr-file": "orchestr",
+	"media-library": "media library"
+};
+const ABOVE_APP_UTILS = /* @__PURE__ */ new Set([
+	"section",
+	"block",
+	"component",
+	"composable",
+	"app-plugin",
+	"override"
+]);
+const ABOVE_COMPOSABLES = /* @__PURE__ */ new Set([
+	"section",
+	"block",
+	"component",
+	"override"
+]);
+const ABOVE_SERVER_UTILS = /* @__PURE__ */ new Set([
+	"route",
+	"nitro-plugin",
+	"orchestr-plugin",
+	"orchestr-file",
+	"media-library"
+]);
+const BUILDER_USERS = /* @__PURE__ */ new Set([
+	"handler",
+	"orchestr-file",
+	"middleware",
+	"media-library"
+]);
+function findViolation(importer, target, typeOnly, sharedDomains) {
+	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 {
+		messageId: "sharedImportsSide",
+		data: { side: target.side }
+	};
+	if (target.side === "build" && !typeOnly) return { messageId: "runtimeImportsBuild" };
+	if (target.kind === "handler") return { messageId: "handlerImported" };
+	if (typeOnly) return;
+	if (target.kind === "client" && importer.kind === "handler") return { messageId: "clientInHandler" };
+	if (target.kind === "client" && importer.kind === "server-util") return { messageId: "clientInUtil" };
+	if (target.kind === "middleware" && !BUILDER_USERS.has(importer.kind)) return { messageId: "middlewareImported" };
+	if (importer.kind === "server-util" && ABOVE_SERVER_UTILS.has(target.kind)) return {
+		messageId: "serverUtilImportsUp",
+		data: { kind: LABELS[target.kind] }
+	};
+	const from = domainOf(importer);
+	const to = domainOf(target);
+	if (from && to && from !== to && !sharedDomains.includes(to)) return {
+		messageId: "crossDomain",
+		data: {
+			from,
+			to
+		}
+	};
+	if (importer.kind === "server-util" && !from && to && !sharedDomains.includes(to)) return {
+		messageId: "sharedImportsDomain",
+		data: { to }
+	};
+	if (importer.kind === "app-util" && ABOVE_APP_UTILS.has(target.kind)) return {
+		messageId: "appUtilImportsUp",
+		data: { kind: LABELS[target.kind] }
+	};
+	if (importer.kind === "composable" && ABOVE_COMPOSABLES.has(target.kind)) return {
+		messageId: "composableImportsUp",
+		data: { kind: LABELS[target.kind] }
+	};
+	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": 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, heavyPackages } = await loadLarrylintConfig(options.cwd);
+	return [{
+		name: "larrylint",
+		files: ["**/src/**/*.{ts,mts,cts,js,mjs,cjs,vue}"],
+		plugins: { larrylint: plugin },
+		rules: {
+			...Object.fromEntries(Object.keys(plugin.rules).map((id) => [`larrylint/${id}`, "error"])),
+			"larrylint/layers": ["error", { sharedDomains }],
+			"larrylint/heavy-imports": ["error", { packages: heavyPackages }]
+		}
+	}];
+}
+export { BASELINE_FILE, applyBaseline, countViolations, defineLarrylintConfig, larrylint, plugin, writeBaseline };