larrylint 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Frederik Bußmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+# 🦙 larrylint
+
+[![Github Actions][github-actions-src]][github-actions-href]
+[![NPM version][npm-version-src]][npm-version-href]
+[![NPM last update][npm-last-update-src]][npm-last-update-href]
+[![License][license-src]][license-href]
+
+Opinionated structure rules for [Laioutr](https://laioutr.com) apps: an ESLint preset for your editor and a CLI for CI.
+
+Laioutr apps are Nuxt modules with a lot of moving parts: sections and blocks, orchestr handlers, middleware, API clients, server routes. larrylint keeps them where they belong and stops the imports that make a codebase drift, like app code pulling in server code, handlers importing each other, or one business domain reaching into another.
+
+## Usage
+
+Check the Laioutr app in the current folder. No install and no config needed:
+
+```sh
+npx larrylint
+```
+
+Set it up for good. This installs larrylint, adds its rules to your `eslint.config`, and records existing violations in a baseline so only new code has to follow the rules:
+
+```sh
+npx larrylint init
+```
+
+After that, `eslint .` and your editor report larrylint's rules next to your own.
+
+## Rules
+
+| Rule                           | What it checks                                                                                                                                                                                                                                                                                                                        |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `larrylint/layers`             | App code doesn't import server code and vice versa; shared code imports neither. Runtime code doesn't import build-time code. Nothing imports orchestr handlers. Handlers and server utils don't import from `server/client/`, and only handlers and media libraries import middleware. Utils are the bottom layer. Domains stay apart. |
+| `larrylint/orchestr-files`     | Laioutr loads every file in `orchestr/` as a server plugin, so only handler files belong there, in a domain folder, exporting nothing but their handler.                                                                                                                                                                              |
+| `larrylint/definitions`        | `defineSection()` lives in `app/sections/Section*.vue`, `defineBlock()` in `app/blocks/Block*.vue`, with a `component` name that matches the file and no top-level schema fields named `style`, `class`, `key`, `ref`, `is`, `slot`, `refFor` or `refKey`, which Vue swallows before they reach the component.                                                                                                                                                                                    |
+| `larrylint/button-type`        | No `type` on the ui-kit button: it always renders its `button-type` prop, so `type="submit"` silently renders a dead button. Autofixable.                                                                                                                                                                                             |
+
+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):
+
+```
+src/
+├── module.ts                  # build time
+└── runtime/
+    ├── app/
+    │   ├── sections/          # Section*.vue with defineSection()
+    │   ├── blocks/            # Block*.vue with defineBlock()
+    │   ├── components/
+    │   ├── composables/
+    │   ├── overrides/         # replacements for upstream components
+    │   ├── plugins/
+    │   └── utils/
+    ├── server/
+    │   ├── orchestr/
+    │   │   ├── <domain>/      # *.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
+    │   ├── plugins/           # Nitro plugins
+    │   ├── media-library/
+    │   └── utils/
+    │       └── <domain>/
+    └── shared/                # code for both the app and the server
+```
+
+A domain is a folder in `server/orchestr/`, together with the `server/utils/` folder of the same name. Other folders in `server/utils/`, like `tracking/`, hold shared helpers that every domain may use.
+
+## 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.
+
+After fixing old violations, shrink the baseline:
+
+```sh
+npx larrylint --baseline
+```
+
+## Configuration
+
+Most apps need none. To let every domain import a domain, add it to `sharedDomains` in your `package.json`:
+
+```json
+{
+  "larrylint": {
+    "sharedDomains": ["product"]
+  }
+}
+```
+
+Or in a `larrylint.config.ts`:
+
+```ts
+import { defineLarrylintConfig } from 'larrylint'
+
+export default defineLarrylintConfig({
+  sharedDomains: ['product'],
+})
+```
+
+## ESLint
+
+`larrylint init` adds the rules to your `eslint.config` for you. To do it by hand with `@nuxt/eslint-config` or `@antfu/eslint-config`:
+
+```js
+import { createConfigForNuxt } from '@nuxt/eslint-config/flat'
+import larrylint from 'larrylint'
+
+export default createConfigForNuxt().append(larrylint())
+```
+
+With a plain array, like `@laioutr/eslint-config`:
+
+```js
+import config from '@laioutr/eslint-config/nuxt-module'
+import larrylint from 'larrylint'
+
+export default [...config, ...(await larrylint())]
+```
+
+The preset only brings rules, no parsers or style rules, so it runs on top of whatever your config already uses.
+
+## CLI
+
+```sh
+larrylint [--cwd <folder>] [--fix] [--baseline]
+larrylint init [--cwd <folder>]
+```
+
+- `--fix` fixes what can be fixed automatically.
+- `--baseline` records the current violations in `larrylint-baseline.json`.
+
+The CLI only runs larrylint's rules, independent of your ESLint setup, and exits with code 1 on new violations.
+
+## License
+
+Published under the [MIT License](https://github.com/bussmann-io/larrylint/tree/main/LICENSE).
+
+[github-actions-src]: https://github.com/bussmann-io/larrylint/actions/workflows/test.yml/badge.svg
+[github-actions-href]: https://github.com/bussmann-io/larrylint/actions
+
+[npm-version-src]: https://img.shields.io/npm/v/larrylint/latest.svg?style=flat&colorA=18181B&colorB=31C553
+[npm-version-href]: https://npmjs.com/package/larrylint
+
+[npm-last-update-src]: https://img.shields.io/npm/last-update/larrylint.svg?style=flat&colorA=18181B&colorB=31C553
+[npm-last-update-href]: https://npmjs.com/package/larrylint
+
+[license-src]: https://img.shields.io/github/license/bussmann-io/larrylint.svg?style=flat&colorA=18181B&colorB=31C553
+[license-href]: https://github.com/bussmann-io/larrylint/tree/main/LICENSE

package/dist/_chunks/check.mjs

@@ -0,0 +1,76 @@
+import { larrylint, readBaseline } from "./preset.mjs";
+import { relative } from "pathe";
+import tsParser from "@typescript-eslint/parser";
+import { ESLint } from "eslint";
+import vueParser from "vue-eslint-parser";
+const PARSERS = [
+	{ ignores: ["**/*.d.ts"] },
+	{
+		files: ["**/*.{ts,mts,cts}"],
+		languageOptions: { parser: tsParser }
+	},
+	{
+		files: ["**/*.vue"],
+		languageOptions: {
+			parser: vueParser,
+			parserOptions: {
+				parser: tsParser,
+				extraFileExtensions: [".vue"]
+			}
+		}
+	}
+];
+async function check(cwd, options = {}) {
+	const eslint = new ESLint({
+		cwd,
+		overrideConfigFile: true,
+		overrideConfig: [
+			...PARSERS,
+			...await larrylint({ cwd }),
+			{
+				linterOptions: { reportUnusedDisableDirectives: "off" },
+				settings: { larrylint: { baseline: false } }
+			}
+		],
+		fix: options.fix,
+		errorOnUnmatchedPattern: false
+	});
+	const results = await eslint.lintFiles(["src"]);
+	if (options.fix) await ESLint.outputFixes(results);
+	return {
+		eslint,
+		...applyBaseline(cwd, results)
+	};
+}
+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
+	};
+}
+export { check };

package/dist/_chunks/check2.mjs

@@ -0,0 +1,50 @@
+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 { existsSync } from "node:fs";
+import { join, resolve } from "pathe";
+import { defineCommand } from "citty";
+import { consola } from "consola";
+var check_default = defineCommand({
+	meta: {
+		name: "check",
+		description: "Check the Laioutr app in the current folder."
+	},
+	args: {
+		...cwdArgs,
+		fix: {
+			type: "boolean",
+			description: "Fix what can be fixed automatically."
+		},
+		baseline: {
+			type: "boolean",
+			description: `Record all current violations in ${BASELINE_FILE}, so only new ones fail.`
+		}
+	},
+	run: async ({ args }) => {
+		const cwd = resolve(args.cwd);
+		if (!existsSync(join(cwd, "src/runtime"))) {
+			consola.warn(`No src/runtime/ in ${cwd}. larrylint checks Laioutr apps, run it in the app's folder.`);
+			process.exitCode = 1;
+			return;
+		}
+		const { eslint, results, violations, baselined, improved } = await check(cwd, { fix: args.fix });
+		if (args.baseline) {
+			writeBaseline(cwd, violations);
+			const total = countViolations(violations);
+			consola.success(total > 0 ? `Recorded ${total} violations in ${Object.keys(violations).length} files in ${BASELINE_FILE}.` : "No violations, nothing to record.");
+			return;
+		}
+		const output = await (await eslint.loadFormatter("stylish")).format(results);
+		if (output) process.stdout.write(`${output}\n`);
+		if (baselined > 0) consola.info(`${baselined} known violations are recorded in ${BASELINE_FILE}.`);
+		if (improved > 0) consola.info(`${improved} baseline entries have fewer violations now. Run larrylint --baseline to lock that in.`);
+		if (results.some((result) => result.errorCount > 0)) {
+			process.exitCode = 1;
+			return;
+		}
+		consola.success(baselined > 0 ? "No new violations." : "No violations.");
+	}
+});
+export { check_default as default };

package/dist/_chunks/init.mjs

@@ -0,0 +1,149 @@
+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 { 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";
+import { readPackageJSON } from "pkg-types";
+import { parseModule } from "magicast";
+const CONFIG_FILES = [
+	"eslint.config.js",
+	"eslint.config.mjs",
+	"eslint.config.cjs",
+	"eslint.config.ts",
+	"eslint.config.mts",
+	"eslint.config.cts"
+];
+const COMPOSERS = /^(?:@nuxt\/eslint-config(?:\/flat)?|@antfu\/eslint-config|eslint-flat-config-utils)$|\/\.nuxt\/eslint\.config\.mjs$/;
+const CONFIG_FUNCTIONS = /* @__PURE__ */ new Set(["defineConfig", "extendConfig"]);
+const NEW_ESLINT_CONFIG = `import larrylint from 'larrylint'\n\nexport default larrylint()\n`;
+const MANUAL_SNIPPET = `import larrylint from 'larrylint'
+
+export default [
+  // ...your config
+  ...(await larrylint()),
+]`;
+function wireEslintConfig(cwd) {
+	const file = CONFIG_FILES.map((name) => join(cwd, name)).find((path) => existsSync(path));
+	if (!file) {
+		const created = join(cwd, "eslint.config.mjs");
+		writeFileSync(created, NEW_ESLINT_CONFIG);
+		return {
+			status: "created",
+			file: created
+		};
+	}
+	const result = addLarrylint(readFileSync(file, "utf8"));
+	if (typeof result === "string") {
+		writeFileSync(file, result);
+		return {
+			status: "updated",
+			file
+		};
+	}
+	return {
+		status: result,
+		file
+	};
+}
+function addLarrylint(code) {
+	const mod = parseModule(code);
+	const imports = Object.values(mod.imports);
+	if (imports.some((item) => item.from === "larrylint")) return "present";
+	const body = mod.$ast.body;
+	const exported = body.find((node) => node.type === "ExportDefaultDeclaration")?.declaration;
+	let edit;
+	if (exported?.type === "ArrayExpression") edit = appendItem(code, exported, exported.elements, "...(await larrylint())");
+	else if (exported?.type === "CallExpression" && isComposer(exported, imports)) {
+		const indent = code.slice(exported.start, exported.end).match(/\n([ \t]*)\.[a-z]/i)?.[1];
+		edit = {
+			start: exported.end,
+			end: exported.end,
+			text: `${indent === void 0 ? "" : `\n${indent}`}.append(larrylint())`
+		};
+	} else if (exported?.type === "CallExpression" && exported.callee.type === "Identifier" && CONFIG_FUNCTIONS.has(exported.callee.name)) edit = appendItem(code, exported, exported.arguments, "await larrylint()");
+	else if (exported?.type === "Identifier") edit = extendBinding(body, exported, imports);
+	if (!edit) return "unknown";
+	const lastImport = body.filter((node) => node.type === "ImportDeclaration").at(-1);
+	const importLine = `import larrylint from 'larrylint'${(lastImport ? code.slice(lastImport.start, lastImport.end).endsWith(";") : false) ? ";" : ""}`;
+	let result = `${code.slice(0, edit.start)}${edit.text}${code.slice(edit.end)}`;
+	result = lastImport ? `${result.slice(0, lastImport.end)}\n${importLine}${result.slice(lastImport.end)}` : `${importLine}\n\n${result}`;
+	return result;
+}
+function extendBinding(body, identifier, imports) {
+	const imported = imports.find((item) => item.local === identifier.name);
+	const declared = body.flatMap((node) => node.type === "VariableDeclaration" ? node.declarations : []).find((declarator) => declarator.id.name === identifier.name);
+	return (imported ? COMPOSERS.test(imported.from) : declared?.init?.type === "CallExpression" && isComposer(declared.init, imports)) ? {
+		start: identifier.end,
+		end: identifier.end,
+		text: ".append(larrylint())"
+	} : {
+		start: identifier.start,
+		end: identifier.end,
+		text: `[...${identifier.name}, ...(await larrylint())]`
+	};
+}
+function isComposer(call, imports) {
+	let node = call;
+	while (node.callee.type === "MemberExpression" && node.callee.object.type === "CallExpression") node = node.callee.object;
+	const factory = node.callee.type === "Identifier" ? imports.find((item) => item.local === node.callee.name) : void 0;
+	return factory ? COMPOSERS.test(factory.from) : false;
+}
+function appendItem(code, container, items, text) {
+	const closing = container.end - 1;
+	const last = items.at(-1);
+	const insert = (at, insertion) => ({
+		start: at,
+		end: at,
+		text: insertion
+	});
+	if (!last) return insert(closing, text);
+	if (!code.slice(container.start, container.end).includes("\n")) return insert(last.end, `, ${text}`);
+	const indent = code.slice(code.lastIndexOf("\n", last.start) + 1, last.start).match(/^[ \t]*/)[0];
+	const comma = code.indexOf(",", last.end);
+	return comma !== -1 && comma < closing ? insert(comma + 1, `\n${indent}${text},`) : insert(last.end, `,\n${indent}${text}`);
+}
+var init_default = defineCommand({
+	meta: {
+		name: "init",
+		description: "Set up larrylint in the Laioutr app in the current folder."
+	},
+	args: cwdArgs,
+	run: async ({ args }) => {
+		const cwd = resolve(args.cwd);
+		if (!existsSync(join(cwd, "package.json")) || !existsSync(join(cwd, "src/runtime"))) {
+			consola.error(`${cwd} doesn't look like a Laioutr app: it needs a package.json and a src/runtime/ folder.`);
+			process.exitCode = 1;
+			return;
+		}
+		const pkg = await readPackageJSON(cwd);
+		if (pkg.dependencies?.larrylint || pkg.devDependencies?.larrylint) consola.info("larrylint is already installed.");
+		else {
+			const packageManager = await detectPackageManager(cwd);
+			const workspace = packageManager?.name === "pnpm" ? existsSync(join(cwd, "pnpm-workspace.yaml")) : packageManager?.name === "yarn" && Boolean(pkg.workspaces);
+			consola.start("Installing larrylint...");
+			await addDevDependency("larrylint", {
+				cwd,
+				packageManager,
+				workspace,
+				silent: true
+			});
+			consola.success("Installed larrylint.");
+		}
+		const wired = wireEslintConfig(cwd);
+		const file = relative(cwd, wired.file);
+		if (wired.status === "created") consola.success(`Created ${file} with the larrylint rules.`);
+		else if (wired.status === "updated") consola.success(`Added the larrylint rules to ${file}.`);
+		else if (wired.status === "present") consola.info(`${file} already uses larrylint.`);
+		else consola.warn(`Couldn't add larrylint to ${file} automatically. Add it like this:\n\n${MANUAL_SNIPPET}\n`);
+		const { violations } = await check(cwd);
+		writeBaseline(cwd, violations);
+		const total = countViolations(violations);
+		if (total > 0) consola.info(`Recorded ${total} existing violations in ${Object.keys(violations).length} files in ${BASELINE_FILE}. New code has to follow the rules; run larrylint --baseline after fixing old violations.`);
+		else consola.success("No violations found.");
+	}
+});
+export { init_default as default };

package/dist/_chunks/package.mjs

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

package/dist/_chunks/preset.mjs

@@ -0,0 +1,586 @@
+import { name, version } from "./package.mjs";
+import process from "node:process";
+import { loadConfig } from "c12";
+import { readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, normalize, resolve } from "pathe";
+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 ?? [] };
+}
+const BASELINE_FILE = "larrylint-baseline.json";
+const cache = /* @__PURE__ */ new Map();
+function readBaseline(root) {
+	const file = join(root, BASELINE_FILE);
+	let mtimeMs;
+	try {
+		mtimeMs = statSync(file).mtimeMs;
+	} catch {
+		return {};
+	}
+	const cached = cache.get(file);
+	if (cached?.mtimeMs === mtimeMs) return cached.baseline;
+	const baseline = JSON.parse(readFileSync(file, "utf8"));
+	cache.set(file, {
+		mtimeMs,
+		baseline
+	});
+	return baseline;
+}
+function writeBaseline(root, baseline) {
+	const file = join(root, BASELINE_FILE);
+	const files = Object.keys(baseline).sort();
+	if (files.length === 0) {
+		rmSync(file, { force: true });
+		return;
+	}
+	const sorted = {};
+	for (const path of files) sorted[path] = Object.fromEntries(Object.entries(baseline[path]).sort(([a], [b]) => a.localeCompare(b)));
+	writeFileSync(file, `${JSON.stringify(sorted, null, 2)}\n`);
+}
+function countViolations(baseline) {
+	return Object.values(baseline).flatMap((rules) => Object.values(rules)).reduce((sum, count) => sum + count, 0);
+}
+function createReporter(context, file) {
+	const reports = [];
+	return {
+		report: (descriptor) => {
+			reports.push(descriptor);
+		},
+		flush: () => {
+			const settings = context.settings.larrylint;
+			const allowed = file && settings?.baseline !== false ? readBaseline(file.root)[file.path]?.[context.id] ?? 0 : 0;
+			if (reports.length > allowed) for (const descriptor of reports) context.report(descriptor);
+			reports.length = 0;
+		}
+	};
+}
+const directories = /* @__PURE__ */ new Map();
+function isDirectory(path) {
+	let result = directories.get(path);
+	if (result === void 0) {
+		try {
+			result = statSync(path).isDirectory();
+		} catch {
+			result = false;
+		}
+		directories.set(path, result);
+	}
+	return result;
+}
+function resolveImport(importer, source) {
+	if (!source.startsWith("./") && !source.startsWith("../")) return;
+	const target = resolve(dirname(importer), source.split("?")[0]);
+	return isDirectory(target) ? `${target}/index` : target;
+}
+const HANDLER_FILE = /\.(?:query|resolver|link|action|template|page-index)(?:\.[cm]?[jt]s)?$/;
+const 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"
+};
+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"
+		};
+		return {
+			side,
+			kind: HANDLER_FILE.test(parts.at(-1)) ? "handler" : "orchestr-file",
+			domain: nested ? rest[0] : void 0
+		};
+	}
+	const kind = SERVER_FOLDERS[folder] ?? "other";
+	return {
+		side,
+		kind,
+		domain: kind === "server-util" && nested ? rest[0] : void 0
+	};
+}
+function kebabCase(name) {
+	return name.replace(/([a-z\d])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+}
+function prefixName(name, prefix) {
+	return `${prefix}${name.endsWith(prefix) ? name.slice(0, -prefix.length) : name}`;
+}
+const UI_KIT_BUTTON = /(?:^#ui-kit|@laioutr-core\/ui-kit)\/.*\/Button\.vue$/;
+const button = {
+	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." }
+	},
+	create(context) {
+		const services = context.sourceCode.parserServices;
+		if (!services?.defineTemplateBodyVisitor) return {};
+		const file = classify(context.filename);
+		if (file?.test) return {};
+		const reporter = createReporter(context, file);
+		const buttons = /* @__PURE__ */ new Set(["LButton", "l-button"]);
+		return services.defineTemplateBodyVisitor({
+			"VElement": (node) => {
+				if (!buttons.has(node.rawName)) return;
+				for (const attribute of node.startTag.attributes) {
+					if (!attribute.directive && attribute.key.rawName === "type") {
+						const key = attribute.key;
+						reporter.report({
+							loc: key.loc,
+							messageId: "buttonType",
+							fix: (fixer) => fixer.replaceTextRange(key.range, "button-type")
+						});
+					}
+					const argument = attribute.directive ? attribute.key.argument : null;
+					if (attribute.directive && attribute.key.name.name === "bind" && argument?.type === "VIdentifier" && argument.rawName === "type") reporter.report({
+						loc: argument.loc,
+						messageId: "buttonType",
+						fix: (fixer) => fixer.replaceTextRange(argument.range, "button-type")
+					});
+				}
+			},
+			"VElement:exit": (node) => {
+				if (node.parent.type === "VDocumentFragment") reporter.flush();
+			}
+		}, { ImportDeclaration: (node) => {
+			if (typeof node.source.value !== "string" || !UI_KIT_BUTTON.test(node.source.value)) return;
+			for (const specifier of node.specifiers) if (specifier.type === "ImportDefaultSpecifier") {
+				const kebab = kebabCase(specifier.local.name);
+				buttons.add(specifier.local.name);
+				if (kebab.includes("-")) buttons.add(kebab);
+			}
+		} });
+	}
+};
+const FILE_START = {
+	start: {
+		line: 1,
+		column: 0
+	},
+	end: {
+		line: 1,
+		column: 0
+	}
+};
+function findProperty(object, key) {
+	for (const entry of object.properties) if (entry.type === "Property" && !entry.computed && (entry.key.type === "Identifier" && entry.key.name === key || entry.key.type === "Literal" && entry.key.value === key)) return entry.value;
+}
+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",
+		prefix: "Section"
+	},
+	defineBlock: {
+		kind: "block",
+		folder: "blocks",
+		prefix: "Block"
+	}
+};
+const FORBIDDEN_FIELD_NAMES = /* @__PURE__ */ new Set([
+	"style",
+	"class",
+	"key",
+	"ref",
+	"is",
+	"slot",
+	"refFor",
+	"refKey"
+]);
+const definition = {
+	meta: {
+		type: "problem",
+		docs: { description: "Keep defineSection() in app/sections/Section*.vue and defineBlock() in app/blocks/Block*.vue, with a matching component name and schema fields that reach the component." },
+		schema: [],
+		messages: {
+			notDefined: "Laioutr registers every .vue in {{folder}}/ as a Studio {{kind}}, but this file has no {{definer}}(). Move it to components/.",
+			wrongFolder: "{{definer}}() belongs in app/{{folder}}/.",
+			prefix: "Name {{kind}}s {{prefix}}*.vue, e.g. {{suggestion}}.vue.",
+			componentName: "component: '{{actual}}' must match the file name '{{expected}}'.",
+			forbiddenFieldName: "Vue consumes '{{name}}' before it reaches the component, so this field never arrives as a prop. Pick another name, e.g. variant for a style selector."
+		}
+	},
+	create(context) {
+		const file = classify(context.filename);
+		if (!file || file.test || file.side !== "app") return {};
+		const reporter = createReporter(context, file);
+		const name = basename(file.path).replace(/\.[^.]+$/, "");
+		const calls = [];
+		return {
+			"CallExpression": (node) => {
+				if (node.callee.type === "Identifier" && Object.hasOwn(DEFINERS, node.callee.name)) calls.push({
+					definer: node.callee.name,
+					node
+				});
+			},
+			"Program:exit": () => {
+				const expected = Object.keys(DEFINERS).find((definer) => DEFINERS[definer].kind === file.kind);
+				if (expected && file.path.endsWith(".vue") && !calls.some((call) => call.definer === expected)) {
+					const { kind, folder } = DEFINERS[expected];
+					reporter.report({
+						loc: FILE_START,
+						messageId: "notDefined",
+						data: {
+							folder,
+							kind,
+							definer: expected
+						}
+					});
+				}
+				for (const { definer, node } of calls) {
+					const { kind, folder, prefix } = DEFINERS[definer];
+					if (file.kind !== kind && file.kind !== "override") reporter.report({
+						node: node.callee,
+						messageId: "wrongFolder",
+						data: {
+							definer,
+							folder
+						}
+					});
+					else if (file.kind === kind && !name.startsWith(prefix)) reporter.report({
+						node: node.callee,
+						messageId: "prefix",
+						data: {
+							kind,
+							prefix,
+							suggestion: prefixName(name, prefix)
+						}
+					});
+					const [options] = node.arguments;
+					if (options?.type !== "ObjectExpression") continue;
+					const component = findStringProperty(options, "component");
+					if (component && component.value !== name) reporter.report({
+						node: component.node,
+						messageId: "componentName",
+						data: {
+							actual: component.value,
+							expected: name
+						}
+					});
+					for (const group of objectElements(findProperty(options, "schema"))) for (const field of objectElements(findProperty(group, "fields"))) {
+						const fieldName = findStringProperty(field, "name");
+						if (fieldName && FORBIDDEN_FIELD_NAMES.has(fieldName.value)) reporter.report({
+							node: fieldName.node,
+							messageId: "forbiddenFieldName",
+							data: { name: fieldName.value }
+						});
+					}
+				}
+				reporter.flush();
+			}
+		};
+	}
+};
+const files = {
+	meta: {
+		type: "problem",
+		docs: { description: "Keep orchestr/ to handler files in domain folders that only export their handler." },
+		schema: [],
+		messages: {
+			notAHandler: "Laioutr loads every file in orchestr/ as a server plugin. Name handlers *.query.ts, *.resolver.ts, *.link.ts, *.action.ts, *.template.ts or *.page-index.ts, and move everything else to server/utils/.",
+			noDomain: "Put handlers in a domain folder, e.g. orchestr/<domain>/{{file}}.",
+			namedExport: "Handler files only export their handler. Laioutr registers the default export; move everything else to server/utils/.",
+			missingDefault: "Handler files export their handler as default, otherwise laioutr registers nothing."
+		}
+	},
+	create(context) {
+		const file = classify(context.filename);
+		if (!file || file.test || file.side !== "server" || file.kind !== "handler" && file.kind !== "orchestr-file") return {};
+		const reporter = createReporter(context, file);
+		if (file.kind === "orchestr-file") return { "Program:exit": () => {
+			reporter.report({
+				loc: FILE_START,
+				messageId: "notAHandler"
+			});
+			reporter.flush();
+		} };
+		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) reporter.report({
+					node,
+					messageId: "namedExport"
+				});
+			},
+			"ExportAllDeclaration": (node) => {
+				reporter.report({
+					node,
+					messageId: "namedExport"
+				});
+			},
+			"Program:exit": () => {
+				if (!file.domain) reporter.report({
+					loc: FILE_START,
+					messageId: "noDomain",
+					data: { file: basename(file.path) }
+				});
+				if (!hasDefault) reporter.report({
+					loc: FILE_START,
+					messageId: "missingDefault"
+				});
+				reporter.flush();
+			}
+		};
+	}
+};
+function isTypeOnly(node) {
+	const { importKind, exportKind } = node;
+	if (importKind === "type" || exportKind === "type") return true;
+	return node.type === "ImportDeclaration" && node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.importKind === "type");
+}
+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 === "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" };
+}
+const plugin = {
+	meta: {
+		name,
+		version
+	},
+	rules: {
+		"layers": {
+			meta: {
+				type: "problem",
+				docs: { description: "Enforce the layers of a Laioutr app: app, server and shared code, orchestr handlers, middleware, clients, utils and domains." },
+				schema: [{
+					type: "object",
+					properties: { sharedDomains: {
+						type: "array",
+						items: { type: "string" }
+					} },
+					additionalProperties: false
+				}],
+				messages: {
+					appImportsServer: "App code can't import server code. Move what both sides need to src/runtime/shared/.",
+					serverImportsApp: "Server code can't import app code. Move what both sides need to src/runtime/shared/.",
+					sharedImportsSide: "Shared code runs in the app and on the server, so it can't import from {{side}}/.",
+					runtimeImportsBuild: "Runtime code can't import build-time code from src/; it isn't part of the runtime bundle. Type imports are fine.",
+					handlerImported: "Orchestr handlers are registered by laioutr, never imported. Move the shared code to server/utils/.",
+					clientInHandler: "Handlers read API clients from the orchestr context. server/client/ only holds clients; move constants and helpers to server/utils/.",
+					clientInUtil: "Server utils get API clients passed in. server/client/ only holds clients; move constants and helpers to server/utils/.",
+					middlewareImported: "Only orchestr handlers and media libraries import middleware. Move helpers like this to server/utils/.",
+					serverUtilImportsUp: "Server utils are the bottom layer and can't import {{kind}} code.",
+					crossDomain: "The {{from}} domain can't import from the {{to}} domain. Move the shared code out of the {{to}} folders into server/utils/, or add '{{to}}' to sharedDomains.",
+					appUtilImportsUp: "App utils are the bottom layer and can't import a {{kind}}. Type imports are fine.",
+					composableImportsUp: "Composables can't import a {{kind}}. Type imports are fine.",
+					componentImportsSection: "Components can't import sections; sections compose components.",
+					nodeBuiltin: "'{{name}}' only exists on the server. Keep it in server/."
+				}
+			},
+			create(context) {
+				const importer = classify(context.filename);
+				if (!importer || importer.test || importer.side !== "app" && importer.side !== "server" && importer.side !== "shared") return {};
+				const { sharedDomains = [] } = context.options[0] ?? {};
+				const reporter = createReporter(context, importer);
+				const checkImport = (node, source, typeOnly) => {
+					if (typeof source !== "string") return;
+					if (source.startsWith("node:")) {
+						if (importer.side !== "server" && !typeOnly) reporter.report({
+							node,
+							messageId: "nodeBuiltin",
+							data: { name: source }
+						});
+						return;
+					}
+					const path = resolveImport(context.filename, source);
+					const target = path ? classify(path) : void 0;
+					const violation = target && findViolation(importer, target, typeOnly, sharedDomains);
+					if (violation) reporter.report({
+						node,
+						...violation
+					});
+				};
+				return {
+					"ImportDeclaration": (node) => {
+						checkImport(node, node.source.value, isTypeOnly(node));
+					},
+					"ExportNamedDeclaration": (node) => {
+						if (node.source) checkImport(node, node.source.value, isTypeOnly(node));
+					},
+					"ExportAllDeclaration": (node) => {
+						checkImport(node, node.source.value, isTypeOnly(node));
+					},
+					"ImportExpression": (node) => {
+						if (node.source.type === "Literal") checkImport(node, node.source.value, false);
+					},
+					"Program:exit": () => {
+						reporter.flush();
+					}
+				};
+			}
+		},
+		"orchestr-files": files,
+		"definitions": definition,
+		"button-type": button
+	}
+};
+async function larrylint(options = {}) {
+	const { sharedDomains } = await loadLarrylintConfig(options.cwd);
+	return [{
+		name: "larrylint",
+		files: ["**/src/**/*.{ts,mts,cts,js,mjs,cjs,vue}"],
+		plugins: { larrylint: plugin },
+		rules: {
+			"larrylint/layers": ["error", { sharedDomains }],
+			"larrylint/orchestr-files": "error",
+			"larrylint/definitions": "error",
+			"larrylint/button-type": "error"
+		}
+	}];
+}
+export { BASELINE_FILE, countViolations, defineLarrylintConfig, larrylint, plugin, readBaseline, writeBaseline };

package/dist/cli/index.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/cli/index.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { description, version } from "../_chunks/package.mjs";
+import { defineCommand, runMain } from "citty";
+const cwdArgs = { cwd: {
+	type: "string",
+	description: "Folder of the Laioutr app.",
+	default: "."
+} };
+const main = defineCommand({
+	meta: {
+		name: "larrylint",
+		version,
+		description
+	},
+	args: cwdArgs,
+	subCommands: {
+		check: () => import("../_chunks/check2.mjs").then((m) => m.default),
+		init: () => import("../_chunks/init.mjs").then((m) => m.default)
+	},
+	default: "check"
+});
+runMain(main);
+export { cwdArgs };

package/dist/index.d.mts

@@ -0,0 +1,59 @@
+import { Linter } from "eslint";
+interface LarrylintConfig {
+  /**
+   * Domains every other domain may import.
+   */
+  sharedDomains?: string[];
+}
+/**
+ * Defines the larrylint configuration of a Laioutr app.
+ *
+ * @param config The configuration.
+ *
+ * @returns The configuration, typed.
+ *
+ * @example
+ * ```ts
+ * // larrylint.config.ts
+ * import { defineLarrylintConfig } from 'larrylint'
+ *
+ * export default defineLarrylintConfig({
+ *   sharedDomains: ['product'],
+ * })
+ * ```
+ */
+export declare function defineLarrylintConfig(config: LarrylintConfig): LarrylintConfig;
+export declare const plugin: {
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: {
+    layers: import("eslint").Rule.RuleModule;
+    'orchestr-files': import("eslint").Rule.RuleModule;
+    definitions: import("eslint").Rule.RuleModule;
+    'button-type': import("eslint").Rule.RuleModule;
+  };
+};
+interface LarrylintOptions {
+  /** Folder of the Laioutr app, defaults to the current working directory. */
+  cwd?: string;
+}
+/**
+ * Creates the larrylint rules as ESLint flat config. The rules come without parsers,
+ * so they run on top of the project's own config, e.g. `@nuxt/eslint-config`.
+ *
+ * @param options Where to load the larrylint configuration from.
+ *
+ * @returns The flat config items.
+ *
+ * @example
+ * ```js
+ * // eslint.config.mjs
+ * import larrylint from 'larrylint'
+ *
+ * export default createConfigForNuxt().append(larrylint())
+ * ```
+ */
+declare function larrylint(options?: LarrylintOptions): Promise<Linter.Config[]>;
+export { type LarrylintConfig, type LarrylintOptions, larrylint as default };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { defineLarrylintConfig, larrylint, plugin } from "./_chunks/preset.mjs";
+export { larrylint as default, defineLarrylintConfig, plugin };

package/package.json

@@ -1,4 +1,59 @@
 {
   "name": "larrylint",
-  "version": "0.0.1"
+  "type": "module",
+  "version": "0.1.0",
+  "packageManager": "pnpm@11.5.3",
+  "description": "Opinionated structure rules for Laioutr apps, as an ESLint preset and a CLI.",
+  "author": "Frederik Bußmann <frederik@bussmann.io>",
+  "license": "MIT",
+  "repository": "bussmann-io/larrylint",
+  "keywords": [
+    "laioutr",
+    "nuxt",
+    "eslint",
+    "eslint-plugin",
+    "architecture",
+    "lint"
+  ],
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "types": "./dist/index.d.mts",
+  "bin": {
+    "larrylint": "dist/cli/index.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": "^20.19.0 || ^22.13.0 || >=24"
+  },
+  "scripts": {
+    "build": "obuild",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "prepack": "pnpm run build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@typescript-eslint/parser": "^8.70.1",
+    "c12": "^3.3.4",
+    "citty": "^0.2.2",
+    "consola": "^3.4.2",
+    "eslint": "^10.11.0",
+    "magicast": "^0.5.5",
+    "nypm": "^0.6.10",
+    "pathe": "^2.0.3",
+    "pkg-types": "^2.3.3",
+    "typescript": "^6.0.3",
+    "vue-eslint-parser": "^10.4.1"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^9.5.1",
+    "@types/estree": "^1.0.9",
+    "@types/node": "^24.13.6",
+    "obuild": "^0.4.40",
+    "vitest": "^5.0.1"
+  }
 }