larrylint 0.2.1 → 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/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 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,7 +47,6 @@ 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 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. |
 
@@ -55,7 +54,7 @@ Type imports are fine across most layers, since they don't end up in the bundle.
 
 | 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-*` attributes Studio needs to select them in the preview. |
@@ -78,35 +77,31 @@ Type imports are fine across most layers, since they don't end up in the bundle.
 
 ## 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/package.mjs

@@ -1,4 +1,4 @@
 var name = "larrylint";
-var version = "0.2.1";
+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

@@ -2,7 +2,7 @@ import { name, version } from "./package.mjs";
 import process from "node:process";
 import { loadConfig } from "c12";
 import { existsSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, normalize, parse, relative, resolve } from "pathe";
+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) {
@@ -30,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();
@@ -62,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]);
@@ -129,31 +133,123 @@ 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 = {
-	"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"
-};
+const APP_FOLDERS = { components: "component" };
+const SERVER_FOLDERS = { client: "client" };
 function classify(file) {
 	const absolute = normalize(file);
 	const test = TEST_FILE.test(absolute);
@@ -164,7 +260,7 @@ function classify(file) {
 			root,
 			path: absolute.slice(root.length + 1),
 			test,
-			...classifyRuntime(absolute.slice(runtimeIndex + 13).split("/"))
+			...classifyRuntime(absolute.slice(runtimeIndex + 13), readRegistration(root))
 		};
 	}
 	const srcIndex = absolute.lastIndexOf("/src/");
@@ -178,33 +274,40 @@ function classify(file) {
 		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 {
+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: "orchestr-plugin"
+			kind: "block"
 		};
-		const handler = HANDLER_FILE.exec(parts.at(-1))?.[1]?.replace("templates", "template");
 		return {
 			side,
-			kind: handler ? "handler" : "orchestr-file",
-			handler
+			kind: registration.plugins.has(withoutExtension(path)) ? "app-plugin" : APP_FOLDERS[folder] ?? "other"
 		};
 	}
-	return {
+	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 {
@@ -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";
 }
@@ -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;
@@ -899,12 +973,12 @@ const FILE_START = {
 		column: 0
 	}
 };
-var files_default$1 = defineRule({
+var files_default = defineRule({
 	meta: {
 		type: "problem",
 		docs: { description: "Disallow files other than handlers in `orchestr/`" },
 		schema: [],
-		messages: { notAHandler: "Only handlers belong in orchestr/. Move this file to server/utils/, or give it a handler suffix like .query.ts or .action.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: () => {
@@ -940,39 +1014,6 @@ var exports_default = defineRule({
 		};
 	}
 });
-const MIDDLEWARE = /* @__PURE__ */ new Set([
-	"defineOrchestr",
-	"defineEventHandler",
-	"eventHandler",
-	"defineRequestMiddleware",
-	"fromNodeMiddleware"
-]);
-var files_default = defineRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Disallow files other than middleware in `server/middleware/`" },
-		schema: [],
-		messages: { helper: "Only middleware belongs in server/middleware/. Move this file 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",
@@ -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([
@@ -1082,7 +1109,7 @@ const PICKERS = /* @__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;
@@ -1176,11 +1203,12 @@ var description_default = defineRule({
 var folder_default = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Require sections in `app/sections/` and blocks in `app/blocks/`, and a definition in every `.vue` there" },
+		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: "Every .vue file in this folder needs {{definer}}(). Add it, or move the file to components/.",
-			wrongFolder: "{{definer}}() belongs in app/{{folder}}/. Move the file there."
+			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",
@@ -1190,15 +1218,21 @@ 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": () => {
@@ -1206,7 +1240,10 @@ var folder_default = defineRule({
 				if (expected && file.path.endsWith(".vue") && !definers.has(expected)) report({
 					loc: FILE_START,
 					messageId: "notDefined",
-					data: { definer: expected }
+					data: {
+						kind: DEFINERS[expected].kind,
+						definer: expected
+					}
 				});
 			}
 		};
@@ -1238,7 +1275,7 @@ const MESSAGES = {
 	content_alignment: "alignment",
 	text: "text",
 	textarea: "text",
-	secret: "text"
+	richtext: "text"
 };
 var fallbacks_default = defineRule({
 	meta: {
@@ -1681,65 +1718,23 @@ var public_default = defineRule({
 		});
 	} })
 });
-const LABELS = {
-	"section": "sections",
-	"block": "blocks",
-	"component": "components",
-	"composable": "composables",
-	"app-plugin": "plugins",
-	"override": "overrides",
-	"route": "API routes",
-	"nitro-plugin": "Nitro plugins",
-	"orchestr-plugin": "orchestr plugins",
-	"orchestr-file": "orchestr files",
-	"media-library": "media libraries"
-};
-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",
@@ -1750,12 +1745,9 @@ var layers_default = defineRule({
 			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/utils/.",
-			clientInHandler: "Handlers get API clients from the orchestr context, not by import. Move other code to server/utils/.",
-			serverUtilImportsUp: "Server utils can't import {{kind}}. Type imports are fine.",
-			appUtilImportsUp: "App utils can't import {{kind}}. Type imports are fine.",
-			composableImportsUp: "Composables can't import {{kind}}. Type imports are fine.",
-			componentImportsSection: "Components can't import sections.",
+			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/."
 		}
 	},
@@ -1764,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 }
@@ -1805,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.1",
+  "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",