larrylint 0.2.0 → 0.2.2

package/README.md

@@ -33,12 +33,12 @@ After that, `eslint .` and your editor report larrylint's rules next to your own
 
 | Rule | Description |
 | --- | --- |
-| `larrylint/layers` | App, server and shared code stay apart, and runtime code doesn't import build-time code, or `node:` modules outside the server. Nothing imports orchestr handlers, and handlers get API clients from the orchestr context. Utils are the bottom layer, followed by composables, components and sections. |
-| `larrylint/heavy-imports` | Sections, blocks and plugins load the packages in `heavyPackages` with `import()`: frontend-core imports every section and block up front, and plugins run on every page, so a static import lands in the chunk every page loads. |
+| `larrylint/layers` | App, server and shared code don't import each other, runtime code doesn't import build-time code, and `node:` modules stay on the server. As Laioutr's coding standards ask, handlers get API clients from the orchestr context, nothing imports handler files, and components don't import sections or blocks. |
+| `larrylint/heavy-imports` | Sections, blocks and plugins load the packages in `heavyPackages` with `import()`: frontend-core imports every section and block up front, and plugins run on every page, so a static import loads the package on every page. |
 | `larrylint/config-keys` | Runtime config keys like `'@laioutr-app/shopware'` are the app itself or one of its dependencies, otherwise the config is missing at runtime. |
-| `larrylint/public-config` | The module doesn't copy its whole options object into `runtimeConfig.public`, which reaches the browser with every token among them. |
+| `larrylint/public-config` | The module doesn't copy its whole options object into `runtimeConfig.public`, which would send every secret in it to the browser. |
 
-Type imports are fine across most layers, since they don't end up in the bundle.
+Type imports are always fine, since they don't end up in the bundle.
 
 ### Orchestr
 
@@ -47,66 +47,61 @@ Type imports are fine across most layers, since they don't end up in the bundle.
 | `larrylint/orchestr-files` | Laioutr loads every file in `orchestr/` as a Nitro plugin, so only handler files belong there. |
 | `larrylint/orchestr-cookies` | Cookies and headers are only written in `extendRequest()` and action handlers, since query, link and resolver handlers and `use()` middleware can run after the headers are sent. Cookies go through frontend-core's `setManagedCookie()` and `deleteManagedCookie()`, which the Studio preview needs. |
 | `larrylint/handler-exports` | Handler files export their handler as default. Without one, the build fails. |
-| `larrylint/middleware-files` | `server/middleware/` only holds orchestr and Nitro middleware; helpers go to `server/utils/`. |
-| `larrylint/initware-throws` | `extendRequest()` doesn't throw, directly or through a function it calls: it runs before every query, so a throw takes down every page. |
+| `larrylint/initware-throws` | `extendRequest()` doesn't throw, directly or through a function it calls: it runs before every query, so a throw breaks every page. |
 | `larrylint/token-namespaces` | Your own tokens stay out of the namespaces of Laioutr's canonical types, like `ecommerce/`, where a later canonical-types release or another app can take the same id. |
 
 ### Sections and blocks
 
 | Rule | Description |
 | --- | --- |
-| `larrylint/definition-folder` | `defineSection()` lives in `app/sections/` and `defineBlock()` in `app/blocks/` (or `section/` and `block/`), and every `.vue` there has one. |
+| `larrylint/definition-folder` | `defineSection()` and `defineBlock()` live where `module.ts` registers sections and blocks, and every `.vue` registered there has one. Files that `module.ts` wires up by hand, like replacements for upstream sections, can live anywhere. |
 | `larrylint/component-name` | The `component` of a definition matches its file name. |
 | `larrylint/definition-description` | Definitions have a `studio.description`, which Studio shows in its section picker and AI agents read through Laioutr's MCP server. |
-| `larrylint/single-root` | Sections and blocks render one root element, also through a component they wrap. Otherwise Vue drops the `data-lfc-*` markers frontend-core adds. |
+| `larrylint/single-root` | Sections and blocks render one root element, also through a component they wrap. Otherwise Vue drops the `data-lfc-*` attributes Studio needs to select them in the preview. |
 | `larrylint/slot-children` | Nothing counts slot children with `.length`: frontend-core passes all blocks of a slot as one Fragment. |
 | `larrylint/reserved-field-names` | No top-level schema fields named `key`, `ref`, `ref_for`, `ref_key`, `class` or `style`, which Vue handles itself, and no `slots` on sections, which frontend-core overwrites. |
-| `larrylint/field-name-case` | Top-level schema field names have no `-` and don't start with `$`: Vue camelizes the one and rejects the other. |
+| `larrylint/field-name-case` | Top-level schema field names have no `-` and don't start with `$`, which Vue renames or rejects as props. |
 | `larrylint/required-fields` | Schema fields have no `required`, which Studio ignores. Give them a `default` instead. |
 | `larrylint/unused-fields` | The component reads every schema field it defines, directly, through the section it's a block of, or in another field's `if`, so editors don't get fields that do nothing. |
-| `larrylint/dead-fallbacks` | No `??` fallbacks that never apply: frontend-core fills unset pickers with their first option, checkboxes with `false` and text fields with `''`. |
+| `larrylint/dead-fallbacks` | No `??` fallbacks that are never used: frontend-core fills unset pickers with their first option, content alignments with the center, checkboxes with `false` and text fields with `''`. |
 
 ### Frontend
 
 | Rule | Description |
 | --- | --- |
 | `larrylint/button-type` | No `type` on the ui-kit buttons: they always render their `button-type` prop, so `type="submit"` silently renders a dead button. Autofixable. |
-| `larrylint/mutation-errors` | An awaited or dropped `mutateAsync()` handles its error. Otherwise a failed mutation replaces the whole section or block with frontend-core's "Retry" state, or ends up as an unhandled rejection. |
-| `larrylint/resolve-result` | Nothing tests the result of `linkResolver.resolve()`: a link it can't resolve comes back as a `#…` fallback, not as an empty value. |
+| `larrylint/mutation-errors` | An awaited or dropped `mutateAsync()` handles its error. Otherwise a failed mutation replaces the whole section or block with an error, or nothing handles it. |
+| `larrylint/resolve-result` | Nothing checks the result of `linkResolver.resolve()`: a link it can't resolve comes back as a `#…` fallback, not as an empty value. |
 | `larrylint/hand-built-links` | Links to pages come from `linkResolver`, not from paths like `` `/hotels/${slug}` ``: page paths are set per page and language in Studio, and each market adds its own prefix, like `/en`. |
 | `larrylint/internal-anchors` | Internal and resolved links use `<NuxtLink>`: a plain `<a>` reloads the page and breaks Studio's navigation sync. |
 
 ## Layout
 
-larrylint expects the layout of Laioutr's [app starter](https://github.com/laioutr/app-starter):
+larrylint follows the runtime layout from Laioutr's [coding standards](https://docs.laioutr.com/apps/app-development/coding-standards):
 
 ```
 src/
-├── module.ts                  # build time
+├── module.ts                # registers sections, blocks, orchestr handlers and plugins
 └── runtime/
-    ├── app/
-    │   ├── sections/          # defineSection() components, or section/
-    │   ├── blocks/            # defineBlock() components, or block/
-    │   ├── components/
-    │   ├── composables/
-    │   ├── overrides/         # replacements for upstream components
-    │   ├── plugins/
-    │   ├── shared-fields/     # schema fields sections and blocks share
-    │   ├── theme/
+    ├── app/                 # client code
+    │   ├── components/      # UI components
+    │   ├── sections/        # defineSection() components
+    │   └── blocks/          # defineBlock() components
+    ├── server/              # server code
+    │   ├── client/          # API client factories
+    │   ├── const/
+    │   ├── mappers/
+    │   ├── middleware/      # defineOrchestr() with extendRequest()
+    │   ├── orchestr/        # *.query.ts, *.resolver.ts, *.link.ts, *.action.ts, *.template.ts, *.page-index.ts
+    │   ├── orchestr-helper/ # helper logic for handlers
     │   └── utils/
-    ├── server/
-    │   ├── orchestr/
-    │   │   ├── <entity>/      # *.query.ts, *.resolver.ts, *.link.ts, *.action.ts, *.template.ts, *.page-index.ts
-    │   │   └── plugins/
-    │   ├── middleware/        # orchestr middleware and the builders handlers use
-    │   ├── client/            # API clients, nothing else
-    │   ├── api/               # server routes, or routes/
-    │   ├── plugins/           # Nitro plugins
-    │   ├── media-library/     # or media-libraries/
-    │   └── utils/
-    └── shared/                # code for both the app and the server
+    └── shared/              # code for both sides, like orchestr tokens
 ```
 
+Where your sections, blocks and handlers live, larrylint reads from your `module.ts`: the folders and globs you pass to `registerLaioutrApp()`, and the plugins you pass to `addPlugin()`. So other folders work too, like `section/` and `block/` in Laioutr's own ui-app. Without a `module.ts` it can read, larrylint assumes the folders of Laioutr's [app starter](https://github.com/laioutr/app-starter): `app/sections/`, `app/blocks/` and `server/orchestr/`.
+
+Besides that, larrylint only relies on the names `app/components/` and `server/client/`, and on the split into `app/`, `server/` and `shared/`.
+
 ## Baseline
 
 On an existing codebase, `larrylint init` records all current violations in `larrylint-baseline.json`, counted per file and rule. A file stays quiet as long as it has no more violations of a rule than recorded. Once it gets more, all of them show again, like ESLint's bulk suppressions. The baseline applies in your editor, in `eslint .` and in the CLI.

package/dist/_chunks/check2.mjs

@@ -2,8 +2,8 @@ import { BASELINE_FILE, countViolations, writeBaseline } from "./preset.mjs";
 import { cwdArgs } from "../cli/index.mjs";
 import { check } from "./check.mjs";
 import process from "node:process";
-import { join, resolve } from "pathe";
 import { existsSync } from "node:fs";
+import { join, resolve } from "pathe";
 import { defineCommand } from "citty";
 import { consola } from "consola";
 var check_default = defineCommand({

package/dist/_chunks/init.mjs

@@ -2,8 +2,8 @@ import { BASELINE_FILE, countViolations, writeBaseline } from "./preset.mjs";
 import { cwdArgs } from "../cli/index.mjs";
 import { check } from "./check.mjs";
 import process from "node:process";
-import { join, relative, resolve } from "pathe";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "pathe";
 import { defineCommand } from "citty";
 import { consola } from "consola";
 import { addDevDependency, detectPackageManager } from "nypm";

package/dist/_chunks/package.mjs

@@ -1,4 +1,4 @@
 var name = "larrylint";
-var version = "0.2.0";
+var version = "0.2.2";
 var description = "Opinionated rules for Laioutr apps, as an ESLint preset and a CLI.";
 export { description, name, version };

package/dist/_chunks/preset.mjs

@@ -1,8 +1,8 @@
 import { name, version } from "./package.mjs";
 import process from "node:process";
 import { loadConfig } from "c12";
-import { dirname, join, normalize, parse, relative, resolve } from "pathe";
 import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, matchesGlob, normalize, parse, relative, resolve } from "pathe";
 import tsParser, { parse as parse$1 } from "@typescript-eslint/parser";
 import { parse as parse$2 } from "vue-eslint-parser";
 function defineLarrylintConfig(config) {
@@ -19,83 +19,6 @@ async function loadLarrylintConfig(cwd = process.cwd()) {
 	});
 	return { heavyPackages: config.heavyPackages ?? [] };
 }
-const HANDLER_FILE = /\.(query|resolver|link|action|templates?|page-index)(?:\.[cm]?[jt]s)?$/;
-const TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
-const APP_FOLDERS = {
-	"sections": "section",
-	"section": "section",
-	"blocks": "block",
-	"block": "block",
-	"components": "component",
-	"composables": "composable",
-	"utils": "app-util",
-	"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 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"
-	};
-	if (folder === "orchestr") {
-		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",
@@ -107,6 +30,7 @@ const EXTENSIONS = [
 	"/index.ts",
 	"/index.js"
 ];
+const SOURCE_EXTENSION = /\.(?:vue|[cm]?[jt]sx?)$/;
 const directories = /* @__PURE__ */ new Map();
 function cachedReader(parse) {
 	const cache = /* @__PURE__ */ new Map();
@@ -139,6 +63,9 @@ function isDirectory(path) {
 	}
 	return result;
 }
+function withoutExtension(path) {
+	return path.replace(SOURCE_EXTENSION, "");
+}
 function resolveImport(importer, source) {
 	if (!source.startsWith("./") && !source.startsWith("../")) return;
 	const target = resolve(dirname(importer), source.split("?")[0]);
@@ -206,6 +133,182 @@ function applyBaseline(cwd, results) {
 		improved
 	};
 }
+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 parseFile = cachedReader((text) => {
+	try {
+		return parse$1(text, {
+			range: true,
+			loc: true
+		});
+	} catch {
+		return;
+	}
+});
+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);
+}
+const STARTER = {
+	sections: ["app/sections"],
+	blocks: ["app/blocks"],
+	orchestr: ["server/orchestr"],
+	plugins: /* @__PURE__ */ new Set(),
+	references: /* @__PURE__ */ new Set()
+};
+const registrations = /* @__PURE__ */ new WeakMap();
+function readRegistration(root) {
+	const program = parseFile(join(root, "src/module.ts"));
+	if (!program) return STARTER;
+	let registration = registrations.get(program);
+	if (!registration) {
+		registration = readModule(program);
+		registrations.set(program, registration);
+	}
+	return registration;
+}
+function readModule(program) {
+	const apps = [];
+	const plugins = /* @__PURE__ */ new Set();
+	const references = /* @__PURE__ */ new Set();
+	walk(program, (node) => {
+		const reference = node.type === "Literal" || node.type === "TemplateLiteral" ? runtimePath(node) : void 0;
+		if (reference) references.add(withoutExtension(reference));
+		if (node.type !== "CallExpression" || node.callee.type !== "Identifier") return;
+		const [argument] = node.arguments;
+		if (node.callee.name === "registerLaioutrApp" && argument?.type === "ObjectExpression") apps.push(argument);
+		if (node.callee.name === "addPlugin" && argument && argument.type !== "SpreadElement") {
+			const src = argument.type === "ObjectExpression" ? findProperty(argument, "src") : argument;
+			const plugin = src && runtimePath(src);
+			if (plugin) plugins.add(withoutExtension(plugin));
+		}
+	});
+	const [app] = apps;
+	return {
+		sections: app ? readEntries(app, "sections", STARTER.sections) : STARTER.sections,
+		blocks: app ? readEntries(app, "blocks", STARTER.blocks) : STARTER.blocks,
+		orchestr: app ? readEntries(app, "orchestrDirs", STARTER.orchestr) : STARTER.orchestr,
+		plugins,
+		references
+	};
+}
+function readEntries(app, option, fallback) {
+	const value = findProperty(app, option);
+	if (!value) return [];
+	const paths = value.type === "ArrayExpression" ? value.elements.map((element) => element && element.type !== "SpreadElement" ? runtimePath(element) : void 0) : [void 0];
+	const known = paths.filter((path) => path !== void 0);
+	return known.length > 0 || paths.length === 0 ? known : fallback;
+}
+function runtimePath(node) {
+	const parts = [];
+	walk(node, (child) => {
+		if (child.type === "Literal" && typeof child.value === "string") parts.push(child.value);
+		else if (child.type === "TemplateElement" && child.value.cooked) parts.push(child.value.cooked);
+	});
+	const path = normalize(parts.join("/")).replace(/^(?:.*\/)?runtime\//, "").replace(/^\/|\/$/g, "");
+	return /^(?:app|server|shared)\//.test(path) ? path : void 0;
+}
+function isRegistered(path, entries) {
+	return entries.some((entry) => matchesGlob(path, entry.includes(".vue") ? entry : `${entry}/**/*.vue`));
+}
+function entryFolder(entry) {
+	const parts = entry.split("/");
+	const end = parts.findIndex((part) => /[*?{[]/.test(part) || part.endsWith(".vue"));
+	return (end === -1 ? parts : parts.slice(0, end)).join("/");
+}
+function isReferenced(file) {
+	return readRegistration(file.root).references.has(withoutExtension(file.path.replace(/^src\/runtime\//, "")));
+}
+const HANDLER_FILE = /\.(query|resolver|link|action|templates?|page-index)(?:\.[cm]?[jt]s)?$/;
+const TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/;
+const APP_FOLDERS = { components: "component" };
+const SERVER_FOLDERS = { client: "client" };
+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), readRegistration(root))
+		};
+	}
+	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 classifyRuntime(path, registration) {
+	const [side, folder] = path.split("/");
+	if (!folder || side !== "app" && side !== "server" && side !== "shared") return { side: "other" };
+	if (side === "shared") return { side };
+	if (side === "app") {
+		if (isRegistered(path, registration.sections)) return {
+			side,
+			kind: "section"
+		};
+		if (isRegistered(path, registration.blocks)) return {
+			side,
+			kind: "block"
+		};
+		return {
+			side,
+			kind: registration.plugins.has(withoutExtension(path)) ? "app-plugin" : APP_FOLDERS[folder] ?? "other"
+		};
+	}
+	const orchestr = registration.orchestr.find((dir) => path.startsWith(`${dir}/`));
+	if (!orchestr) return {
+		side,
+		kind: SERVER_FOLDERS[folder] ?? "other"
+	};
+	const [first, ...rest] = path.slice(orchestr.length + 1).split("/");
+	if (first === "plugins" && rest.length > 0) return {
+		side,
+		kind: "orchestr-plugin"
+	};
+	const handler = HANDLER_FILE.exec(path)?.[1]?.replace("templates", "template");
+	return {
+		side,
+		kind: handler ? "handler" : "orchestr-file",
+		handler
+	};
+}
 function defineRule(rule) {
 	return {
 		meta: rule.meta,
@@ -331,25 +434,6 @@ function isTested(node) {
 		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";
 }
@@ -396,11 +480,11 @@ function canReturnNullish(fn, value) {
 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." },
+		docs: { description: "Require error handling for awaited or dropped `mutateAsync()` calls" },
 		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()."
+			unhandled: "If this mutation fails, an error replaces the whole section or block. Catch it with try/catch or .catch().",
+			dropped: "Nothing catches errors of this mutation. Add .catch(), or await it in a try/catch."
 		}
 	},
 	applies: (file) => file.side === "app",
@@ -450,16 +534,6 @@ 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;
@@ -607,9 +681,9 @@ function rendersTag(element, tag) {
 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." },
+		docs: { description: "Disallow plain `<a>` tags for internal links" },
 		schema: [],
-		messages: { anchor: "A plain <a> reloads the whole page and breaks Studio's navigation sync. Use <NuxtLink> for internal links." }
+		messages: { anchor: "A plain <a> reloads the whole page. Use <NuxtLink> for internal links." }
 	},
 	applies: (file) => file.side === "app" && file.path.endsWith(".vue"),
 	create: ({ report, visitTemplate }) => {
@@ -646,9 +720,9 @@ 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." },
+		docs: { description: "Disallow page paths built by hand" },
 		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." }
+		messages: { path: "Hand-built page paths differ per language and market. Use linkResolver instead." }
 	},
 	applies: (file) => file.side === "app",
 	create: ({ report, visitTemplate }) => {
@@ -681,11 +755,11 @@ var paths_default = defineRule({
 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." },
+		docs: { description: "Disallow checking the result of `linkResolver.resolve()`" },
 		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."
+			tested: "linkResolver.resolve() never returns an empty value, so this check misses broken links. Use resolveOrThrow() in a try/catch instead.",
+			branch: "linkResolver.resolve() never returns an empty value, so the checks on '{{name}}' miss broken links. Use resolveOrThrow() in a try/catch instead."
 		}
 	},
 	applies: (file) => file.side === "app",
@@ -765,9 +839,9 @@ 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." },
+		docs: { description: "Disallow `type` on ui-kit buttons" },
 		schema: [],
-		messages: { buttonType: "<{{tag}}> ignores type and always renders its button-type prop, which defaults to \"button\". Use button-type." }
+		messages: { buttonType: "<{{tag}}> ignores type. Use button-type instead." }
 	},
 	applies: (file) => file.path.endsWith(".vue"),
 	create: ({ report, visitTemplate }) => {
@@ -861,11 +935,11 @@ const MANAGED = {
 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." },
+		docs: { description: "Require cookies and headers to be set in `extendRequest()` or 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."
+			streamed: "The headers may already be sent when {{name}}() runs here. Call it in extendRequest() or an action handler instead.",
+			managed: "Use {{managed}}() instead, so it also works in the Studio preview."
 		}
 	},
 	applies: (file) => file.side === "server",
@@ -899,12 +973,12 @@ const FILE_START = {
 		column: 0
 	}
 };
-var files_default$1 = defineRule({
+var files_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Keep orchestr/ to handler files, since Laioutr loads every file in it as a Nitro plugin." },
+		docs: { description: "Disallow files other than handlers in `orchestr/`" },
 		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." }
+		messages: { notAHandler: "Only handlers belong in orchestr/. Move this file to server/orchestr-helper/, or give it a handler suffix like .query.ts or .action.ts." }
 	},
 	applies: (file) => file.kind === "orchestr-file",
 	create: ({ report }) => ({ Program: () => {
@@ -917,9 +991,9 @@ var files_default$1 = defineRule({
 var exports_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Require handler files to export their handler as default." },
+		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." }
+		messages: { missingDefault: "Export the handler as default, or it will fail the build." }
 	},
 	applies: (file) => file.kind === "handler",
 	create: ({ report }) => {
@@ -940,47 +1014,14 @@ var exports_default = defineRule({
 		};
 	}
 });
-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"
-				});
-			}
-		};
-	}
-});
 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." },
+		docs: { description: "Disallow throwing in `extendRequest()`" },
 		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."
+			throws: "A throw in extendRequest() breaks every page. Throw later instead, e.g. when the client is used.",
+			throwsInCall: "{{name}}() can throw ({{location}}), and a throw in extendRequest() breaks every page. Catch it here."
 		}
 	},
 	applies: (file) => file.side === "server",
@@ -1034,9 +1075,9 @@ function canonicalNamespaces(root) {
 var namespaces_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Keep your own token ids out of the namespaces of Laioutr's canonical types." },
+		docs: { description: "Disallow your own token ids in 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." }
+		messages: { canonical: "'{{namespace}}/' belongs to Laioutr's canonical types. Use your app's own namespace." }
 	},
 	applies: (file) => file.side === "app" || file.side === "server" || file.side === "shared",
 	create: ({ file, report }) => ({ CallExpression: (node) => {
@@ -1050,28 +1091,14 @@ var namespaces_default = defineRule({
 		});
 	} })
 });
-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 DEFINERS = {
 	defineSection: {
 		kind: "section",
-		folder: "sections"
+		option: "sections"
 	},
 	defineBlock: {
 		kind: "block",
-		folder: "blocks"
+		option: "blocks"
 	}
 };
 const PICKERS = /* @__PURE__ */ new Set([
@@ -1079,10 +1106,10 @@ const PICKERS = /* @__PURE__ */ new Set([
 	"radio",
 	"toggle_button"
 ]);
-const TEXTS$1 = /* @__PURE__ */ new Set([
+const TEXTS = /* @__PURE__ */ new Set([
 	"text",
 	"textarea",
-	"secret"
+	"richtext"
 ]);
 function readDefinition(call) {
 	if (call.callee.type !== "Identifier" || !Object.hasOwn(DEFINERS, call.callee.name)) return;
@@ -1138,7 +1165,7 @@ function expectedDefiner(kind) {
 }
 function fillValue(field, program, filename) {
 	if (field.type === "checkbox") return { value: field.as === "visibility" };
-	if (TEXTS$1.has(field.type ?? "")) return { value: "" };
+	if (TEXTS.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" };
@@ -1155,31 +1182,33 @@ function fillValue(field, program, filename) {
 var description_default = defineRule({
 	meta: {
 		type: "suggestion",
-		docs: { description: "Require a studio.description on section and block definitions." },
+		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." }
+		messages: { description: "Add a studio.description, so editors and AI agents know what this {{kind}} is for." }
 	},
 	applies: (file) => file.side === "app",
 	create: ({ report }) => ({ CallExpression: (node) => {
-		const options = readDefinition(node)?.options;
-		if (!options) return;
-		const studio = findProperty(options, "studio");
+		const definition = readDefinition(node);
+		if (!definition?.options) return;
+		const studio = findProperty(definition.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"
+			messageId: "description",
+			data: { kind: DEFINERS[definition.definer].kind }
 		});
 	} })
 });
 var folder_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Keep defineSection() in app/sections/ and defineBlock() in app/blocks/, and every .vue there defined." },
+		docs: { description: "Require sections and blocks in the folders `module.ts` registers for them, and a definition in every `.vue` registered there" },
 		schema: [],
 		messages: {
-			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}}/."
+			notDefined: "This file is registered as a {{kind}}, so it needs {{definer}}(). Add it, or move the file to components/.",
+			wrongFolder: "{{definer}}() belongs in {{folder}}/. Move the file there.",
+			notRegistered: "module.ts registers no {{kind}}s, so this {{kind}} never shows up in Studio. Add its folder to registerLaioutrApp()."
 		}
 	},
 	applies: (file) => file.side === "app",
@@ -1189,31 +1218,33 @@ var folder_default = defineRule({
 			"CallExpression": (node) => {
 				const definition = readDefinition(node);
 				if (!definition) return;
-				const { kind, folder } = DEFINERS[definition.definer];
+				const { kind, option } = DEFINERS[definition.definer];
 				definers.add(definition.definer);
-				if (file.kind !== kind && file.kind !== "override") report({
+				if (file.kind === kind || isReferenced(file)) return;
+				const [entry] = readRegistration(file.root)[option];
+				report(entry ? {
 					node: node.callee,
 					messageId: "wrongFolder",
 					data: {
 						definer: definition.definer,
-						folder
+						folder: entryFolder(entry)
 					}
+				} : {
+					node: node.callee,
+					messageId: "notRegistered",
+					data: { kind }
 				});
 			},
 			"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
-						}
-					});
-				}
+				if (expected && file.path.endsWith(".vue") && !definers.has(expected)) report({
+					loc: FILE_START,
+					messageId: "notDefined",
+					data: {
+						kind: DEFINERS[expected].kind,
+						definer: expected
+					}
+				});
 			}
 		};
 	}
@@ -1221,7 +1252,7 @@ var folder_default = defineRule({
 var name_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Require the `component` of a section or block definition to match its file name." },
+		docs: { description: "Require the `component` of a definition to match its file name" },
 		schema: [],
 		messages: { componentName: "component: '{{actual}}' must match the file name '{{expected}}'." }
 	},
@@ -1239,20 +1270,23 @@ var name_default = defineRule({
 		});
 	} })
 });
-const TEXTS = /* @__PURE__ */ new Set([
-	"text",
-	"textarea",
-	"secret"
-]);
+const MESSAGES = {
+	checkbox: "checkbox",
+	content_alignment: "alignment",
+	text: "text",
+	textarea: "text",
+	richtext: "text"
+};
 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 ''." },
+		docs: { description: "Disallow `??` fallbacks on fields that frontend-core always fills" },
 		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."
+			picker: "This fallback is never used: an unset {{type}} gets its first option, {{fill}}. To use {{fallback}}, make it the first option.",
+			alignment: "This fallback is never used: an unset content_alignment is {{fill}}. Remove the fallback.",
+			checkbox: "This fallback is never used: an unset checkbox is false. To make true the default, invert the field, e.g. hideIcon instead of showIcon.",
+			text: "An unset {{type}} field is '', so ?? never falls back. Use || instead."
 		}
 	},
 	applies: (file) => file.side === "app" && file.path.endsWith(".vue"),
@@ -1290,7 +1324,7 @@ var fallbacks_default = defineRule({
 				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 messageId = MESSAGES[field.type] ?? "picker";
 					const fill = typeof field.value === "string" ? `'${field.value}'` : String(field.value);
 					report({
 						node,
@@ -1357,9 +1391,9 @@ const NOT_READ = /* @__PURE__ */ new Set([
 var unused_default = defineRule({
 	meta: {
 		type: "suggestion",
-		docs: { description: "Disallow schema fields the section or block never reads." },
+		docs: { description: "Disallow schema fields the component never uses" },
 		schema: [],
-		messages: { unused: "Studio shows '{{name}}' to editors, but the component never reads it. Use the field or remove it." }
+		messages: { unused: "The component never uses '{{name}}'. Use the field or remove it." }
 	},
 	applies: (file) => file.side === "app" && file.path.endsWith(".vue"),
 	create: ({ context, file, report, visitTemplate }) => {
@@ -1412,11 +1446,11 @@ var unused_default = defineRule({
 var casing_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallow top-level schema field names that Vue renames or rejects as props." },
+		docs: { description: "Disallow schema field names that Vue renames or rejects" },
 		schema: [],
 		messages: {
-			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."
+			hyphen: "Vue renames '{{name}}' to '{{suggestion}}', so the component never gets this field. Name it '{{suggestion}}'.",
+			dollar: "Vue doesn't allow props that start with $, so the component never gets this field. Rename it."
 		}
 	},
 	applies: (file) => file.side === "app",
@@ -1440,9 +1474,9 @@ var casing_default = defineRule({
 var required_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallow `required` on schema fields, which Studio doesn't support." },
+		docs: { description: "Disallow `required` on schema fields" },
 		schema: [],
-		messages: { required: "Schema fields have no required option, so Studio ignores it. Give the field a default instead." }
+		messages: { required: "Studio ignores required. Give the field a default instead." }
 	},
 	applies: (file) => file.side === "app",
 	create: ({ report }) => ({ CallExpression: (node) => {
@@ -1467,11 +1501,11 @@ const RESERVED = /* @__PURE__ */ new Set([
 var reserved_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallow top-level schema field names that never reach the component's props." },
+		docs: { description: "Disallow schema field names that Vue or frontend-core already use" },
 		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."
+			reserved: "Vue uses '{{name}}' itself, so the component never gets this field. Rename it.",
+			slots: "frontend-core passes the blocks in the slots prop, so it overwrites this field. Rename it."
 		}
 	},
 	applies: (file) => file.side === "app",
@@ -1506,29 +1540,31 @@ 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." },
+		docs: { description: "Require sections and blocks to render one root element" },
 		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."
+			roots: "Studio can't select a {{kind}} with more than one root element. Wrap the content in one element.",
+			componentRoots: "<{{name}}> has more than one root element, so Studio can't select this {{kind}}. Give it one root, or wrap it here."
 		}
 	},
 	applies: (file) => file.side === "app" && file.path.endsWith(".vue"),
 	create: ({ context, report }) => {
-		let defined = false;
+		let kind;
 		return {
 			"CallExpression": (node) => {
-				defined ||= readDefinition(node) !== void 0;
+				const definition = readDefinition(node);
+				kind ??= definition && DEFINERS[definition.definer].kind;
 			},
 			"Program:exit": () => {
 				const program = context.sourceCode.ast;
 				const template = program.templateBody;
-				if (!defined || !template || OWN_ATTRS.test(context.sourceCode.text)) return;
+				if (!kind || !template || OWN_ATTRS.test(context.sourceCode.text)) return;
 				const [root, second] = renderedRoots(template);
 				if (second) {
 					report({
 						loc: second.startTag.loc,
-						messageId: "roots"
+						messageId: "roots",
+						data: { kind }
 					});
 					return;
 				}
@@ -1538,7 +1574,10 @@ var root_default = defineRule({
 				if (root && componentTemplate && renderedRoots(componentTemplate).length > 1 && !OWN_ATTRS.test(component.text)) report({
 					loc: root.startTag.loc,
 					messageId: "componentRoots",
-					data: { name: root.rawName }
+					data: {
+						name: root.rawName,
+						kind
+					}
 				});
 			}
 		};
@@ -1547,9 +1586,9 @@ var root_default = defineRule({
 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." },
+		docs: { description: "Disallow counting the blocks of a slot with `.length`" },
 		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." }
+		messages: { length: "For blocks, this is always 1: frontend-core passes them as one Fragment. Count the Fragment's children instead." }
 	},
 	applies: (file) => file.side === "app",
 	create: ({ report, visitTemplate }) => {
@@ -1578,7 +1617,7 @@ var slots_default = defineRule({
 var bundle_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallow static imports of heavy packages in sections, blocks and plugins, which every page loads." },
+		docs: { description: "Disallow static imports of heavy packages in sections, blocks and plugins" },
 		schema: [{
 			type: "object",
 			properties: { packages: {
@@ -1587,7 +1626,7 @@ var bundle_default = defineRule({
 			} },
 			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." }
+		messages: { heavy: "This loads '{{name}}' on every page. Load it with import() or defineAsyncComponent() instead." }
 	},
 	applies: (file) => file.kind === "section" || file.kind === "block" || file.kind === "app-plugin",
 	create: ({ context, report }) => {
@@ -1632,9 +1671,9 @@ function setupOptions(node) {
 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." },
+		docs: { description: "Require runtime config keys to be this package 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." }
+		messages: { key: "'{{key}}' isn't this package or one of its dependencies, so this config is undefined." }
 	},
 	applies: (file) => file.side === "app" || file.side === "server" || file.side === "shared",
 	create: ({ file, report }) => {
@@ -1659,9 +1698,9 @@ var keys_default = defineRule({
 var public_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallow copying module options into the public runtime config, which reaches the browser." },
+		docs: { description: "Disallow copying all module options into the public runtime config" },
 		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." }
+		messages: { options: "This sends all module options to the browser, secrets included. Copy only the public ones, e.g. options.storefrontUrl." }
 	},
 	applies: (file) => file.side === "build",
 	create: ({ report }) => ({ AssignmentExpression: (node) => {
@@ -1679,82 +1718,37 @@ var public_default = defineRule({
 		});
 	} })
 });
-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"
-]);
 function findViolation(importer, target, typeOnly) {
+	if (typeOnly) return;
 	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.side === "build") return { messageId: "runtimeImportsBuild" };
 	if (target.kind === "handler") return { messageId: "handlerImported" };
-	if (typeOnly) return;
 	if (target.kind === "client" && importer.kind === "handler") return { messageId: "clientInHandler" };
-	if (importer.kind === "server-util" && ABOVE_SERVER_UTILS.has(target.kind)) return {
-		messageId: "serverUtilImportsUp",
-		data: { kind: LABELS[target.kind] }
-	};
-	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" || target.kind === "block")) return {
+		messageId: "schemaInComponent",
+		data: { kind: target.kind }
 	};
-	if (importer.kind === "component" && target.kind === "section") return { messageId: "componentImportsSection" };
 }
+const SERVER_ONLY = /\.server\.[^/]+$/;
 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." },
+		docs: { description: "Enforce which parts of a Laioutr app can import each other" },
 		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/."
+			appImportsServer: "App code can't import server code. Move what both need to src/runtime/shared/.",
+			serverImportsApp: "Server code can't import app code. Move what both need to src/runtime/shared/.",
+			sharedImportsSide: "Shared code can't import from {{side}}/.",
+			runtimeImportsBuild: "Runtime code can't import build code from src/, like module.ts. Type imports are fine.",
+			handlerImported: "Don't import orchestr handlers. Move the code you need to server/orchestr-helper/.",
+			clientInHandler: "Handlers get API clients from the orchestr context, not by import. Move constants to server/const/ and helpers to server/orchestr-helper/.",
+			schemaInComponent: "Components can't import {{kind}}s.",
+			nodeBuiltin: "'{{name}}' only works on the server. Move this code to server/."
 		}
 	},
 	applies: (file) => file.side === "app" || file.side === "server" || file.side === "shared",
@@ -1762,7 +1756,7 @@ var layers_default = defineRule({
 		const checkImport = (node, source, typeOnly) => {
 			if (typeof source !== "string") return;
 			if (source.startsWith("node:")) {
-				if (importer.side !== "server" && !typeOnly) report({
+				if (importer.side !== "server" && !typeOnly && !SERVER_ONLY.test(importer.path)) report({
 					node,
 					messageId: "nodeBuiltin",
 					data: { name: source }
@@ -1803,10 +1797,9 @@ const plugin = {
 		"heavy-imports": bundle_default,
 		"config-keys": keys_default,
 		"public-config": public_default,
-		"orchestr-files": files_default$1,
+		"orchestr-files": files_default,
 		"orchestr-cookies": cookies_default,
 		"handler-exports": exports_default,
-		"middleware-files": files_default,
 		"initware-throws": throws_default,
 		"token-namespaces": namespaces_default,
 		"definition-folder": folder_default,

package/dist/index.d.mts

@@ -34,7 +34,6 @@ export declare const plugin: {
     'orchestr-files': import("eslint").Rule.RuleModule;
     'orchestr-cookies': import("eslint").Rule.RuleModule;
     'handler-exports': import("eslint").Rule.RuleModule;
-    'middleware-files': import("eslint").Rule.RuleModule;
     'initware-throws': import("eslint").Rule.RuleModule;
     'token-namespaces': import("eslint").Rule.RuleModule;
     'definition-folder': import("eslint").Rule.RuleModule;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "larrylint",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Opinionated rules for Laioutr apps, as an ESLint preset and a CLI.",
   "author": "Frederik Bußmann <frederik@bussmann.io>",
   "license": "MIT",