@kingsword/lint-config 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2003 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+
+//#region src/utils/options.ts
+function getFirstOptionObject(context) {
+	const raw = Array.isArray(context.options) ? context.options[0] : void 0;
+	if (raw && typeof raw === "object" && !Array.isArray(raw)) return raw;
+	return {};
+}
+
+//#endregion
+//#region src/rules/no-restricted-syntax.ts
+/**
+* A small subset of ESLint's `no-restricted-syntax`, implemented as a JS plugin rule.
+*
+* Config shape (ESLint compatible):
+*   "@kingsword/no-restricted-syntax": ["error", "ForInStatement", { selector, message }, ...]
+*/
+const rule$25 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow specific syntax patterns by selector." },
+		schema: {
+			type: "array",
+			items: { anyOf: [{ type: "string" }, {
+				type: "object",
+				properties: {
+					selector: { type: "string" },
+					message: { type: "string" }
+				},
+				required: ["selector"],
+				additionalProperties: false
+			}] }
+		},
+		messages: { restricted: "The syntax '{{selector}}' is not allowed." }
+	},
+	create(context) {
+		const restrictions = Array.isArray(context.options) ? context.options : [];
+		const listeners = {};
+		for (const restriction of restrictions) {
+			const restrictionObj = typeof restriction === "string" ? { selector: restriction } : getFirstOptionObject({
+				...context,
+				options: [restriction]
+			});
+			const selector = restrictionObj.selector;
+			if (!selector) continue;
+			const message = typeof restriction === "string" ? `The syntax '${selector}' is not allowed.` : restrictionObj.message || `The syntax '${selector}' is not allowed.`;
+			listeners[selector] = (node) => {
+				context.report({
+					node,
+					message
+				});
+			};
+		}
+		return listeners;
+	}
+};
+var no_restricted_syntax_default = rule$25;
+
+//#endregion
+//#region src/rules/no-exported-function-expressions.ts
+const rule$24 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require exported functions to use function declarations instead of function expressions." },
+		schema: [],
+		messages: { useDeclaration: "Exported function expressions are not allowed. Use a function declaration instead." }
+	},
+	create(context) {
+		return {
+			ExportNamedDeclaration(node) {
+				const decl = node.declaration;
+				if (!decl || decl.type !== "VariableDeclaration") return;
+				for (const declarator of decl.declarations || []) {
+					const init = declarator && declarator.init;
+					if (!init) continue;
+					if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") context.report({
+						node: declarator.id || decl,
+						messageId: "useDeclaration"
+					});
+				}
+			},
+			ExportDefaultDeclaration(node) {
+				const decl = node.declaration;
+				if (decl && (decl.type === "ArrowFunctionExpression" || decl.type === "FunctionExpression")) context.report({
+					node: decl,
+					messageId: "useDeclaration"
+				});
+			}
+		};
+	}
+};
+var no_exported_function_expressions_default = rule$24;
+
+//#endregion
+//#region src/rules/no-exported-string-union-types.ts
+function isStringLiteralTsType(node) {
+	return node && node.type === "TSLiteralType" && node.literal && node.literal.type === "Literal" && typeof node.literal.value === "string";
+}
+function isExportedTypeDeclaration(node) {
+	const parent = node?.parent;
+	if (!parent) return false;
+	if (parent.type === "ExportNamedDeclaration" || parent.type === "ExportDefaultDeclaration") return true;
+	if (parent.type === "TSModuleBlock" && parent.parent && parent.parent.parent && parent.parent.parent.type === "ExportNamedDeclaration") return true;
+	return false;
+}
+const rule$23 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow exported types that are unions of string literals; prefer enums instead." },
+		schema: [],
+		messages: { preferEnum: "Exported string union types are not allowed. Prefer an enum (typically in enums.ts)." }
+	},
+	create(context) {
+		return { TSTypeAliasDeclaration(node) {
+			if (!isExportedTypeDeclaration(node)) return;
+			const typeAnn = node.typeAnnotation;
+			if (!typeAnn || typeAnn.type !== "TSUnionType") return;
+			const members = Array.isArray(typeAnn.types) ? typeAnn.types : [];
+			if (members.length === 0) return;
+			if (members.every(isStringLiteralTsType)) context.report({
+				node,
+				messageId: "preferEnum"
+			});
+		} };
+	}
+};
+var no_exported_string_union_types_default = rule$23;
+
+//#endregion
+//#region src/utils/ast.ts
+function isIdentifier$1(node, name) {
+	return node && node.type === "Identifier" && typeof node.name === "string" && (name === void 0 || node.name === name);
+}
+function isTemplateLiteralWithExpressions(node) {
+	return node && node.type === "TemplateLiteral" && Array.isArray(node.expressions) && node.expressions.length > 0;
+}
+function isStringConcat(node) {
+	return node && node.type === "BinaryExpression" && node.operator === "+";
+}
+function getFirstNonDirectiveStatement(statements) {
+	if (!Array.isArray(statements)) return null;
+	for (const stmt of statements) {
+		if (!stmt) continue;
+		if (stmt.type === "EmptyStatement") continue;
+		if (Object.prototype.hasOwnProperty.call(stmt, "directive")) continue;
+		return stmt;
+	}
+	return null;
+}
+function findParentBlock(node) {
+	let current = node?.parent;
+	while (current && current.type !== "BlockStatement" && current.type !== "Program") current = current.parent;
+	return current || null;
+}
+function nodeContainsCall(node, predicate) {
+	const visited = /* @__PURE__ */ new WeakSet();
+	function walk(value) {
+		if (!value) return false;
+		if (predicate(value)) return true;
+		if (typeof value !== "object") return false;
+		if (visited.has(value)) return false;
+		visited.add(value);
+		if (Array.isArray(value)) return value.some(walk);
+		for (const [key, child] of Object.entries(value)) {
+			if (key === "parent") continue;
+			if (!child) continue;
+			if (typeof child !== "object") continue;
+			if (walk(child)) return true;
+		}
+		return false;
+	}
+	return walk(node);
+}
+
+//#endregion
+//#region src/rules/structured-logging.ts
+const LOGGING_FUNCTIONS = new Set([
+	"logError",
+	"logException",
+	"logInfo",
+	"logWarn"
+]);
+function escapeSingleQuotes(text) {
+	return String(text).replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function isDynamicString(node) {
+	return isTemplateLiteralWithExpressions(node) || isStringConcat(node);
+}
+function extractTemplateParts(node, sourceCode) {
+	const staticParts = [];
+	const expressions = [];
+	for (let i = 0; i < node.quasis.length; i++) {
+		staticParts.push(node.quasis[i].value.raw);
+		if (i < node.expressions.length) {
+			const expr = node.expressions[i];
+			expressions.push({
+				node: expr,
+				text: sourceCode.getText(expr)
+			});
+		}
+	}
+	const joined = staticParts.join("");
+	const isSimple = staticParts.length === 2;
+	const endsWithSingleSpace = joined.endsWith(" ") && !joined.endsWith("  ");
+	return {
+		message: isSimple && endsWithSingleSpace ? joined.trim() : joined,
+		expressions
+	};
+}
+function buildMetadataObject(expressions) {
+	if (!expressions.length) return "{ }";
+	return `{ ${expressions.map((expr, idx) => {
+		if (isIdentifier$1(expr.node)) return expr.node.name;
+		return `param${idx + 1}: ${expr.text}`;
+	}).join(", ")} }`;
+}
+const rule$22 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforce structured logging message patterns." },
+		fixable: "code",
+		schema: [],
+		messages: { dynamicMessage: "Use a static message string and pass dynamic values as structured metadata (no template expressions or string concatenation)." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		return {
+			NewExpression(node) {
+				if (!isIdentifier$1(node.callee)) return;
+				const name = node.callee.name;
+				if (!name || !name.endsWith("Error")) return;
+				if (node.arguments.length !== 1) return;
+				const arg = node.arguments[0];
+				if (!isDynamicString(arg)) return;
+				context.report({
+					node,
+					messageId: "dynamicMessage",
+					fix(fixer) {
+						if (name !== "Error") return null;
+						if (!isTemplateLiteralWithExpressions(arg)) return null;
+						const { message, expressions } = extractTemplateParts(arg, sourceCode);
+						const meta = buildMetadataObject(expressions);
+						const replacement = `new MetaError('${escapeSingleQuotes(message)}', ${meta})`;
+						return fixer.replaceText(node, replacement);
+					}
+				});
+			},
+			CallExpression(node) {
+				if (!isIdentifier$1(node.callee)) return;
+				const fnName = node.callee.name;
+				if (!LOGGING_FUNCTIONS.has(fnName)) return;
+				if (!(node.arguments || []).some(isDynamicString)) return;
+				context.report({
+					node,
+					messageId: "dynamicMessage",
+					fix(fixer) {
+						if (node.arguments.length !== 1) return null;
+						const arg = node.arguments[0];
+						if (!isTemplateLiteralWithExpressions(arg)) return null;
+						const { message, expressions } = extractTemplateParts(arg, sourceCode);
+						const meta = buildMetadataObject(expressions);
+						const replacement = `${fnName}('${escapeSingleQuotes(message)}', ${meta})`;
+						return fixer.replaceText(node, replacement);
+					}
+				});
+			}
+		};
+	}
+};
+var structured_logging_default = rule$22;
+
+//#endregion
+//#region src/utils/filename.ts
+function getBasename(filename) {
+	return node_path.default.basename(filename || "");
+}
+function isTsOrTsx(filename) {
+	return typeof filename === "string" && (filename.endsWith(".ts") || filename.endsWith(".tsx"));
+}
+function isTs(filename) {
+	return typeof filename === "string" && filename.endsWith(".ts") && !filename.endsWith(".d.ts");
+}
+function isTsx(filename) {
+	return typeof filename === "string" && filename.endsWith(".tsx");
+}
+function isTestOrSpecFile(filename) {
+	const base = getBasename(filename);
+	return base.includes(".test.") || base.includes(".spec.") || filename.includes("__tests__");
+}
+function isTestSpecOrStoryFile(filename) {
+	const base = getBasename(filename);
+	return base.includes(".test.") || base.includes(".spec.") || base.includes(".stories.");
+}
+
+//#endregion
+//#region src/utils/path.ts
+function toPosixPath(filePath) {
+	if (typeof filePath !== "string") return "";
+	return filePath.replace(/\\/g, "/");
+}
+
+//#endregion
+//#region src/rules/enum-file-organization.ts
+function isExported$2(node) {
+	const parent = node?.parent;
+	return !!parent && (parent.type === "ExportNamedDeclaration" || parent.type === "ExportDefaultDeclaration");
+}
+const rule$21 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforce that exported enums live in enums.ts." },
+		schema: [],
+		messages: {
+			wrongFile: "TypeScript enums must be defined in a file named \"enums.ts\".",
+			badEnumFile: "Files named \"enums.ts\" can only contain enum declarations and type exports (no imports).",
+			noImports: "Files named \"enums.ts\" cannot contain import statements."
+		}
+	},
+	create(context) {
+		const filename = toPosixPath(context.filename);
+		if (!isTsOrTsx(filename)) return {};
+		const isEnumsFile = filename.endsWith("/enums.ts") || filename === "enums.ts";
+		return {
+			TSEnumDeclaration(node) {
+				if (isExported$2(node) && !isEnumsFile) context.report({
+					node,
+					messageId: "wrongFile"
+				});
+			},
+			ImportDeclaration(node) {
+				if (isEnumsFile) context.report({
+					node,
+					messageId: "noImports"
+				});
+			},
+			Program(node) {
+				if (!isEnumsFile) return;
+				for (const stmt of node.body || []) {
+					const isEnum = stmt.type === "TSEnumDeclaration";
+					const isTypeAlias = stmt.type === "TSTypeAliasDeclaration";
+					const isInterface = stmt.type === "TSInterfaceDeclaration";
+					const isExportNamed = stmt.type === "ExportNamedDeclaration";
+					const exportDecl = isExportNamed ? stmt.declaration : null;
+					const isExportingTypesOrEnums = isExportNamed && (exportDecl === null || exportDecl?.type === "TSEnumDeclaration" || exportDecl?.type === "TSTypeAliasDeclaration" || exportDecl?.type === "TSInterfaceDeclaration");
+					const isReExportFromCurrentFile = isExportNamed && !stmt.source && Array.isArray(stmt.specifiers) && stmt.specifiers.length > 0;
+					if (stmt.type === "ImportDeclaration" || isEnum || isTypeAlias || isInterface || isExportingTypesOrEnums || isReExportFromCurrentFile) continue;
+					if (stmt.type !== "ExportAllDeclaration") context.report({
+						node: stmt,
+						messageId: "badEnumFile"
+					});
+				}
+			}
+		};
+	}
+};
+var enum_file_organization_default = rule$21;
+
+//#endregion
+//#region src/utils/import.ts
+function isTypeOnlyImport(node) {
+	if (!node || node.type !== "ImportDeclaration") return false;
+	if (node.importKind === "type") return true;
+	const specifiers = node.specifiers;
+	if (!Array.isArray(specifiers) || specifiers.length === 0) return false;
+	return specifiers.every((s) => s && s.importKind === "type");
+}
+
+//#endregion
+//#region src/rules/types-file-organization.ts
+function isExportedFromTypesModule(node) {
+	const parent = node?.parent;
+	if (!parent) return false;
+	if (parent.type === "ExportNamedDeclaration" || parent.type === "ExportDefaultDeclaration") return true;
+	if (parent.type === "TSModuleBlock" && parent.parent && parent.parent.parent && parent.parent.parent.type === "ExportNamedDeclaration") return true;
+	return false;
+}
+function isAllowedImport$2(importPath) {
+	if (typeof importPath !== "string") return false;
+	if (!importPath.startsWith(".") && !importPath.startsWith("/") && !importPath.startsWith("@/")) return true;
+	return importPath.endsWith("/enums") || importPath.endsWith("/enums.ts") || importPath === "enums" || importPath.endsWith("/types") || importPath.endsWith("/types.ts") || importPath === "types" || importPath.endsWith("/schema") || importPath.endsWith("/schema.ts") || importPath === "schema";
+}
+const rule$20 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforce that exported types/interfaces live in types.ts." },
+		schema: [],
+		messages: {
+			wrongFile: "TypeScript types and interfaces must be defined in a file named \"types.ts\".",
+			badTypesFile: "Files named \"types.ts\" can only contain type aliases, interface declarations, and type exports.",
+			badImport: "Files named \"types.ts\" can only import external modules or internal enums/types/schema files."
+		}
+	},
+	create(context) {
+		const filename = toPosixPath(context.filename);
+		const isTypesFile = filename.endsWith("/types.ts") || filename === "types.ts";
+		return {
+			TSTypeAliasDeclaration(node) {
+				if (isExportedFromTypesModule(node) && !isTypesFile) context.report({
+					node,
+					messageId: "wrongFile"
+				});
+			},
+			TSInterfaceDeclaration(node) {
+				if (isExportedFromTypesModule(node) && !isTypesFile) context.report({
+					node,
+					messageId: "wrongFile"
+				});
+			},
+			ImportDeclaration(node) {
+				if (!isTypesFile) return;
+				if (isTypeOnlyImport(node)) return;
+				const importPath = node?.source?.value;
+				if (!isAllowedImport$2(importPath)) context.report({
+					node,
+					messageId: "badImport"
+				});
+			},
+			Program(node) {
+				if (!isTypesFile) return;
+				for (const stmt of node.body || []) {
+					const isTypeAlias = stmt.type === "TSTypeAliasDeclaration" || stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSTypeAliasDeclaration";
+					const isInterface = stmt.type === "TSInterfaceDeclaration" || stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSInterfaceDeclaration";
+					const isExportingTypes = stmt.type === "ExportNamedDeclaration" && (stmt.declaration === null || stmt.declaration?.type === "TSTypeAliasDeclaration" || stmt.declaration?.type === "TSInterfaceDeclaration");
+					const isReExportFromCurrentFile = stmt.type === "ExportNamedDeclaration" && !stmt.source && Array.isArray(stmt.specifiers) && stmt.specifiers.length > 0;
+					const isImport = stmt.type === "ImportDeclaration";
+					if (isTypeAlias || isInterface || isExportingTypes || isReExportFromCurrentFile || isImport) continue;
+					if (stmt.type !== "ExportAllDeclaration") context.report({
+						node: stmt,
+						messageId: "badTypesFile"
+					});
+				}
+			}
+		};
+	}
+};
+var types_file_organization_default = rule$20;
+
+//#endregion
+//#region src/rules/constants-file-organization.ts
+function isExported$1(node) {
+	const parent = node?.parent;
+	return !!parent && (parent.type === "ExportNamedDeclaration" || parent.type === "ExportDefaultDeclaration");
+}
+function isConstantsFile(filename) {
+	const f = toPosixPath(filename);
+	return f.endsWith("/constants.ts") || f.endsWith("/constants.tsx") || f === "constants.ts" || f === "constants.tsx";
+}
+function isAllowedImport$1(importPath) {
+	if (typeof importPath !== "string") return false;
+	if (!importPath.startsWith(".") && !importPath.startsWith("/") && !importPath.startsWith("@/")) return true;
+	if ([
+		".mp4",
+		".webm",
+		".ogg",
+		".mp3",
+		".wav",
+		".png",
+		".jpg",
+		".jpeg",
+		".gif",
+		".svg",
+		".webp"
+	].some((ext) => importPath.endsWith(ext))) return true;
+	return importPath.endsWith("/constants") || importPath.endsWith("/constants.ts") || importPath === "constants" || importPath.endsWith("/enums") || importPath.endsWith("/enums.ts") || importPath === "enums" || importPath.endsWith("/types") || importPath.endsWith("/types.ts") || importPath === "types" || importPath.endsWith("/schema") || importPath.endsWith("/schema.ts") || importPath === "schema";
+}
+function hasRuntimeInitializer(declarator) {
+	const init = declarator?.init;
+	return !!init && (init.type === "CallExpression" || init.type === "NewExpression" || init.type === "TaggedTemplateExpression");
+}
+const rule$19 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforce constants file organization (constants.ts)." },
+		schema: [],
+		messages: {
+			wrongFile: "Exported constants must be defined in a file named \"constants.ts\".",
+			badConstantsFile: "Files named \"constants.ts\" can only contain const declarations.",
+			badImport: "Files named \"constants.ts\" can only import external modules, media files, or internal constants/enums/types/schema files."
+		}
+	},
+	create(context) {
+		const filename = context.filename;
+		const inConstantsFile = isConstantsFile(filename);
+		return {
+			VariableDeclaration(node) {
+				if (node.kind !== "const") return;
+				if (!isExported$1(node)) return;
+				if (inConstantsFile) return;
+				if (!(Array.isArray(node.declarations) ? node.declarations : []).some(hasRuntimeInitializer)) context.report({
+					node,
+					messageId: "wrongFile"
+				});
+			},
+			ImportDeclaration(node) {
+				if (!inConstantsFile) return;
+				const importPath = node?.source?.value;
+				if (!isAllowedImport$1(importPath)) context.report({
+					node,
+					messageId: "badImport"
+				});
+			},
+			Program(node) {
+				if (!inConstantsFile) return;
+				for (const stmt of node.body || []) {
+					const isImport = stmt.type === "ImportDeclaration";
+					const isTypeImport = stmt.type === "ImportDeclaration" && stmt.importKind === "type";
+					const isConstDecl = stmt.type === "VariableDeclaration" && stmt.kind === "const";
+					const isExportedConstDecl = stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration" && stmt.declaration.kind === "const";
+					const isReExport = stmt.type === "ExportNamedDeclaration" && !stmt.declaration && Array.isArray(stmt.specifiers) && stmt.specifiers.length > 0;
+					const isExportAllAllowed = stmt.type === "ExportAllDeclaration" && stmt.source && isAllowedImport$1(stmt.source.value);
+					if (isImport || isTypeImport || isConstDecl || isExportedConstDecl || isReExport || isExportAllAllowed) continue;
+					if (stmt.type !== "ExportAllDeclaration") context.report({
+						node: stmt,
+						messageId: "badConstantsFile"
+					});
+				}
+			}
+		};
+	}
+};
+var constants_file_organization_default = rule$19;
+
+//#endregion
+//#region src/rules/errors-file-organization.ts
+function isErrorsFile(filename) {
+	const f = toPosixPath(filename);
+	return f.endsWith("/errors.ts") || f.endsWith("/errors.tsx") || f === "errors.ts" || f === "errors.tsx";
+}
+function isExported(node) {
+	const parent = node?.parent;
+	return !!parent && (parent.type === "ExportNamedDeclaration" || parent.type === "ExportDefaultDeclaration");
+}
+function extendsErrorClass(node) {
+	const superClass = node?.superClass;
+	if (!superClass) return false;
+	if (superClass.type === "Identifier") return superClass.name === "Error" || superClass.name.includes("Error");
+	if (superClass.type === "MemberExpression" && superClass.property?.type === "Identifier") {
+		const name = superClass.property.name;
+		return name === "Error" || name.includes("Error");
+	}
+	return false;
+}
+function isAllowedImport(importPath) {
+	if (typeof importPath !== "string") return false;
+	if (!importPath.startsWith(".") && !importPath.startsWith("/") && !importPath.startsWith("@/")) return true;
+	return importPath.endsWith("/enums") || importPath.endsWith("/enums.ts") || importPath === "enums" || importPath.endsWith("/types") || importPath.endsWith("/types.ts") || importPath === "types" || importPath.endsWith("/constants") || importPath.endsWith("/constants.ts") || importPath === "constants" || importPath.endsWith("/errors") || importPath.endsWith("/errors.ts") || importPath === "errors";
+}
+const rule$18 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforce Error class organization (errors.ts)." },
+		schema: [],
+		messages: {
+			wrongFile: "Classes extending Error must be defined in a file named \"errors.ts\".",
+			badErrorsFile: "Files named \"errors.ts\" can only contain Error classes.",
+			badImport: "Files named \"errors.ts\" can only import external modules or internal enums/types/constants/errors files."
+		}
+	},
+	create(context) {
+		const filename = context.filename;
+		const inErrorsFile = isErrorsFile(filename);
+		return {
+			ClassDeclaration(node) {
+				if (!extendsErrorClass(node)) return;
+				if (!isExported(node)) return;
+				if (inErrorsFile) return;
+				context.report({
+					node,
+					messageId: "wrongFile"
+				});
+			},
+			ImportDeclaration(node) {
+				if (!inErrorsFile) return;
+				const importPath = node?.source?.value;
+				if (!isAllowedImport(importPath)) context.report({
+					node,
+					messageId: "badImport"
+				});
+			},
+			Program(node) {
+				if (!inErrorsFile) return;
+				for (const stmt of node.body || []) {
+					const isImport = stmt.type === "ImportDeclaration";
+					const isTypeImport = stmt.type === "ImportDeclaration" && stmt.importKind === "type";
+					const isErrorClass = stmt.type === "ClassDeclaration" && extendsErrorClass(stmt);
+					const isExportedErrorClass = stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "ClassDeclaration" && extendsErrorClass(stmt.declaration);
+					const isReExport = stmt.type === "ExportNamedDeclaration" && !stmt.declaration && Array.isArray(stmt.specifiers) && stmt.specifiers.length > 0;
+					const isExportAllAllowed = stmt.type === "ExportAllDeclaration" && stmt.source && isAllowedImport(stmt.source.value);
+					if (isImport || isTypeImport || isErrorClass || isExportedErrorClass || isReExport || isExportAllAllowed) continue;
+					if (stmt.type !== "ExportAllDeclaration") context.report({
+						node: stmt,
+						messageId: "badErrorsFile"
+					});
+				}
+			}
+		};
+	}
+};
+var errors_file_organization_default = rule$18;
+
+//#endregion
+//#region src/rules/test-utils-organization.ts
+const mockNamePatterns = [
+	/^mock[A-Z]/,
+	/^createMock[A-Z]/,
+	/^make(Mock|Test)[A-Z]/,
+	/^generate(Mock|Test)[A-Z]/,
+	/^fake[A-Z]/,
+	/^stub[A-Z]/,
+	/TestFactory$/,
+	/MockFactory$/
+];
+function isIdentifier(node) {
+	return node && node.type === "Identifier" && typeof node.name === "string";
+}
+const rule$17 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforce that test utilities live under test-utils/." },
+		schema: [],
+		messages: {
+			wrongLocation: "Test utilities (mocks, fixtures, factories) should be defined in a test-utils directory.",
+			badMockName: "Mock functions should follow naming conventions (e.g., mockX, createMockX)."
+		}
+	},
+	create(context) {
+		const filename = toPosixPath(context.filename);
+		if (!isTsOrTsx(filename)) return {};
+		if (isTestOrSpecFile(filename)) return {};
+		const inTestUtils = filename.includes("/test-utils/");
+		return {
+			"FunctionDeclaration, VariableDeclaration"(node) {
+				if (inTestUtils) return;
+				if (node.type === "FunctionDeclaration" && isIdentifier(node.id)) {
+					const name = node.id.name;
+					if (mockNamePatterns.some((p) => p.test(name))) context.report({
+						node: node.id,
+						messageId: "wrongLocation"
+					});
+				}
+				if (node.type === "VariableDeclaration") {
+					for (const declarator of node.declarations || []) if (isIdentifier(declarator.id)) {
+						const name = declarator.id.name;
+						if (mockNamePatterns.some((p) => p.test(name))) context.report({
+							node: declarator.id,
+							messageId: "wrongLocation"
+						});
+					}
+				}
+			},
+			"VariableDeclarator, FunctionDeclaration"(node) {
+				if (!inTestUtils) return;
+				const name = node.type === "VariableDeclarator" ? node.id?.name : node.id?.name;
+				if (typeof name !== "string") return;
+				if (name.includes("mock") && !name.includes("Mock")) {
+					if (!mockNamePatterns.some((p) => p.test(name))) context.report({
+						node: node.id || node,
+						messageId: "badMockName"
+					});
+				}
+			}
+		};
+	}
+};
+var test_utils_organization_default = rule$17;
+
+//#endregion
+//#region src/rules/test-file-location.ts
+const TEST_CALL_NAMES = new Set([
+	"describe",
+	"it",
+	"test",
+	"beforeEach",
+	"afterEach",
+	"beforeAll",
+	"afterAll",
+	"expect",
+	"jest",
+	"vitest",
+	"cy",
+	"assert",
+	"should",
+	"mock"
+]);
+function isTestCall(node) {
+	return node.type === "CallExpression" && node.callee && node.callee.type === "Identifier" && TEST_CALL_NAMES.has(node.callee.name);
+}
+const rule$16 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Enforce colocated, non-empty test files." },
+		schema: [],
+		messages: {
+			badName: "Test file should follow naming convention: filename.test.ts",
+			badLocation: "Test files should be colocated with source files, not in a 'test' or '__tests__' directory.",
+			missingTests: "Test file should contain at least one test/describe block."
+		}
+	},
+	create(context) {
+		const filename = context.filename;
+		if (!isTsOrTsx(filename)) return {};
+		if (!filename.includes(".test.")) return {};
+		const dirname = node_path.default.dirname(filename);
+		const basename = node_path.default.basename(filename);
+		let hasTests = false;
+		return {
+			CallExpression(node) {
+				if (isTestCall(node)) hasTests = true;
+			},
+			"Program:exit"(node) {
+				if (!/^.+\.test\.(ts|tsx)$/.test(basename)) context.report({
+					node,
+					messageId: "badName"
+				});
+				if (dirname.split(node_path.default.sep).some((s) => s === "test" || s === "__tests__")) context.report({
+					node,
+					messageId: "badLocation"
+				});
+				if (!hasTests) context.report({
+					node,
+					messageId: "missingTests"
+				});
+			}
+		};
+	}
+};
+var test_file_location_default = rule$16;
+
+//#endregion
+//#region src/rules/require-test-files.ts
+const DEFAULT_EXEMPT_BASENAMES = new Set([
+	"enums.ts",
+	"schema.ts",
+	"types.ts",
+	"constants.ts",
+	"errors.ts",
+	"index.ts",
+	"env.ts",
+	"config.ts",
+	"route.ts"
+]);
+const rule$15 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require a sibling *.test.ts for most *.ts files." },
+		schema: [],
+		messages: { missingTest: "TypeScript file \"{{filename}}\" is missing a corresponding test file \"{{testFilename}}\"." }
+	},
+	create(context) {
+		const filename = context.filename;
+		if (!isTs(filename)) return {};
+		const base = node_path.default.basename(filename);
+		if (filename.endsWith(".test.ts")) return {};
+		if (filename.endsWith(".config.ts")) return {};
+		if (filename.endsWith(".d.ts")) return {};
+		if (DEFAULT_EXEMPT_BASENAMES.has(base)) return {};
+		if (base.startsWith("use")) return {};
+		const dir = node_path.default.dirname(filename);
+		const testFilename = base.replace(/\.ts$/, ".test.ts");
+		const testPath = node_path.default.join(dir, testFilename);
+		return { "Program:exit"(node) {
+			if (!node_fs.default.existsSync(testPath)) context.report({
+				node,
+				messageId: "missingTest",
+				data: {
+					filename: base,
+					testFilename
+				}
+			});
+		} };
+	}
+};
+var require_test_files_default = rule$15;
+
+//#endregion
+//#region src/rules/require-tsx-test-stories-files.ts
+const EXEMPT_BASENAMES = new Set([
+	"index.ts",
+	"index.tsx",
+	"layout.tsx",
+	"page.tsx",
+	"loading.tsx",
+	"error.tsx",
+	"not-found.tsx",
+	"template.tsx",
+	"default.tsx",
+	"types.ts",
+	"types.tsx",
+	"constants.ts",
+	"constants.tsx",
+	"enums.ts",
+	"enums.tsx"
+]);
+const EXEMPT_PATTERNS = [
+	/^style-props\.(ts|tsx)$/,
+	/^config\.(ts|tsx)$/,
+	/^schema\.(ts|tsx)$/
+];
+const rule$14 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Require sibling test files for TS/TSX, and sibling stories files for TSX." },
+		schema: [],
+		messages: {
+			missingTest: "{{fileType}} file \"{{filename}}\" is missing a corresponding test file \"{{testFilename}}\".",
+			missingStories: "TSX file \"{{filename}}\" is missing a corresponding stories file \"{{storiesFilename}}\"."
+		}
+	},
+	create(context) {
+		const filename = context.filename;
+		if (!isTsOrTsx(filename)) return {};
+		const base = node_path.default.basename(filename);
+		const dir = node_path.default.dirname(filename);
+		const tsx = isTsx(filename);
+		if (base.endsWith(".d.ts")) return {};
+		if (base.endsWith(".test.ts") || base.endsWith(".test.tsx")) return {};
+		if (base.endsWith(".stories.tsx")) return {};
+		if (EXEMPT_BASENAMES.has(base)) return {};
+		if (EXEMPT_PATTERNS.some((re) => re.test(base))) return {};
+		const ext = tsx ? ".tsx" : ".ts";
+		const testFilename = base.replace(/* @__PURE__ */ new RegExp(`\\${ext}$`), `.test${ext}`);
+		const testPath = node_path.default.join(dir, testFilename);
+		const storiesFilename = tsx ? base.replace(/\.tsx$/, ".stories.tsx") : null;
+		const storiesPath = tsx ? node_path.default.join(dir, storiesFilename) : null;
+		return { "Program:exit"(node) {
+			if (!node_fs.default.existsSync(testPath)) context.report({
+				node,
+				messageId: "missingTest",
+				data: {
+					fileType: tsx ? "TSX" : "TS",
+					filename: base,
+					testFilename
+				}
+			});
+			if (tsx && storiesPath && !node_fs.default.existsSync(storiesPath)) context.report({
+				node,
+				messageId: "missingStories",
+				data: {
+					filename: base,
+					storiesFilename
+				}
+			});
+		} };
+	}
+};
+var require_tsx_test_stories_files_default = rule$14;
+
+//#endregion
+//#region src/rules/vitest-mock-absolute-paths.ts
+const VITEST_OBJECT_NAMES$1 = new Set(["vi", "vitest"]);
+function isRelativePath(text) {
+	return typeof text === "string" && (text.startsWith(".") || text.startsWith(".."));
+}
+function isVitestMethodCall(node, names) {
+	if (!node || node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (!callee || callee.type !== "MemberExpression") return false;
+	if (callee.object?.type !== "Identifier" || !VITEST_OBJECT_NAMES$1.has(callee.object.name)) return false;
+	if (callee.property?.type !== "Identifier") return false;
+	return names.includes(callee.property.name);
+}
+const rule$13 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Require vi.mock() to use absolute (non-relative) module specifiers." },
+		schema: [],
+		messages: {
+			relative: "vi.mock() must use absolute paths. Use an absolute path instead of \"{{path}}\".",
+			requireResolve: "vi.mock() should not use require.resolve(). Use the absolute path directly."
+		}
+	},
+	create(context) {
+		const filename = context.filename;
+		if (!isTestOrSpecFile(filename)) return {};
+		const targetMethods = [
+			"mock",
+			"doMock",
+			"unmock",
+			"doUnmock"
+		];
+		return { CallExpression(node) {
+			if (!isVitestMethodCall(node, targetMethods)) return;
+			const firstArg = node.arguments?.[0];
+			if (!firstArg) return;
+			if (firstArg.type === "Literal" && typeof firstArg.value === "string") {
+				if (isRelativePath(firstArg.value)) context.report({
+					node: firstArg,
+					messageId: "relative",
+					data: { path: firstArg.value }
+				});
+			}
+			if (firstArg.type === "TemplateLiteral" && firstArg.quasis?.length) {
+				const cooked = firstArg.quasis[0]?.value?.cooked;
+				if (typeof cooked === "string" && isRelativePath(cooked)) context.report({
+					node: firstArg,
+					messageId: "relative",
+					data: { path: `${cooked}...` }
+				});
+			}
+			if (firstArg.type === "CallExpression" && firstArg.callee?.type === "MemberExpression" && firstArg.callee.object?.type === "Identifier" && firstArg.callee.object.name === "require" && firstArg.callee.property?.type === "Identifier" && firstArg.callee.property.name === "resolve") context.report({
+				node: firstArg,
+				messageId: "requireResolve"
+			});
+		} };
+	}
+};
+var vitest_mock_absolute_paths_default = rule$13;
+
+//#endregion
+//#region src/rules/vitest-mock-require-actual.ts
+const VITEST_OBJECT_NAMES = new Set(["vi", "vitest"]);
+function unwrapExpression(node) {
+	let current = node;
+	while (current && typeof current === "object") {
+		if (current.type === "TSAsExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "ChainExpression" || current.type === "ParenthesizedExpression") {
+			current = current.expression;
+			continue;
+		}
+		break;
+	}
+	return current;
+}
+function isVitestMockCall(node) {
+	if (!node || node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (!callee || callee.type !== "MemberExpression") return false;
+	if (callee.object?.type !== "Identifier" || !VITEST_OBJECT_NAMES.has(callee.object.name)) return false;
+	if (callee.property?.type !== "Identifier" || callee.property.name !== "mock") return false;
+	return true;
+}
+function isVitestImportActualCall(node) {
+	if (!node || node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (!callee || callee.type !== "MemberExpression") return false;
+	if (callee.object?.type !== "Identifier" || !VITEST_OBJECT_NAMES.has(callee.object.name)) return false;
+	if (callee.property?.type !== "Identifier" || callee.property.name !== "importActual") return false;
+	return true;
+}
+function getFactoryFirstParamName(fnNode) {
+	if (!fnNode) return null;
+	if (fnNode.type !== "ArrowFunctionExpression" && fnNode.type !== "FunctionExpression") return null;
+	const param = fnNode.params?.[0];
+	if (!param) return null;
+	if (param.type !== "Identifier" || typeof param.name !== "string") return null;
+	return param.name;
+}
+function isCallToIdentifier(node, name) {
+	if (!node || node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	return callee?.type === "Identifier" && callee.name === name;
+}
+function objectOnlySpreadsActual(objectExpression, importOriginalParamName) {
+	if (!objectExpression || objectExpression.type !== "ObjectExpression") return false;
+	const props = objectExpression.properties;
+	if (!Array.isArray(props) || props.length !== 1) return false;
+	const only = props[0];
+	const spreadArg = only.argument;
+	if (only.type !== "SpreadElement" && only.type !== "SpreadProperty" && only.type !== "ExperimentalSpreadProperty") return false;
+	const unwrapped = unwrapExpression(spreadArg);
+	const expr = unwrapped?.type === "AwaitExpression" ? unwrapExpression(unwrapped.argument) : unwrapped;
+	if (isVitestImportActualCall(expr)) return true;
+	if (importOriginalParamName && isCallToIdentifier(expr, importOriginalParamName)) return true;
+	return false;
+}
+function isPointlessActualOnly(fnNode) {
+	if (!fnNode) return false;
+	if (fnNode.type !== "ArrowFunctionExpression" && fnNode.type !== "FunctionExpression") return false;
+	const importOriginalParamName = getFactoryFirstParamName(fnNode);
+	const body = fnNode.body;
+	if (!body) return false;
+	if (body.type === "ObjectExpression") return objectOnlySpreadsActual(body, importOriginalParamName);
+	if (body.type === "BlockStatement") {
+		const statements = body.body || [];
+		if (statements.length !== 1) return false;
+		const stmt = statements[0];
+		if (stmt.type !== "ReturnStatement") return false;
+		return objectOnlySpreadsActual(stmt.argument, importOriginalParamName);
+	}
+	return false;
+}
+function findEnclosingExpressionStatement(node) {
+	let current = node;
+	while (current && current.parent) {
+		if (current.parent.type === "ExpressionStatement") return current.parent;
+		current = current.parent;
+	}
+	return null;
+}
+const rule$12 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Require vi.mock() to include a factory which keeps non-mocked exports via vi.importActual() (or importOriginal)." },
+		fixable: "code",
+		schema: [],
+		messages: {
+			missingSecondArg: "vi.mock() must have a second argument to prevent auto-mocking all exports.",
+			missingImportActual: "The second argument of vi.mock() must contain a call to vi.importActual() (or call the factory's importOriginal parameter).",
+			pointless: "vi.mock() that only spreads the original module is pointless and should be removed."
+		}
+	},
+	create(context) {
+		const filename = context.filename;
+		if (!isTestOrSpecFile(filename)) return {};
+		const sourceCode = context.sourceCode;
+		return { CallExpression(node) {
+			if (!isVitestMockCall(node)) return;
+			const firstArg = node.arguments?.[0];
+			if (!node.arguments || node.arguments.length < 2) {
+				context.report({
+					node,
+					messageId: "missingSecondArg",
+					fix(fixer) {
+						if (!firstArg) return null;
+						if (firstArg.type !== "Literal" || typeof firstArg.value !== "string") return null;
+						const modulePathText = sourceCode.getText(firstArg);
+						return fixer.insertTextAfter(firstArg, `, async () => ({ ...(await vi.importActual(${modulePathText})) })`);
+					}
+				});
+				return;
+			}
+			const secondArg = node.arguments[1];
+			const importOriginalParamName = getFactoryFirstParamName(secondArg);
+			const hasImportActual = nodeContainsCall(secondArg, isVitestImportActualCall);
+			const hasImportOriginalCall = importOriginalParamName ? nodeContainsCall(secondArg, (n) => isCallToIdentifier(n, importOriginalParamName)) : false;
+			if (!hasImportActual && !hasImportOriginalCall) {
+				context.report({
+					node: secondArg || node,
+					messageId: "missingImportActual"
+				});
+				return;
+			}
+			if (isPointlessActualOnly(secondArg)) context.report({
+				node: secondArg,
+				messageId: "pointless",
+				fix(fixer) {
+					const stmt = findEnclosingExpressionStatement(node);
+					if (!stmt) return null;
+					return fixer.remove(stmt);
+				}
+			});
+		} };
+	}
+};
+var vitest_mock_require_actual_default = rule$12;
+
+//#endregion
+//#region src/rules/vitest-no-focused-tests.ts
+const TEST_API_ROOT_NAMES$1 = new Set([
+	"describe",
+	"it",
+	"test",
+	"suite"
+]);
+function unwrapCallee$1(node) {
+	let current = node;
+	while (current && typeof current === "object") {
+		if (current.type === "ChainExpression") {
+			current = current.expression;
+			continue;
+		}
+		break;
+	}
+	return current;
+}
+function getMemberChain$1(callee) {
+	const members = [];
+	let current = unwrapCallee$1(callee);
+	while (current && typeof current === "object") {
+		if (current.type === "MemberExpression") {
+			if (current.computed) return {
+				root: null,
+				members
+			};
+			if (current.property?.type !== "Identifier") return {
+				root: null,
+				members
+			};
+			members.push(current.property.name);
+			current = unwrapCallee$1(current.object);
+			continue;
+		}
+		if (current.type === "Identifier") return {
+			root: current.name,
+			members
+		};
+		break;
+	}
+	return {
+		root: null,
+		members
+	};
+}
+const rule$11 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow focused Vitest tests (describe.only / it.only / test.only)." },
+		schema: [],
+		messages: { focused: "Focused tests are not allowed (remove .only before committing)." }
+	},
+	create(context) {
+		const filename = context.filename;
+		if (!isTestOrSpecFile(filename)) return {};
+		return { CallExpression(node) {
+			const { root, members } = getMemberChain$1(node.callee);
+			if (!root || !TEST_API_ROOT_NAMES$1.has(root)) return;
+			if (!members.includes("only")) return;
+			context.report({
+				node: node.callee || node,
+				messageId: "focused"
+			});
+		} };
+	}
+};
+var vitest_no_focused_tests_default = rule$11;
+
+//#endregion
+//#region src/rules/vitest-no-disabled-tests.ts
+const TEST_API_ROOT_NAMES = new Set([
+	"describe",
+	"it",
+	"test",
+	"suite"
+]);
+const DISABLED_MEMBERS = new Set(["skip", "todo"]);
+function unwrapCallee(node) {
+	let current = node;
+	while (current && typeof current === "object") {
+		if (current.type === "ChainExpression") {
+			current = current.expression;
+			continue;
+		}
+		break;
+	}
+	return current;
+}
+function getMemberChain(callee) {
+	const members = [];
+	let current = unwrapCallee(callee);
+	while (current && typeof current === "object") {
+		if (current.type === "MemberExpression") {
+			if (current.computed) return {
+				root: null,
+				members
+			};
+			if (current.property?.type !== "Identifier") return {
+				root: null,
+				members
+			};
+			members.push(current.property.name);
+			current = unwrapCallee(current.object);
+			continue;
+		}
+		if (current.type === "Identifier") return {
+			root: current.name,
+			members
+		};
+		break;
+	}
+	return {
+		root: null,
+		members
+	};
+}
+const rule$10 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow disabled Vitest tests (describe.skip / it.skip / test.skip / *.todo)." },
+		schema: [],
+		messages: { disabled: "Disabled tests are not allowed (remove .skip/.todo before committing)." }
+	},
+	create(context) {
+		const filename = context.filename;
+		if (!isTestOrSpecFile(filename)) return {};
+		return { CallExpression(node) {
+			const { root, members } = getMemberChain(node.callee);
+			if (!root || !TEST_API_ROOT_NAMES.has(root)) return;
+			if (!members.some((m) => DISABLED_MEMBERS.has(m))) return;
+			context.report({
+				node: node.callee || node,
+				messageId: "disabled"
+			});
+		} };
+	}
+};
+var vitest_no_disabled_tests_default = rule$10;
+
+//#endregion
+//#region src/rules/vitest-no-test-prefixes.ts
+const BANNED_PREFIX_CALLS = new Set([
+	"fdescribe",
+	"fit",
+	"fcontext",
+	"xdescribe",
+	"xit",
+	"xtest",
+	"xcontext"
+]);
+const rule$9 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow fdescribe/fit/xdescribe/xit/xtest style test prefixes in Vitest tests." },
+		schema: [],
+		messages: { banned: "Test prefixes like fdescribe/fit/xdescribe/xit/xtest are not allowed." }
+	},
+	create(context) {
+		const filename = context.filename;
+		if (!isTestOrSpecFile(filename)) return {};
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (!callee || callee.type !== "Identifier") return;
+			if (!BANNED_PREFIX_CALLS.has(callee.name)) return;
+			context.report({
+				node: callee,
+				messageId: "banned"
+			});
+		} };
+	}
+};
+var vitest_no_test_prefixes_default = rule$9;
+
+//#endregion
+//#region src/rules/no-log-exception-with-throw.ts
+function isLogCall(node) {
+	return node.type === "CallExpression" && node.callee && node.callee.type === "Identifier" && (node.callee.name === "logException" || node.callee.name === "logError");
+}
+const rule$8 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow logException()/logError() in the same block as a throw statement." },
+		schema: [],
+		messages: { duplicate: "Do not log and throw in the same block. It causes duplicate error reporting; choose one." }
+	},
+	create(context) {
+		const logCalls = [];
+		const throwBlocks = /* @__PURE__ */ new Set();
+		return {
+			CallExpression(node) {
+				if (!isLogCall(node)) return;
+				logCalls.push({
+					node,
+					block: findParentBlock(node)
+				});
+			},
+			ThrowStatement(node) {
+				const block = findParentBlock(node);
+				if (block) throwBlocks.add(block);
+			},
+			"Program:exit"() {
+				for (const log of logCalls) if (log.block && throwBlocks.has(log.block)) context.report({
+					node: log.node,
+					messageId: "duplicate"
+				});
+			}
+		};
+	}
+};
+var no_log_exception_with_throw_default = rule$8;
+
+//#endregion
+//#region src/rules/require-route-middleware.ts
+const HTTP_METHODS = new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH",
+	"OPTIONS",
+	"HEAD"
+]);
+function isHandleMiddlewareCallee(callee) {
+	if (!callee) return false;
+	if (callee.type === "Identifier") return callee.name.startsWith("handle") && callee.name.endsWith("Middleware");
+	if (callee.type === "MemberExpression" && callee.property?.type === "Identifier") {
+		const name = callee.property.name;
+		return name.startsWith("handle") && name.endsWith("Middleware");
+	}
+	return false;
+}
+function expressionIsMiddlewareCall(expr) {
+	if (!expr) return false;
+	if (expr.type === "CallExpression") return isHandleMiddlewareCallee(expr.callee);
+	if (expr.type === "AwaitExpression") {
+		const arg = expr.argument;
+		return arg?.type === "CallExpression" && isHandleMiddlewareCallee(arg.callee);
+	}
+	return false;
+}
+function functionFirstStatementCallsMiddleware(fnNode) {
+	if (!fnNode) return false;
+	if (fnNode.type === "ArrowFunctionExpression" && fnNode.body?.type !== "BlockStatement") return expressionIsMiddlewareCall(fnNode.body);
+	const first = getFirstNonDirectiveStatement(fnNode.body?.type === "BlockStatement" ? fnNode.body.body : []);
+	if (!first) return false;
+	if (first.type === "ReturnStatement") return expressionIsMiddlewareCall(first.argument);
+	if (first.type === "ExpressionStatement") return expressionIsMiddlewareCall(first.expression);
+	if (first.type === "VariableDeclaration") for (const decl of first.declarations || []) {
+		const init = decl?.init;
+		if (!init) continue;
+		if (expressionIsMiddlewareCall(init)) return true;
+	}
+	return false;
+}
+function isFunctionLike(node) {
+	return node && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression");
+}
+const rule$7 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Require route.ts exported HTTP handlers to call handle*Middleware as the first statement." },
+		schema: [],
+		messages: { missing: "The first statement of each exported route handler must be a call to a handle*Middleware function (e.g., handleRouteMiddleware)." }
+	},
+	create(context) {
+		const filename = toPosixPath(context.filename);
+		if (!filename.endsWith("route.ts")) return {};
+		if (filename.includes("/api/v0/")) return {};
+		const handlers = [];
+		return {
+			ExportNamedDeclaration(node) {
+				if (node.declaration?.type === "FunctionDeclaration") {
+					const fn = node.declaration;
+					if (fn.id?.type === "Identifier" && HTTP_METHODS.has(fn.id.name)) handlers.push(fn);
+				}
+				if (node.declaration?.type === "VariableDeclaration") for (const declarator of node.declaration.declarations || []) {
+					if (declarator.id?.type !== "Identifier") continue;
+					if (!HTTP_METHODS.has(declarator.id.name)) continue;
+					if (isFunctionLike(declarator.init)) handlers.push(declarator.init);
+				}
+			},
+			"Program:exit"() {
+				for (const fn of handlers) if (!functionFirstStatementCallsMiddleware(fn)) context.report({
+					node: fn,
+					messageId: "missing"
+				});
+			}
+		};
+	}
+};
+var require_route_middleware_default = rule$7;
+
+//#endregion
+//#region src/rules/require-v0-route-handle-middleware.ts
+function isHandleV0MiddlewareCall(expr) {
+	return expr && expr.type === "CallExpression" && expr.callee?.type === "Identifier" && expr.callee.name === "handleV0RouteMiddleware";
+}
+function handlerStartsWithV0Middleware(fnNode) {
+	if (!fnNode) return false;
+	if (fnNode.type === "ArrowFunctionExpression" && fnNode.body?.type !== "BlockStatement") return isHandleV0MiddlewareCall(fnNode.body);
+	const first = getFirstNonDirectiveStatement(fnNode.body?.type === "BlockStatement" ? fnNode.body.body : []);
+	if (!first) return false;
+	if (first.type === "ReturnStatement") return isHandleV0MiddlewareCall(first.argument);
+	if (first.type === "ExpressionStatement") return isHandleV0MiddlewareCall(first.expression);
+	return false;
+}
+const rule$6 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Require v0 API route handlers to call handleV0RouteMiddleware inside .handler(...)." },
+		schema: [],
+		messages: { missing: "v0 API route handlers must call handleV0RouteMiddleware. Usage: .handler(async (req) => handleV0RouteMiddleware(req, async (user) => { ... }))" }
+	},
+	create(context) {
+		const filename = toPosixPath(context.filename);
+		if (!filename.includes("/api/v0/") || !filename.endsWith("route.ts")) return {};
+		const handlerCalls = [];
+		return {
+			CallExpression(node) {
+				const callee = node.callee;
+				if (callee?.type !== "MemberExpression") return;
+				if (callee.property?.type !== "Identifier" || callee.property.name !== "handler") return;
+				const arg = node.arguments?.[0];
+				if (!arg) return;
+				if (arg.type !== "ArrowFunctionExpression" && arg.type !== "FunctionExpression") return;
+				handlerCalls.push({
+					call: node,
+					fn: arg
+				});
+			},
+			"Program:exit"() {
+				for (const { call, fn } of handlerCalls) if (!handlerStartsWithV0Middleware(fn)) context.report({
+					node: call,
+					messageId: "missing"
+				});
+			}
+		};
+	}
+};
+var require_v0_route_handle_middleware_default = rule$6;
+
+//#endregion
+//#region src/rules/require-v0-strict-schemas.ts
+function isZodObjectCall(node) {
+	return node && node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.object?.type === "Identifier" && node.callee.object.name === "z" && node.callee.property?.type === "Identifier" && node.callee.property.name === "object";
+}
+function isExtendCall(node) {
+	return node && node.type === "CallExpression" && node.callee?.type === "MemberExpression" && node.callee.property?.type === "Identifier" && node.callee.property.name === "extend";
+}
+function hasStrictInChain(node) {
+	let current = node;
+	let parent = current.parent;
+	while (parent) {
+		if (parent.type === "MemberExpression" && parent.object === current) {
+			if (parent.property?.type === "Identifier" && parent.property.name === "strict") return true;
+			current = parent;
+			parent = current.parent;
+			continue;
+		}
+		if (parent.type === "CallExpression" && parent.callee === current) {
+			current = parent;
+			parent = current.parent;
+			continue;
+		}
+		break;
+	}
+	return false;
+}
+function findChainEnd(node) {
+	let current = node;
+	let parent = current.parent;
+	while (parent) {
+		if (parent.type === "CallExpression" && parent.callee?.type === "MemberExpression" && parent.callee.object === current) {
+			current = parent;
+			parent = current.parent;
+			continue;
+		}
+		if (parent.type === "MemberExpression" && parent.object === current) {
+			current = parent;
+			parent = current.parent;
+			continue;
+		}
+		break;
+	}
+	return current;
+}
+const rule$5 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Require .strict() for v0 API Zod schemas." },
+		fixable: "code",
+		schema: [],
+		messages: { missing: "v0 API schemas must use .strict() on z.object() to reject unknown properties. Add .strict() after the object definition." }
+	},
+	create(context) {
+		const filename = toPosixPath(context.filename);
+		if (!filename.includes("/api/v0/")) return {};
+		const isSchemaFile = filename.includes("/schemas/");
+		const isRouteFile = filename.endsWith("route.ts");
+		if (!isSchemaFile && !isRouteFile) return {};
+		return { CallExpression(node) {
+			if (!isZodObjectCall(node) && !isExtendCall(node)) return;
+			if (hasStrictInChain(node)) return;
+			const end = findChainEnd(node);
+			context.report({
+				node: end,
+				messageId: "missing",
+				fix(fixer) {
+					return fixer.insertTextAfter(end, ".strict()");
+				}
+			});
+		} };
+	}
+};
+var require_v0_strict_schemas_default = rule$5;
+
+//#endregion
+//#region src/rules/filename-match-export.ts
+function isUppercaseComponentName(name) {
+	return typeof name === "string" && name[0] === name[0]?.toUpperCase();
+}
+function isReactComponentExport(node) {
+	if (node.type === "FunctionDeclaration" && node.id) return isUppercaseComponentName(node.id.name);
+	if (node.type === "VariableDeclaration") for (const declarator of node.declarations || []) {
+		const id = declarator.id;
+		const init = declarator.init;
+		if (id?.type !== "Identifier") continue;
+		if (!isUppercaseComponentName(id.name)) continue;
+		if (!init) continue;
+		if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") return true;
+	}
+	return false;
+}
+function getExportedName(node) {
+	if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "FunctionDeclaration" && node.declaration.id) return node.declaration.id.name;
+	if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+		const decl = node.declaration.declarations?.[0];
+		if (decl?.id?.type === "Identifier") return decl.id.name;
+	}
+	if (node.type === "ExportDefaultDeclaration" && node.declaration?.type === "FunctionDeclaration" && node.declaration.id) return node.declaration.id.name;
+	if (node.type === "ExportDefaultDeclaration" && node.declaration?.type === "Identifier") return node.declaration.name;
+	return null;
+}
+function stripExt(filename) {
+	const base = node_path.default.basename(filename);
+	const ext = node_path.default.extname(base);
+	return base.slice(0, -ext.length).replace(/\.(tsx|ts|jsx|js)$/, "");
+}
+function suffixExpectationFromFilename(base) {
+	for (const p of [
+		{
+			key: "page",
+			re: /^(.+)\.page\.(tsx|ts|jsx|js)$/i,
+			suffix: "Page"
+		},
+		{
+			key: "module",
+			re: /^(.+)\.module\.(tsx|ts|jsx|js)$/i,
+			suffix: "Module"
+		},
+		{
+			key: "layout",
+			re: /^(.+)\.layout\.(tsx|ts|jsx|js)$/i,
+			suffix: "Layout"
+		},
+		{
+			key: "view",
+			re: /^(.+)\.view\.(tsx|ts|jsx|js)$/i,
+			suffix: "View"
+		},
+		{
+			key: "provider",
+			re: /^(.+)\.provider\.(tsx|ts|jsx|js)$/i,
+			suffix: "Provider"
+		}
+	]) {
+		const m = base.match(p.re);
+		if (m) return {
+			baseName: m[1],
+			suffix: p.suffix
+		};
+	}
+	return null;
+}
+function suggestFilenameFromExport(exportName, ext) {
+	for (const s of [
+		{
+			suffix: "Page",
+			file: "page"
+		},
+		{
+			suffix: "Module",
+			file: "module"
+		},
+		{
+			suffix: "Layout",
+			file: "layout"
+		},
+		{
+			suffix: "View",
+			file: "view"
+		},
+		{
+			suffix: "Provider",
+			file: "provider"
+		}
+	]) if (exportName.endsWith(s.suffix)) return `${exportName.slice(0, -s.suffix.length)}.${s.file}${ext}`;
+	return `${exportName}${ext}`;
+}
+const rule$4 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce that filenames match their single exported React component or single exported function." },
+		schema: [{
+			type: "object",
+			properties: { ignoredFiles: {
+				type: "array",
+				items: { type: "string" }
+			} },
+			additionalProperties: false
+		}],
+		messages: { mismatch: "Filename \"{{filename}}\" should match the exported {{exportType}} name \"{{exportedName}}\". Expected \"{{expectedFilename}}\"." }
+	},
+	create(context) {
+		const filename = context.filename;
+		const base = node_path.default.basename(filename);
+		const ext = node_path.default.extname(base);
+		if ((getFirstOptionObject(context).ignoredFiles || [
+			"utils.ts",
+			"constants.ts",
+			"types.ts",
+			"index.ts",
+			"index.tsx",
+			"index.js",
+			"index.jsx"
+		]).includes(base)) return {};
+		if (base.includes(".test.") || base.includes(".spec.") || base.includes(".stories.")) return {};
+		const exported = [];
+		const components = [];
+		function recordExport(node, name, isComponent) {
+			exported.push({
+				name,
+				node
+			});
+			if (isComponent) components.push({
+				name,
+				node
+			});
+		}
+		return {
+			ExportNamedDeclaration(node) {
+				const name = getExportedName(node);
+				if (!name) return;
+				recordExport(node, name, node.declaration ? isReactComponentExport(node.declaration) : isUppercaseComponentName(name));
+			},
+			ExportDefaultDeclaration(node) {
+				const name = getExportedName(node);
+				if (!name) return;
+				let isComponent = false;
+				const decl = node.declaration;
+				if (decl && (decl.type === "FunctionDeclaration" || decl.type === "VariableDeclaration")) isComponent = isReactComponentExport(decl);
+				else isComponent = isUppercaseComponentName(name);
+				recordExport(node, name, isComponent);
+			},
+			"Program:exit"() {
+				const filenameStem = stripExt(filename);
+				if (components.length === 1) {
+					const comp = components[0];
+					const expectedFromFile = suffixExpectationFromFilename(base);
+					let expectedExportName = filenameStem;
+					if (expectedFromFile) expectedExportName = `${expectedFromFile.baseName}${expectedFromFile.suffix}`;
+					else if ([
+						"Page",
+						"Module",
+						"Layout",
+						"View",
+						"Provider"
+					].some((s) => comp.name.endsWith(s))) {
+						const expectedFilename = suggestFilenameFromExport(comp.name, ext);
+						context.report({
+							node: comp.node,
+							messageId: "mismatch",
+							data: {
+								filename: base,
+								exportType: "React component",
+								exportedName: comp.name,
+								expectedFilename
+							}
+						});
+						return;
+					}
+					if (comp.name !== expectedExportName) {
+						const expectedFilename = suggestFilenameFromExport(comp.name, ext);
+						context.report({
+							node: comp.node,
+							messageId: "mismatch",
+							data: {
+								filename: base,
+								exportType: "React component",
+								exportedName: comp.name,
+								expectedFilename
+							}
+						});
+					}
+					return;
+				}
+				if (components.length === 0 && exported.length === 1) {
+					const item = exported[0];
+					if (item.name !== filenameStem) context.report({
+						node: item.node,
+						messageId: "mismatch",
+						data: {
+							filename: base,
+							exportType: "function",
+							exportedName: item.name,
+							expectedFilename: `${item.name}${ext}`
+						}
+					});
+				}
+			}
+		};
+	}
+};
+var filename_match_export_default = rule$4;
+
+//#endregion
+//#region src/rules/restrict-tsx-components.ts
+function isAllowedFile(filename) {
+	return filename.endsWith(".page.tsx") || filename.endsWith(".page.ts") || filename.endsWith(".module.tsx") || filename.endsWith(".module.ts") || filename.endsWith(".layout.tsx") || filename.endsWith(".layout.ts") || filename.endsWith(".view.tsx") || filename.endsWith(".view.ts") || filename.endsWith(".provider.tsx") || filename.endsWith(".provider.ts");
+}
+function isComponentName(name) {
+	return typeof name === "string" && name[0] === name[0].toUpperCase();
+}
+const rule$3 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce that TSX components are only declared in *.page/module/layout/view/provider files (or allowlist)." },
+		schema: [{
+			type: "object",
+			properties: { allowlist: {
+				type: "array",
+				items: { type: "string" }
+			} },
+			additionalProperties: false
+		}],
+		messages: { restricted: "Component \"{{componentName}}\" cannot be declared in this file. Use *.page/module/layout/view/provider.tsx or add it to the allowlist." }
+	},
+	create(context) {
+		const filename = context.filename;
+		if (isAllowedFile(filename)) return {};
+		const base = node_path.default.basename(filename);
+		if (base.includes(".test.") || base.includes(".spec.") || base.includes(".stories.")) return {};
+		if (!filename.endsWith(".tsx")) return {};
+		const opts = getFirstOptionObject(context);
+		const allowlist = new Set(opts.allowlist ?? []);
+		return {
+			"ExportNamedDeclaration > FunctionDeclaration"(node) {
+				const name = node.id?.name;
+				if (!isComponentName(name)) return;
+				if (allowlist.has(name)) return;
+				context.report({
+					node: node.id,
+					messageId: "restricted",
+					data: { componentName: name }
+				});
+			},
+			"ExportNamedDeclaration > VariableDeclaration > VariableDeclarator"(node) {
+				const name = node.id?.name;
+				if (!isComponentName(name)) return;
+				if (allowlist.has(name)) return;
+				context.report({
+					node: node.id,
+					messageId: "restricted",
+					data: { componentName: name }
+				});
+			},
+			"ExportDefaultDeclaration > FunctionDeclaration"(node) {
+				const name = node.id?.name;
+				if (!isComponentName(name)) return;
+				if (allowlist.has(name)) return;
+				context.report({
+					node: node.id,
+					messageId: "restricted",
+					data: { componentName: name }
+				});
+			},
+			"ExportDefaultDeclaration > Identifier"(node) {
+				const name = node.name;
+				if (!isComponentName(name)) return;
+				if (allowlist.has(name)) return;
+				context.report({
+					node,
+					messageId: "restricted",
+					data: { componentName: name }
+				});
+			}
+		};
+	}
+};
+var restrict_tsx_components_default = rule$3;
+
+//#endregion
+//#region src/rules/no-dynamic-styled-components.ts
+function isInsideFunction(ancestors) {
+	return ancestors.some((a) => [
+		"FunctionDeclaration",
+		"FunctionExpression",
+		"ArrowFunctionExpression",
+		"MethodDefinition",
+		"Property",
+		"PropertyDefinition"
+	].includes(a.type));
+}
+function getLeftMostIdentifier(node) {
+	let current = node;
+	while (current) {
+		if (current.type === "Identifier") return current.name;
+		if (current.type === "MemberExpression") {
+			current = current.object;
+			continue;
+		}
+		if (current.type === "CallExpression") {
+			current = current.callee;
+			continue;
+		}
+		break;
+	}
+	return null;
+}
+const rule$2 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow creating styled-components inside functions/components (must be module scoped)." },
+		schema: [],
+		messages: { dynamic: "Do not create styled-components inside functions/components. Hoist styled definitions to module scope." }
+	},
+	create(context) {
+		const filename = context.filename;
+		if (isTestSpecOrStoryFile(filename)) return {};
+		const styledIdentifiers = /* @__PURE__ */ new Set();
+		return {
+			ImportDeclaration(node) {
+				if (node.source?.value !== "styled-components") return;
+				for (const spec of node.specifiers || []) if (spec.type === "ImportDefaultSpecifier" || spec.type === "ImportNamespaceSpecifier") styledIdentifiers.add(spec.local.name);
+			},
+			TaggedTemplateExpression(node) {
+				if (styledIdentifiers.size === 0) return;
+				const base = getLeftMostIdentifier(node.tag);
+				if (!base || !styledIdentifiers.has(base)) return;
+				if (isInsideFunction(context.sourceCode.getAncestors(node))) context.report({
+					node,
+					messageId: "dynamic"
+				});
+			}
+		};
+	}
+};
+var no_dynamic_styled_components_default = rule$2;
+
+//#endregion
+//#region src/rules/no-plain-html-text-elements.ts
+const RESTRICTED = new Set([
+	"div",
+	"span",
+	"p",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"section",
+	"article",
+	"aside",
+	"header",
+	"footer",
+	"main",
+	"nav",
+	"strong",
+	"em",
+	"b",
+	"i",
+	"u",
+	"s",
+	"small",
+	"mark",
+	"del",
+	"ins",
+	"sub",
+	"sup",
+	"blockquote",
+	"cite",
+	"q",
+	"code",
+	"pre",
+	"kbd",
+	"samp",
+	"var",
+	"time",
+	"address",
+	"abbr",
+	"dfn",
+	"label",
+	"legend",
+	"caption",
+	"th",
+	"td",
+	"li",
+	"dt",
+	"dd",
+	"figcaption",
+	"summary"
+]);
+function hasDirectTextChildren(jsxElement) {
+	const children = jsxElement?.children;
+	if (!Array.isArray(children) || children.length === 0) return false;
+	return children.some((child) => {
+		if (!child) return false;
+		if (child.type === "JSXText") return child.value.trim().length > 0;
+		if (child.type === "JSXExpressionContainer" && child.expression) {
+			const expr = child.expression;
+			if (expr.type === "JSXEmptyExpression") return false;
+			if (expr.type === "Literal") return typeof expr.value === "string" && expr.value.trim().length > 0;
+			if (expr.type === "TemplateLiteral") return true;
+			if (expr.type === "BinaryExpression" && expr.operator === "+") return true;
+			if (expr.type === "ConditionalExpression") return true;
+			if (expr.type === "Identifier") return !["null", "undefined"].includes(expr.name);
+			if (expr.type === "MemberExpression") return true;
+		}
+		return false;
+	});
+}
+const rule$1 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow wrapping text in plain HTML elements." },
+		schema: [{
+			type: "object",
+			properties: {
+				allowedElements: {
+					type: "array",
+					items: { type: "string" }
+				},
+				customMessage: { type: "string" }
+			},
+			additionalProperties: false
+		}],
+		messages: { plain: "Do not wrap text in plain HTML element <{{element}}>. Use a design-system typography component instead." }
+	},
+	create(context) {
+		const opts = getFirstOptionObject(context);
+		const allowed = new Set(opts.allowedElements ?? []);
+		const customMessage = opts.customMessage;
+		return { JSXOpeningElement(node) {
+			if (node.name?.type !== "JSXIdentifier") return;
+			const name = node.name.name;
+			if (!name) return;
+			if (name[0] === name[0].toUpperCase()) return;
+			if (allowed.has(name)) return;
+			if (!RESTRICTED.has(name)) return;
+			const jsxElement = node.parent;
+			if (jsxElement?.type !== "JSXElement") return;
+			if (hasDirectTextChildren(jsxElement)) context.report({
+				node,
+				messageId: customMessage ? void 0 : "plain",
+				message: customMessage,
+				data: { element: name }
+			});
+		} };
+	}
+};
+var no_plain_html_text_elements_default = rule$1;
+
+//#endregion
+//#region src/rules/no-use-effect-in-hooks.ts
+function isInsideCustomHook(ancestors) {
+	for (let i = ancestors.length - 1; i >= 0; i--) {
+		const n = ancestors[i];
+		if (n.type === "FunctionDeclaration" && n.id?.name?.startsWith("use")) return true;
+		if (n.type === "VariableDeclarator" && n.id?.type === "Identifier" && n.id.name.startsWith("use")) return true;
+		if (n.type === "ExportNamedDeclaration" && n.declaration?.type === "VariableDeclaration") {
+			for (const d of n.declaration.declarations || []) if (d.id?.type === "Identifier" && d.id.name.startsWith("use")) return true;
+		}
+	}
+	return false;
+}
+const rule = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow effect hooks inside custom hooks." },
+		schema: [],
+		messages: { noEffect: "Do not use {{hookName}} inside custom hooks. Side effects should be managed by the component using the hook." }
+	},
+	create(context) {
+		const filename = context.filename;
+		if (isTestOrSpecFile(filename)) return {};
+		const sourceCode = context.sourceCode;
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (callee?.type !== "Identifier") return;
+			const hookName = callee.name;
+			if (!hookName || !hookName.toLowerCase().endsWith("effect")) return;
+			if (isInsideCustomHook(sourceCode.getAncestors(node))) context.report({
+				node,
+				messageId: "noEffect",
+				data: { hookName }
+			});
+		} };
+	}
+};
+var no_use_effect_in_hooks_default = rule;
+
+//#endregion
+//#region src/index.ts
+const plugin = {
+	meta: {
+		name: "@kingsword",
+		version: "0.1.0"
+	},
+	rules: {
+		"no-restricted-syntax": no_restricted_syntax_default,
+		"no-exported-function-expressions": no_exported_function_expressions_default,
+		"no-exported-string-union-types": no_exported_string_union_types_default,
+		"structured-logging": structured_logging_default,
+		"enum-file-organization": enum_file_organization_default,
+		"types-file-organization": types_file_organization_default,
+		"constants-file-organization": constants_file_organization_default,
+		"errors-file-organization": errors_file_organization_default,
+		"test-utils-organization": test_utils_organization_default,
+		"test-file-location": test_file_location_default,
+		"require-test-files": require_test_files_default,
+		"require-tsx-test-stories-files": require_tsx_test_stories_files_default,
+		"vitest-mock-absolute-paths": vitest_mock_absolute_paths_default,
+		"vitest-mock-require-actual": vitest_mock_require_actual_default,
+		"vitest-no-focused-tests": vitest_no_focused_tests_default,
+		"vitest-no-disabled-tests": vitest_no_disabled_tests_default,
+		"vitest-no-test-prefixes": vitest_no_test_prefixes_default,
+		"no-log-exception-with-throw": no_log_exception_with_throw_default,
+		"require-route-middleware": require_route_middleware_default,
+		"require-v0-route-handle-middleware": require_v0_route_handle_middleware_default,
+		"require-v0-strict-schemas": require_v0_strict_schemas_default,
+		"filename-match-export": filename_match_export_default,
+		"restrict-tsx-components": restrict_tsx_components_default,
+		"no-dynamic-styled-components": no_dynamic_styled_components_default,
+		"no-plain-html-text-elements": no_plain_html_text_elements_default,
+		"no-use-effect-in-hooks": no_use_effect_in_hooks_default
+	}
+};
+var src_default = plugin;
+
+//#endregion
+module.exports = src_default;