@totto2727/oxlint 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1613 @@
+import { n as effectRuleNames, r as typescriptRuleNames, t as compatibilityRuleNames } from "./rule-groups-jUlABfyW.js";
+import { Predicate, Schema, String } from "effect";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import ts from "typescript-api";
+//#region src/helpers.ts
+const Reportable = Schema.Struct({ range: Schema.mutable(Schema.Tuple([Schema.Number, Schema.Number])) });
+const { hasProperty } = Predicate;
+const isReportable = Schema.is(Reportable);
+const isEqualityOperator = (op) => op === "==" || op === "!=" || op === "===" || op === "!==";
+const getLiteralNumber = (node) => {
+	if (Predicate.isObject(node) && node["type"] === "Literal" && Predicate.isNumber(node["value"])) return node["value"];
+	return null;
+};
+const isSchemaMethodCall = (node, methodName) => {
+	if (Predicate.isObject(node) && node["type"] === "CallExpression" && Predicate.isObject(node["callee"]) && node["callee"]["type"] === "MemberExpression" && !Predicate.isTruthy(node["callee"]["computed"]) && Predicate.isObject(node["callee"]["object"]) && node["callee"]["object"]["type"] === "Identifier" && node["callee"]["object"]["name"] === "Schema" && Predicate.isObject(node["callee"]["property"]) && node["callee"]["property"]["type"] === "Identifier" && node["callee"]["property"]["name"] === methodName) return true;
+	return false;
+};
+const getImportSource = (node) => {
+	if (Predicate.isObject(node) && hasProperty(node, "source") && Predicate.isObject(node["source"]) && hasProperty(node["source"], "value") && Predicate.isString(node["source"]["value"])) return node["source"]["value"];
+	return null;
+};
+//#endregion
+//#region src/rules/force-ts-extension.ts
+/** Bare specifiers and absolute paths are outside this rule family's scope. */
+const matchImportPath = (value) => {
+	const start = /^(\.+|#(?!#)[^/?#]*)(?=\/)/u.exec(value)?.[1];
+	if (start === void 0) return null;
+	const remainder = value.slice(start.length);
+	const suffixIndex = remainder.search(/[?#]/u);
+	const pathname = suffixIndex === -1 ? remainder : remainder.slice(0, suffixIndex);
+	const suffix = suffixIndex === -1 ? "" : remainder.slice(suffixIndex);
+	const basename = pathname.slice(pathname.lastIndexOf("/") + 1);
+	const dot = basename.lastIndexOf(".");
+	return {
+		start,
+		path: pathname,
+		suffix,
+		extension: dot > 0 ? basename.slice(dot) : "",
+		directory: basename === "" || basename === "." || basename === ".."
+	};
+};
+const importExtensionSchema = [{
+	additionalProperties: false,
+	properties: { mode: {
+		enum: ["js", "ts"],
+		type: "string"
+	} },
+	type: "object"
+}];
+const getImportExtensionMode = (option) => typeof option === "object" && option !== null && "mode" in option && option.mode === "js" ? "js" : "ts";
+const extensionTargets = {
+	".js": {
+		js: ".js",
+		ts: ".ts"
+	},
+	".jsx": {
+		js: ".js",
+		ts: ".tsx"
+	},
+	".ts": {
+		js: ".js",
+		ts: ".ts"
+	},
+	".tsx": {
+		js: ".js",
+		ts: ".tsx"
+	},
+	".mjs": {
+		js: ".mjs",
+		ts: ".mts"
+	},
+	".mts": {
+		js: ".mjs",
+		ts: ".mts"
+	},
+	".cjs": {
+		js: ".cjs",
+		ts: ".cts"
+	},
+	".cts": {
+		js: ".cjs",
+		ts: ".cts"
+	}
+};
+/** Preserve explicit ESM/CommonJS families while normalizing code extensions. */
+const normalizeImportExtension = (value, mode) => {
+	const match = matchImportPath(value);
+	if (match === null) return null;
+	const targets = extensionTargets[match.extension];
+	if (targets === void 0) return null;
+	const extension = targets[mode];
+	if (extension === match.extension) return null;
+	return `${match.start}${match.path.slice(0, -match.extension.length)}${extension}${match.suffix}`;
+};
+const quoteLiteral = (value, quote) => {
+	const encoded = JSON.stringify(value);
+	if (quote === "'") return `'${encoded.slice(1, -1).replace(/\\"/gu, "\"").replace(/'/gu, "\\'")}'`;
+	return encoded;
+};
+/** Shared import boundary: null ignores, unchanged text reports without an unsafe fix. */
+const createImportExtensionListeners = (context, replacement, message) => {
+	const check = (node) => {
+		if (!Predicate.isObject(node) || !Predicate.isObject(node["source"])) return;
+		const source = node["source"];
+		if (source["type"] !== "Literal" || typeof source["value"] !== "string" || typeof source["raw"] !== "string" || !isReportable(source)) return;
+		const fixed = replacement(source["value"]);
+		if (fixed === null) return;
+		const quote = source["raw"][0] ?? "\"";
+		context.report({
+			...fixed === source["value"] ? {} : { fix: (fixer) => fixer.replaceText(source, quoteLiteral(fixed, quote)) },
+			message,
+			node: source
+		});
+	};
+	return {
+		ExportAllDeclaration: check,
+		ExportNamedDeclaration: check,
+		ImportDeclaration: check,
+		ImportExpression: check
+	};
+};
+const rule$33 = {
+	create(context) {
+		const mode = getImportExtensionMode(context.options[0]);
+		return createImportExtensionListeners(context, (value) => {
+			const match = matchImportPath(value);
+			if (match !== null && (match.extension === "" || match.directory)) return value;
+			return normalizeImportExtension(value, mode);
+		}, mode === "js" ? "Use explicit JavaScript import extensions (.js, .mjs or .cjs) for code modules" : "Use explicit TypeScript import extensions (.ts, .tsx, .mts or .cts) for code modules");
+	},
+	meta: {
+		fixable: "code",
+		schema: importExtensionSchema,
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/rules/consistent-import-extension.ts
+const rule$32 = {
+	create(context) {
+		const mode = getImportExtensionMode(context.options[0]);
+		return createImportExtensionListeners(context, (value) => normalizeImportExtension(value, mode), mode === "js" ? "Use JavaScript import extensions (.js, .mjs or .cjs) for code modules" : "Use TypeScript import extensions (.ts, .tsx, .mts or .cts) for code modules");
+	},
+	meta: {
+		fixable: "code",
+		schema: importExtensionSchema,
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/rules/force-array-empty.ts
+const isLengthMember = (node) => Predicate.isObject(node) && node["type"] === "MemberExpression" && node["computed"] !== true && Predicate.isObject(node["property"]) && node["property"]["type"] === "Identifier" && node["property"]["name"] === "length";
+const classifyAgainstZero = (operator, literalPosition) => {
+	if (operator === "===" || operator === "==") return "empty";
+	if (operator === "!==" || operator === "!=") return "non-empty";
+	if (operator === ">") return literalPosition === "right" ? "non-empty" : null;
+	if (operator === "<") return literalPosition === "right" ? null : "non-empty";
+	if (operator === ">=") return literalPosition === "right" ? null : "empty";
+	if (operator === "<=") return literalPosition === "right" ? "empty" : null;
+	return null;
+};
+const classifyAgainstOne = (operator, literalPosition) => {
+	if (operator === "<") return literalPosition === "right" ? "empty" : null;
+	if (operator === ">=") return literalPosition === "right" ? "non-empty" : null;
+	if (operator === ">") return literalPosition === "right" ? null : "empty";
+	if (operator === "<=") return literalPosition === "right" ? null : "non-empty";
+	return null;
+};
+const classifyLengthComparison = (operator, literalPosition, literal) => {
+	if (literal === 0) return classifyAgainstZero(operator, literalPosition);
+	if (literal === 1) return classifyAgainstOne(operator, literalPosition);
+	return null;
+};
+const rule$31 = {
+	create(context) {
+		return { BinaryExpression(node) {
+			if (!isReportable(node)) return;
+			if (!Predicate.isObject(node)) return;
+			if (!Predicate.isString(node["operator"])) return;
+			const leftIsLength = isLengthMember(node["left"]);
+			const rightIsLength = isLengthMember(node["right"]);
+			if (!leftIsLength && !rightIsLength) return;
+			const literalPosition = leftIsLength ? "right" : "left";
+			const literalSide = literalPosition === "right" ? node["right"] : node["left"];
+			const literal = getLiteralNumber(literalSide);
+			if (Predicate.isNullish(literal)) return;
+			const kind = classifyLengthComparison(node["operator"], literalPosition, literal);
+			if (Predicate.isNullish(kind)) return;
+			const message = kind === "empty" ? "Use Array.isArrayEmpty()/Array.isReadonlyArrayEmpty() instead of .length comparison" : "Use Array.isArrayNonEmpty()/Array.isReadonlyArrayNonEmpty() instead of .length comparison";
+			context.report({
+				message,
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/force-iterable-empty.ts
+const isIterableSizeCall = (node) => Predicate.isObject(node) && node["type"] === "CallExpression" && Predicate.isObject(node["callee"]) && node["callee"]["type"] === "MemberExpression" && node["callee"]["computed"] !== true && Predicate.isObject(node["callee"]["object"]) && node["callee"]["object"]["type"] === "Identifier" && node["callee"]["object"]["name"] === "Iterable" && Predicate.isObject(node["callee"]["property"]) && node["callee"]["property"]["type"] === "Identifier" && node["callee"]["property"]["name"] === "size";
+const rule$30 = {
+	create(context) {
+		return { BinaryExpression(node) {
+			if (!isReportable(node)) return;
+			if (!Predicate.isObject(node)) return;
+			if (!Predicate.isString(node["operator"])) return;
+			const leftIsSize = isIterableSizeCall(node["left"]);
+			const rightIsSize = isIterableSizeCall(node["right"]);
+			if (!leftIsSize && !rightIsSize) return;
+			const literalPosition = leftIsSize ? "right" : "left";
+			const literalSide = literalPosition === "right" ? node["right"] : node["left"];
+			const literal = getLiteralNumber(literalSide);
+			if (Predicate.isNullish(literal)) return;
+			const kind = classifyLengthComparison(node["operator"], literalPosition, literal);
+			if (Predicate.isNullish(kind)) return;
+			const message = kind === "empty" ? "Use Iterable.isEmpty() instead of Iterable.size() === 0 comparison" : "Use !Iterable.isEmpty() instead of Iterable.size() comparison";
+			context.report({
+				message,
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/force-predicate.ts
+const typeofToPredicateMap = {
+	bigint: "Predicate.isBigInt",
+	boolean: "Predicate.isBoolean",
+	function: "Predicate.isFunction",
+	number: "Predicate.isNumber",
+	object: "Predicate.isObject",
+	string: "Predicate.isString",
+	symbol: "Predicate.isSymbol",
+	undefined: "Predicate.isUndefined"
+};
+const isNullLiteral = (node) => Predicate.isObject(node) && node["type"] === "Literal" && Predicate.isNullish(node["value"]);
+const isUndefinedIdentifier = (node) => Predicate.isObject(node) && node["type"] === "Identifier" && node["name"] === "undefined";
+const getNullishSide = (node) => {
+	if (isNullLiteral(node)) return "null";
+	if (isUndefinedIdentifier(node)) return "undefined";
+	return null;
+};
+const getTypeofType = (node) => {
+	if (Predicate.isObject(node) && node["type"] === "UnaryExpression" && node["operator"] === "typeof") return "typeof";
+	return null;
+};
+const getStringValue = (node) => {
+	if (Predicate.isObject(node) && node["type"] === "Literal" && Predicate.isString(node["value"])) return node["value"];
+	return null;
+};
+const resolveTypeStr = (leftTypeof, rightTypeof, leftStr, rightStr) => {
+	if (Predicate.isNotNullish(leftTypeof)) return rightStr;
+	if (Predicate.isNotNullish(rightTypeof)) return leftStr;
+	return null;
+};
+const rule$29 = {
+	create(context) {
+		return { BinaryExpression(node) {
+			if (!isReportable(node)) return;
+			if (Predicate.isObject(node) && isEqualityOperator(node["operator"])) {
+				const leftKind = getNullishSide(node["left"]);
+				const rightKind = getNullishSide(node["right"]);
+				const kind = leftKind ?? rightKind;
+				if (Predicate.isNotNullish(kind)) {
+					const predicateFn = kind === "null" ? "Predicate.isNull" : "Predicate.isUndefined";
+					context.report({
+						message: `Use ${predicateFn}() instead of direct ${kind} comparison`,
+						node
+					});
+					return;
+				}
+				const leftTypeof = getTypeofType(node["left"]);
+				const rightTypeof = getTypeofType(node["right"]);
+				const leftStr = getStringValue(node["left"]);
+				const rightStr = getStringValue(node["right"]);
+				const typeStr = resolveTypeStr(leftTypeof, rightTypeof, leftStr, rightStr);
+				if (Predicate.isNullish(typeStr)) return;
+				const predicateFn = typeofToPredicateMap[typeStr];
+				if (Predicate.isNullish(predicateFn)) return;
+				context.report({
+					message: `Use ${predicateFn}() instead of typeof comparison`,
+					node
+				});
+			}
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/force-string-empty.ts
+const isEmptyStringLiteral = (node) => Predicate.isObject(node) && node["type"] === "Literal" && Predicate.isString(node["value"]) && String.isEmpty(node["value"]);
+const rule$28 = {
+	create(context) {
+		return { BinaryExpression(node) {
+			if (!isReportable(node)) return;
+			if (Predicate.isObject(node) && isEqualityOperator(node["operator"])) {
+				const leftEmpty = isEmptyStringLiteral(node["left"]);
+				const rightEmpty = isEmptyStringLiteral(node["right"]);
+				if (!leftEmpty && !rightEmpty) return;
+				const predicateFn = node["operator"] === "==" || node["operator"] === "===" ? "String.isEmpty" : "String.isNonEmpty";
+				context.report({
+					message: `Use ${predicateFn}() instead of direct empty string comparison`,
+					node
+				});
+			}
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-effect-import-as.ts
+const EFFECT_IMPORT_RE = /^@?effect(?:\/|$)/u;
+const isEffectEcosystemImport = (sourceValue) => EFFECT_IMPORT_RE.test(sourceValue);
+const checkSpecifierForAs = (spec, context, reportNode) => {
+	if (spec["type"] === "ImportNamespaceSpecifier") {
+		const localName = hasProperty(spec, "local") && Predicate.isObject(spec.local) && hasProperty(spec.local, "name") && Predicate.isString(spec.local.name) ? spec.local.name : "";
+		context.report({
+			message: `Avoid namespace import (\`import * as ${localName}\`) from the effect ecosystem. Use named imports directly.`,
+			node: reportNode
+		});
+		return true;
+	}
+	if (spec["type"] === "ImportSpecifier" && hasProperty(spec, "imported") && hasProperty(spec, "local") && Predicate.isObject(spec.imported) && Predicate.isObject(spec.local) && hasProperty(spec.imported, "name") && hasProperty(spec.local, "name") && Predicate.isString(spec.imported.name) && Predicate.isString(spec.local.name)) {
+		const { name: importedName } = spec.imported;
+		const { name: localName } = spec.local;
+		if (importedName !== localName) {
+			context.report({
+				message: `Avoid aliased import (\`${importedName} as ${localName}\`) from the effect ecosystem. Import \`${importedName}\` directly without aliasing.`,
+				node: reportNode
+			});
+			return true;
+		}
+	}
+	return false;
+};
+const rule$27 = {
+	create(context) {
+		return { ImportDeclaration(node) {
+			const sourceValue = getImportSource(node);
+			if (Predicate.isNullish(sourceValue) || !isEffectEcosystemImport(sourceValue) || !isReportable(node)) return;
+			const specifiers = Predicate.isObject(node) && hasProperty(node, "specifiers") ? node["specifiers"] : null;
+			if (!Array.isArray(specifiers)) return;
+			for (const spec of specifiers) if (Predicate.isObject(spec) && checkSpecifierForAs(spec, context, node)) return;
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-effect-runtime-run.ts
+const RUNTIME_METHODS = /* @__PURE__ */ new Set([
+	"runCallback",
+	"runFork",
+	"runMain",
+	"runPromise",
+	"runPromiseExit",
+	"runSync"
+]);
+const getRuntimeMethod = (node) => {
+	if (Predicate.isObject(node) && node["type"] === "MemberExpression" && node["computed"] !== true && Predicate.isObject(node["property"]) && node["property"]["type"] === "Identifier" && Predicate.isString(node["property"]["name"]) && RUNTIME_METHODS.has(node["property"]["name"])) return node["property"]["name"];
+	return null;
+};
+const isRuntimeCallee = (node) => Predicate.isNotNullish(getRuntimeMethod(node));
+const rule$26 = {
+	create(context) {
+		return { CallExpression(node) {
+			if (!isReportable(node) || !Predicate.isObject(node) || !hasProperty(node, "callee")) return;
+			if (!isRuntimeCallee(node["callee"])) return;
+			context.report({
+				message: "Run Effect runtimes only at workflow boundaries. Move runtime execution to the top-level entrypoint, or disable this rule with a reason for genuinely independent workflows (for example a client-side useEffect).",
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-effect-subpath-import.ts
+const EFFECT_ECOSYSTEM_RE = /^@?effect(?:\/|$)/u;
+const isAllowedEffectImport = (source) => {
+	if (source === "effect") return true;
+	if (/^@effect\/[^/]+$/u.test(source)) return true;
+	if (/^effect\/unstable\/[^/]+$/u.test(source)) return true;
+	return false;
+};
+const rule$25 = {
+	create(context) {
+		return { ImportDeclaration(node) {
+			if (!isReportable(node)) return;
+			if (!Predicate.isObject(node)) return;
+			if (!hasProperty(node, "source")) return;
+			const { source } = node;
+			if (!Predicate.isObject(source)) return;
+			if (!hasProperty(source, "value")) return;
+			if (!Predicate.isString(source.value)) return;
+			if (!EFFECT_ECOSYSTEM_RE.test(source.value)) return;
+			if (isAllowedEffectImport(source.value)) return;
+			context.report({
+				message: `Avoid subpath imports from the effect ecosystem. Import from the package root instead (e.g. \`@effect/platform-node\` not \`@effect/platform-node/NodeRuntime\`).`,
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-error-cause-option.ts
+const NO_ERROR_CAUSE_OPTION_MESSAGE = "Do not pass `{ cause }` to `new Error`. Use `{ error }` instead.";
+const getIdentifierName$3 = (node) => Predicate.isObject(node) && node["type"] === "Identifier" && Predicate.isString(node["name"]) ? node["name"] : null;
+const getPropertyKeyName = (node) => {
+	if (Predicate.isObject(node) && node["type"] === "Identifier" && Predicate.isString(node["name"])) return node["name"];
+	if (Predicate.isObject(node) && node["type"] === "Literal" && Predicate.isString(node["value"])) return node["value"];
+	return null;
+};
+const hasCauseProperty = (node) => Predicate.isObject(node) && node["type"] === "ObjectExpression" && hasProperty(node, "properties") && Array.isArray(node["properties"]) && node["properties"]["some"]((property) => Predicate.isObject(property) && hasProperty(property, "key") ? getPropertyKeyName(property.key) === "cause" : false);
+const isNewErrorWithCauseOption = (node) => Predicate.isObject(node) && node["type"] === "NewExpression" && getIdentifierName$3(node["callee"]) === "Error" && hasProperty(node, "arguments") && Array.isArray(node["arguments"]) && node["arguments"]["some"](hasCauseProperty);
+const rule$24 = {
+	create(context) {
+		return { NewExpression(node) {
+			if (!isReportable(node) || !isNewErrorWithCauseOption(node)) return;
+			context.report({
+				message: NO_ERROR_CAUSE_OPTION_MESSAGE,
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-error-property-access.ts
+const NO_ERROR_PROPERTY_ACCESS_MESSAGE = "Do not access properties on caught error values (`e`, `error`, `c`, `cause`, or `err`). Pass the value through as `error` unchanged.";
+const ERROR_VALUE_NAMES = /* @__PURE__ */ new Set([
+	"c",
+	"cause",
+	"e",
+	"err",
+	"error"
+]);
+const getIdentifierName$2 = (node) => Predicate.isObject(node) && node["type"] === "Identifier" && Predicate.isString(node["name"]) ? node["name"] : null;
+const isErrorPropertyAccess = (node) => Predicate.isObject(node) && node["type"] === "MemberExpression" && Predicate.isObject(node["object"]) && ERROR_VALUE_NAMES.has(getIdentifierName$2(node["object"]) ?? "");
+const rule$23 = {
+	create(context) {
+		return { MemberExpression(node) {
+			if (!isReportable(node) || !isErrorPropertyAccess(node)) return;
+			context.report({
+				message: NO_ERROR_PROPERTY_ACCESS_MESSAGE,
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-eslint-disable-comments.ts
+const ESLINT_DISABLE_RE = /^\s*eslint-disable(?:-next-line|-line)?\b/gmu;
+const rule$22 = {
+	create(context) {
+		return { "Program:exit"() {
+			const comments = context.sourceCode.getAllComments();
+			for (const comment of comments) {
+				const { value } = comment;
+				ESLINT_DISABLE_RE.lastIndex = 0;
+				if (ESLINT_DISABLE_RE.test(value)) {
+					const fixed = value.replaceAll("eslint-disable", "oxlint-disable");
+					context.report({
+						fix(fixer) {
+							const [start, end] = comment.range;
+							const prefix = comment.type === "Block" ? "/*" : "//";
+							const suffix = comment.type === "Block" ? "*/" : "";
+							return fixer.replaceTextRange([start, end], `${prefix}${fixed}${suffix}`);
+						},
+						message: "Use oxlint-disable instead of eslint-disable.",
+						node: comment
+					});
+				}
+			}
+		} };
+	},
+	meta: {
+		fixable: "code",
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/rules/no-fetch.ts
+const FETCH_GLOBALS = /* @__PURE__ */ new Set([
+	"globalThis",
+	"self",
+	"window"
+]);
+const FETCH_GUIDANCE_MESSAGE = "Use Effect `HttpClient` (provide the `FetchHttpClient` layer) instead of the global `fetch`. Bypass only at external-library anti-corruption layers with a documented disable reason.";
+const isFetchIdentifier = (node) => Predicate.isObject(node) && node["type"] === "Identifier" && hasProperty(node, "name") && node["name"] === "fetch";
+const isFetchOnGlobal = (node) => {
+	if (!Predicate.isObject(node) || node["type"] !== "MemberExpression" || node["computed"] === true) return false;
+	if (!isFetchIdentifier(node["property"])) return false;
+	if (!Predicate.isObject(node["object"]) || node["object"]["type"] !== "Identifier") return false;
+	return hasProperty(node["object"], "name") && Predicate.isString(node["object"]["name"]) && FETCH_GLOBALS.has(node["object"]["name"]);
+};
+const rule$21 = {
+	create(context) {
+		return { CallExpression(node) {
+			if (!isReportable(node) || !Predicate.isObject(node) || !hasProperty(node, "callee")) return;
+			const { callee } = node;
+			if (isFetchIdentifier(callee) || isFetchOnGlobal(callee)) context.report({
+				message: FETCH_GUIDANCE_MESSAGE,
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-instanceof-error.ts
+const NO_INSTANCEOF_ERROR_MESSAGE = "Do not use `instanceof Error`. Preserve caught errors as `error` and handle narrowing only in the shared fp error helper with an explicit disable comment.";
+const getIdentifierName$1 = (node) => Predicate.isObject(node) && node["type"] === "Identifier" && Predicate.isString(node["name"]) ? node["name"] : null;
+const isInstanceofError = (node) => Predicate.isObject(node) && node["type"] === "BinaryExpression" && node["operator"] === "instanceof" && getIdentifierName$1(node["right"]) === "Error";
+const rule$20 = {
+	create(context) {
+		return { BinaryExpression(node) {
+			if (!isReportable(node) || !isInstanceofError(node)) return;
+			context.report({
+				message: NO_INSTANCEOF_ERROR_MESSAGE,
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-js-date.ts
+const FORBIDDEN_DATE_STATIC_METHODS = /* @__PURE__ */ new Set([
+	"now",
+	"parse",
+	"UTC"
+]);
+const isDateIdentifier = (node) => Predicate.isObject(node) && node["type"] === "Identifier" && node["name"] === "Date";
+const getForbiddenDateStaticMethod = (node) => {
+	if (Predicate.isObject(node) && node["type"] === "MemberExpression" && node["computed"] !== true && isDateIdentifier(node["object"]) && Predicate.isObject(node["property"]) && node["property"]["type"] === "Identifier" && Predicate.isString(node["property"]["name"]) && FORBIDDEN_DATE_STATIC_METHODS.has(node["property"]["name"])) return node["property"]["name"];
+	return null;
+};
+const rule$19 = {
+	create(context) {
+		return {
+			MemberExpression(node) {
+				if (!isReportable(node)) return;
+				const method = getForbiddenDateStaticMethod(node);
+				if (Predicate.isNotNullish(method)) context.report({
+					message: `Use Effect \`DateTime\` / \`Duration\` instead of \`Date.${method}()\`. Native \`Date\` is allowed only at external-API boundaries.`,
+					node
+				});
+			},
+			NewExpression(node) {
+				if (!isReportable(node)) return;
+				if (Predicate.isObject(node) && isDateIdentifier(node["callee"])) context.report({
+					message: "Use Effect `DateTime` / `Duration` instead of `new Date()`. Native `Date` is allowed only at external-API boundaries.",
+					node
+				});
+			}
+		};
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-jsx-script-tag.ts
+const isScriptJsxElement = (node) => Predicate.isObject(node) && node["type"] === "JSXOpeningElement" && Predicate.isObject(node["name"]) && node["name"].type === "JSXIdentifier" && node["name"].name === "script";
+const rule$18 = {
+	create(context) {
+		return { JSXOpeningElement(node) {
+			if (!isReportable(node)) return;
+			if (isScriptJsxElement(node)) context.report({
+				message: "Do not use <script> tags in JSX. Write client-side logic in React or Remix v3 components instead. If unavoidable (e.g. a third-party inline script), disable this rule with an oxlint-disable comment that includes the reason.",
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-let.ts
+const isLetDeclaration = (node) => Predicate.isObject(node) && node["kind"] === "let";
+const rule$17 = {
+	create(context) {
+		return { VariableDeclaration(node) {
+			if (!isReportable(node)) return;
+			if (isLetDeclaration(node)) context.report({
+				message: "Use const with shadowing instead of let. Reassignment via let is prohibited.",
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-node-imports.ts
+const NODE_PROTOCOL = "node:";
+const NODE_IMPORT_GUIDANCE_MESSAGE = "Avoid Node.js built-in imports. Prefer Effect Platform APIs from `effect` / `@effect/platform-node`; add a rule whitelist entry only for documented exceptions.";
+const getNodeBuiltinSpecifier = (source) => {
+	if (!source.startsWith(NODE_PROTOCOL)) return null;
+	return source.slice(5);
+};
+const getStringArrayProperty = (value, key) => {
+	if (!Predicate.isObject(value) || !hasProperty(value, key) || !Array.isArray(value[key])) return [];
+	return value[key].filter(Predicate.isString);
+};
+const getContextOptions = (context) => {
+	if (!Predicate.isObject(context) || !hasProperty(context, "options")) return [];
+	const { options } = context;
+	return Array.isArray(options) ? options : [];
+};
+const getAllowedNodeBuiltins = (context) => {
+	const first = getContextOptions(context).at(0);
+	if (Array.isArray(first)) return new Set(first.filter(Predicate.isString));
+	return /* @__PURE__ */ new Set([...getStringArrayProperty(first, "allow"), ...getStringArrayProperty(first, "allowed")]);
+};
+const reportNodeImport = (node, context) => {
+	const source = getImportSource(node);
+	if (Predicate.isNullish(source) || !isReportable(node)) return;
+	const builtin = getNodeBuiltinSpecifier(source);
+	if (Predicate.isNullish(builtin) || getAllowedNodeBuiltins(context).has(builtin)) return;
+	context.report({
+		message: NODE_IMPORT_GUIDANCE_MESSAGE,
+		node
+	});
+};
+const rule$16 = {
+	create(context) {
+		return {
+			ExportAllDeclaration(node) {
+				reportNodeImport(node, context);
+			},
+			ExportNamedDeclaration(node) {
+				reportNodeImport(node, context);
+			},
+			ImportDeclaration(node) {
+				reportNodeImport(node, context);
+			}
+		};
+	},
+	meta: {
+		schema: [{ anyOf: [{
+			items: { type: "string" },
+			type: "array"
+		}, {
+			additionalProperties: false,
+			properties: {
+				allow: {
+					items: { type: "string" },
+					type: "array"
+				},
+				allowed: {
+					items: { type: "string" },
+					type: "array"
+				}
+			},
+			type: "object"
+		}] }],
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/rules/no-option-tag-comparison.ts
+const tagToPredicateMap = {
+	None: "Option.isNone",
+	Some: "Option.isSome"
+};
+const getOptionTag = (node) => {
+	if (Predicate.isObject(node) && node["type"] === "Literal" && Predicate.isString(node["value"])) {
+		const { value } = node;
+		if (value in tagToPredicateMap) return value;
+	}
+	return null;
+};
+const isTagPropertyAccess = (node) => Predicate.isObject(node) && node["type"] === "MemberExpression" && node["computed"] !== true && Predicate.isObject(node["property"]) && node["property"]["type"] === "Identifier" && node["property"]["name"] === "_tag";
+const isTypeofTag = (node) => Predicate.isObject(node) && node["type"] === "UnaryExpression" && node["operator"] === "typeof" && isTagPropertyAccess(node["argument"]);
+const rule$15 = {
+	create(context) {
+		return { BinaryExpression(node) {
+			if (!isReportable(node)) return;
+			if (Predicate.isObject(node) && isEqualityOperator(node["operator"])) {
+				const leftTag = getOptionTag(node["left"]);
+				const rightTag = getOptionTag(node["right"]);
+				const tag = leftTag ?? rightTag;
+				if (Predicate.isNullish(tag)) return;
+				const otherSide = Predicate.isNotNullish(leftTag) ? node["right"] : node["left"];
+				if (isTagPropertyAccess(otherSide) || isTypeofTag(otherSide)) {
+					const predicateFn = tagToPredicateMap[tag];
+					const isEquality = node["operator"] === "==" || node["operator"] === "===";
+					context.report({
+						fix(fixer) {
+							const rawTarget = hasProperty(otherSide, "object") ? otherSide.object : otherSide;
+							if (!isReportable(rawTarget)) return null;
+							const sourceText = context.sourceCode.getText(rawTarget);
+							const prefix = isEquality ? "" : "!";
+							return fixer.replaceText(node, `${prefix}${predicateFn}(${sourceText})`);
+						},
+						message: `Use ${predicateFn}() instead of _tag === '${tag}'`,
+						node
+					});
+				}
+			}
+		} };
+	},
+	meta: {
+		fixable: "code",
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/rules/no-raw-hono-create-middleware.ts
+const HONO_FACTORY_SOURCE = "hono/factory";
+const CREATE_MIDDLEWARE_NAME = "createMiddleware";
+const MESSAGE = "Do not use raw `createMiddleware` from `hono/factory` in application code. Use the shared `factory.createMiddleware` instance instead. Shared library code may disable this rule with a reason.";
+const getIdentifierName = (node) => Predicate.isObject(node) && hasProperty(node, "name") && Predicate.isString(node["name"]) ? node["name"] : null;
+const isCreateMiddlewareImportSpecifier = (node) => Predicate.isObject(node) && node["type"] === "ImportSpecifier" && hasProperty(node, "imported") && getIdentifierName(node["imported"]) === CREATE_MIDDLEWARE_NAME;
+const isNamespaceCreateMiddlewareCall = (node, namespaceNames) => {
+	if (!Predicate.isObject(node) || node["type"] !== "CallExpression" || !hasProperty(node, "callee")) return false;
+	const { callee } = node;
+	if (!Predicate.isObject(callee) || callee["type"] !== "MemberExpression" || callee["computed"] === true) return false;
+	if (getIdentifierName(callee["property"]) !== CREATE_MIDDLEWARE_NAME) return false;
+	const objectName = getIdentifierName(callee["object"]);
+	return !Predicate.isNullish(objectName) && namespaceNames.has(objectName);
+};
+const rule$14 = {
+	create(context) {
+		const honoFactoryNamespaceNames = /* @__PURE__ */ new Set();
+		return {
+			CallExpression(node) {
+				if (!isReportable(node) || !isNamespaceCreateMiddlewareCall(node, honoFactoryNamespaceNames)) return;
+				context.report({
+					message: MESSAGE,
+					node
+				});
+			},
+			ImportDeclaration(node) {
+				if (getImportSource(node) !== HONO_FACTORY_SOURCE || !isReportable(node)) return;
+				const specifiers = Predicate.isObject(node) && hasProperty(node, "specifiers") ? node["specifiers"] : null;
+				if (!Array.isArray(specifiers)) return;
+				for (const specifier of specifiers) {
+					if (!Predicate.isObject(specifier)) continue;
+					if (isCreateMiddlewareImportSpecifier(specifier)) {
+						context.report({
+							message: MESSAGE,
+							node
+						});
+						continue;
+					}
+					if (specifier["type"] === "ImportNamespaceSpecifier" && hasProperty(specifier, "local")) {
+						const localName = getIdentifierName(specifier.local);
+						if (!Predicate.isNullish(localName)) honoFactoryNamespaceNames.add(localName);
+					}
+				}
+			}
+		};
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-redundant-alias.ts
+const REDUNDANT_TYPE_ALIAS_MESSAGE = "Avoid type aliases that merely rename another type (e.g. `type SentEmail = SendParams`). Inline the original, or keep the alias only inside an anti-corruption layer with a documented disable reason.";
+const REDUNDANT_VALUE_ALIAS_MESSAGE = "Avoid exported bindings that merely rename another value (e.g. `export const sentEmail = sendParams`). Re-export the original directly, or keep the alias only inside an anti-corruption layer with a documented disable reason.";
+const hasTypeArguments = (node) => Predicate.isObject(node) && hasProperty(node, "typeArguments") && Predicate.isNotNullish(node["typeArguments"]);
+const hasGenericTypeParameters = (node) => Predicate.isObject(node) && hasProperty(node, "typeParameters") && Predicate.isNotNullish(node["typeParameters"]);
+const isPlainTypeReference = (node) => Predicate.isObject(node) && node["type"] === "TSTypeReference" && !hasTypeArguments(node);
+const isRedundantTypeAlias = (node) => {
+	if (!Predicate.isObject(node) || node["type"] !== "TSTypeAliasDeclaration") return false;
+	if (hasGenericTypeParameters(node)) return false;
+	return hasProperty(node, "typeAnnotation") && isPlainTypeReference(node["typeAnnotation"]);
+};
+const isIdentifierInitDeclarator = (declarator) => Predicate.isObject(declarator) && hasProperty(declarator, "id") && Predicate.isObject(declarator.id) && declarator.id["type"] === "Identifier" && hasProperty(declarator, "init") && Predicate.isObject(declarator.init) && declarator.init["type"] === "Identifier";
+const rule$13 = {
+	create(context) {
+		return {
+			ExportNamedDeclaration(node) {
+				if (!isReportable(node) || !Predicate.isObject(node) || !hasProperty(node, "declaration")) return;
+				const { declaration } = node;
+				if (!Predicate.isObject(declaration) || declaration["type"] !== "VariableDeclaration" || !hasProperty(declaration, "declarations") || !Array.isArray(declaration.declarations)) return;
+				const declarationItems = declaration.declarations;
+				for (const declarator of declarationItems) if (isReportable(declarator) && isIdentifierInitDeclarator(declarator)) context.report({
+					message: REDUNDANT_VALUE_ALIAS_MESSAGE,
+					node: declarator
+				});
+			},
+			TSTypeAliasDeclaration(node) {
+				if (!isReportable(node)) return;
+				if (isRedundantTypeAlias(node)) context.report({
+					message: REDUNDANT_TYPE_ALIAS_MESSAGE,
+					node
+				});
+			}
+		};
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-string-style.ts
+const hasStringStyleValue = (node) => Predicate.isObject(node) && node["type"] === "JSXAttribute" && Predicate.isObject(node["name"]) && node["name"].name === "style" && Predicate.isObject(node["value"]) && node["value"].type === "Literal" && Predicate.isString(node["value"].value);
+const rule$12 = {
+	create(context) {
+		return { JSXAttribute(node) {
+			if (!isReportable(node)) return;
+			if (hasStringStyleValue(node)) context.report({
+				message: "Use object-style `style={{ ... }}` instead of string `style=\"...\"`.",
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-sync-decode.ts
+const BANNED_DECODE_METHODS = {
+	decodePromise: "decodeEffect",
+	decodeSync: "decodeEffect",
+	decodeUnknownPromise: "decodeUnknownEffect",
+	decodeUnknownSync: "decodeUnknownEffect"
+};
+const isSchemaBannedDecodeCall = (node) => {
+	for (const method of Object.keys(BANNED_DECODE_METHODS)) if (isSchemaMethodCall(node, method)) return method;
+	return null;
+};
+const rule$11 = {
+	create(context) {
+		return { CallExpression(node) {
+			if (!isReportable(node)) return;
+			const method = isSchemaBannedDecodeCall(node);
+			if (Predicate.isNotNullish(method)) {
+				const recommended = BANNED_DECODE_METHODS[method];
+				context.report({
+					message: `Use Schema.${recommended} or Schema.decodeExit instead of Schema.${method}.`,
+					node
+				});
+			}
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/no-type-predicate.ts
+const NO_TYPE_PREDICATE_MESSAGE = "Do not use TypeScript type predicate annotations (`value is Type`). Model the value with Effect Schema and use `Schema.is(...)` instead.";
+const isTypePredicateAnnotation = (node) => Predicate.isObject(node) && node["type"] === "TSTypePredicate";
+const rule$10 = {
+	create(context) {
+		return { TSTypePredicate(node) {
+			if (!isReportable(node) || !isTypePredicateAnnotation(node)) return;
+			context.report({
+				message: NO_TYPE_PREDICATE_MESSAGE,
+				node
+			});
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/prefer-is-nullish.ts
+const NULLISH_PREDICATE_METHODS = /* @__PURE__ */ new Set([
+	"isNull",
+	"isNotNull",
+	"isUndefined",
+	"isNotUndefined"
+]);
+const getNullishPredicateMember = (node) => {
+	if (!Predicate.isObject(node) || !Predicate.isObject(node["object"]) || node["object"]["type"] !== "Identifier" || node["object"]["name"] !== "Predicate" || !Predicate.isObject(node["property"]) || node["property"]["type"] !== "Identifier" || !Predicate.isString(node["property"]["name"])) return null;
+	const { name } = node["property"];
+	return NULLISH_PREDICATE_METHODS.has(name) ? name : null;
+};
+const rule$9 = {
+	create(context) {
+		return { MemberExpression(node) {
+			if (!isReportable(node)) return;
+			const method = getNullishPredicateMember(node);
+			if (Predicate.isNullish(method)) return;
+			const recommended = method.startsWith("isNot") ? "isNotNullish" : "isNullish";
+			context.report({
+				message: `Use Predicate.${recommended} to treat null and undefined uniformly. Only when distinguishing them is required, disable this rule with an oxlint-disable comment that includes the reason.`,
+				node
+			});
+		} };
+	},
+	meta: { type: "suggestion" }
+};
+//#endregion
+//#region src/rules/prefer-non-unknown-decode.ts
+const UNKNOWN_DECODE_METHODS = {
+	decodeUnknownEffect: "decodeEffect",
+	decodeUnknownExit: "decodeExit"
+};
+const isSchemaUnknownDecodeCall = (node) => {
+	for (const method of Object.keys(UNKNOWN_DECODE_METHODS)) if (isSchemaMethodCall(node, method)) return method;
+	return null;
+};
+const rule$8 = {
+	create(context) {
+		return { CallExpression(node) {
+			if (!isReportable(node)) return;
+			const method = isSchemaUnknownDecodeCall(node);
+			if (Predicate.isNotNullish(method)) {
+				const recommended = UNKNOWN_DECODE_METHODS[method];
+				context.report({
+					message: `Prefer Schema.${recommended} over Schema.${method}. Use unknown variants only when input type is truly unknown. Add an oxlint-disable comment if the unknown variant is required.`,
+					node
+				});
+			}
+		} };
+	},
+	meta: { type: "suggestion" }
+};
+//#endregion
+//#region src/rules/require-disable-reason.ts
+const OXLINT_DISABLE_DIRECTIVE_RE = /\boxlint-disable\b/u;
+const DISABLE_REASON_RE = /\s--\s+\S/u;
+const isOxlintDisableDirective = (value) => OXLINT_DISABLE_DIRECTIVE_RE.test(value);
+const hasDisableReason = (value) => DISABLE_REASON_RE.test(value);
+const rule$7 = {
+	create(context) {
+		return { "Program:exit"() {
+			const comments = context.sourceCode.getAllComments();
+			for (const comment of comments) {
+				const { value } = comment;
+				if (!isOxlintDisableDirective(value)) continue;
+				if (hasDisableReason(value)) continue;
+				context.report({
+					message: "oxlint-disable comments must include a reason in the form `<disable directive> -- <reason>`.",
+					node: comment
+				});
+			}
+		} };
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/rules/require-import-extension.ts
+const rule$6 = {
+	create: (context) => createImportExtensionListeners(context, (value) => {
+		const match = matchImportPath(value);
+		return match !== null && (match.extension === "" || match.directory) ? value : null;
+	}, "Use an explicit extension in relative and subpath imports"),
+	meta: {
+		schema: [],
+		type: "problem"
+	}
+};
+//#endregion
+//#region src/rules/require-top-level-decoder.ts
+const TOP_LEVEL_DECODER_MESSAGE = "Hoist schema decoder construction to module top level and call the cached function inside this scope. Building the decoder per call re-runs the schema compilation on every invocation.";
+const matchMemberCallByPrefix = (node, namespace, prefix) => {
+	if (!Predicate.isObject(node) || node["type"] !== "CallExpression" || !Predicate.isObject(node["callee"]) || node["callee"]["type"] !== "MemberExpression" || Predicate.isTruthy(node["callee"]["computed"])) return false;
+	const { object, property } = node["callee"];
+	if (!Predicate.isObject(object) || object["type"] !== "Identifier" || !hasProperty(object, "name") || object.name !== namespace) return false;
+	if (!Predicate.isObject(property) || property["type"] !== "Identifier" || !hasProperty(property, "name") || !Predicate.isString(property.name)) return false;
+	return property.name.startsWith(prefix);
+};
+const isHoistableDecoderCall = (node) => matchMemberCallByPrefix(node, "Schema", "decode") || matchMemberCallByPrefix(node, "HttpClientResponse", "schema");
+const rule$5 = {
+	create(context) {
+		const functionStack = [];
+		const enterFunction = () => {
+			functionStack.push(true);
+		};
+		const exitFunction = () => {
+			functionStack.pop();
+		};
+		return {
+			ArrowFunctionExpression: enterFunction,
+			"ArrowFunctionExpression:exit": exitFunction,
+			CallExpression(node) {
+				if (Predicate.isNullish(functionStack[0]) || !isReportable(node)) return;
+				if (isHoistableDecoderCall(node)) context.report({
+					message: TOP_LEVEL_DECODER_MESSAGE,
+					node
+				});
+			},
+			FunctionDeclaration: enterFunction,
+			"FunctionDeclaration:exit": exitFunction,
+			FunctionExpression: enterFunction,
+			"FunctionExpression:exit": exitFunction
+		};
+	},
+	meta: { type: "problem" }
+};
+//#endregion
+//#region src/upstream/effect/no-bigint-literals.ts
+const rule$4 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow bigint literals" },
+		fixable: "code"
+	},
+	create(context) {
+		return { Literal(node) {
+			if (typeof node.value === "bigint") {
+				const fixedSource = `BigInt("${node.value}")`;
+				context.report({
+					node,
+					message: "BigInt literals are not allowed",
+					fix: (fixer) => fixer.replaceText(node, fixedSource)
+				});
+			}
+		} };
+	}
+};
+//#endregion
+//#region src/upstream/effect/no-import-from-barrel-package.ts
+const extensions = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+];
+function getModuleName(specifier) {
+	return specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+}
+function isRelativeImport$1(source) {
+	return source.startsWith("./") || source.startsWith("../");
+}
+function hasIndexFile(dirPath) {
+	for (const ext of extensions) if (fs.existsSync(path.join(dirPath, `index${ext}`))) return true;
+	return false;
+}
+function isIndexImport(importPath) {
+	const basename = path.basename(importPath);
+	return basename === "index" || /^index\.(ts|tsx|js|jsx|mts|cts|mjs|cjs)$/.test(basename);
+}
+function resolvesToBarrel(importSource, currentFile) {
+	const dir = path.dirname(currentFile);
+	const resolved = path.resolve(dir, importSource);
+	if (isIndexImport(importSource)) return true;
+	if (hasIndexFile(resolved)) return true;
+	return false;
+}
+function createBarrelMatcher(options) {
+	const patterns = (options.checkPatterns ?? []).map((p) => new RegExp(p));
+	const checkRelative = options.checkRelativeIndexImports !== false;
+	return (source, currentFile) => {
+		if (isRelativeImport$1(source)) return checkRelative && resolvesToBarrel(source, currentFile);
+		for (const pattern of patterns) if (pattern.test(source)) return true;
+		return false;
+	};
+}
+const rule$3 = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow importing from barrel files (index.ts), encourage importing specific modules instead" },
+		schema: [{
+			type: "object",
+			properties: {
+				checkPatterns: {
+					type: "array",
+					items: { type: "string" },
+					description: "Regex patterns to match barrel imports"
+				},
+				checkRelativeIndexImports: {
+					type: "boolean",
+					description: "Whether to check relative imports that resolve to index files"
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	create(context) {
+		const currentFile = context.filename;
+		const isBarrelImport = createBarrelMatcher(context.options[0] ?? {});
+		return { ImportDeclaration(node) {
+			if (node.importKind === "type") return;
+			const importSource = node.source.value;
+			if (!isBarrelImport(importSource, currentFile)) return;
+			const namespaceSpecifiers = [];
+			const namedValueSpecifiers = [];
+			for (const specifier of node.specifiers) if (specifier.type === "ImportNamespaceSpecifier") namespaceSpecifiers.push(specifier);
+			else if (specifier.type === "ImportSpecifier") {
+				if (specifier.importKind !== "type") namedValueSpecifiers.push(specifier);
+			}
+			for (const specifier of namespaceSpecifiers) context.report({
+				node: specifier,
+				message: `Do not use namespace import from barrel file "${importSource}", import from specific modules instead`
+			});
+			for (const specifier of namedValueSpecifiers) {
+				const moduleName = getModuleName(specifier);
+				const localName = specifier.local.name;
+				const message = isRelativeImport$1(importSource) ? `Do not import "${moduleName}" from barrel file "${importSource}", import from specific module instead` : `Use import * as ${localName} from "${importSource}/${moduleName}" instead`;
+				context.report({
+					node: specifier,
+					message
+				});
+			}
+		} };
+	}
+};
+//#endregion
+//#region src/upstream/effect/no-js-extension-imports.ts
+const jsExtensions = [
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+];
+const extensionMap = {
+	".js": ".ts",
+	".jsx": ".tsx",
+	".mjs": ".mts",
+	".cjs": ".cts"
+};
+function isRelativeImport(source) {
+	return source.startsWith("./") || source.startsWith("../");
+}
+function getJsExtension(source) {
+	for (const ext of jsExtensions) if (source.endsWith(ext)) return ext;
+}
+const rule$2 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow .js, .jsx, .mjs and .cjs extensions in relative imports, use .ts, .tsx, .mts or .cts instead" },
+		fixable: "code"
+	},
+	create(context) {
+		function checkSource(source) {
+			const value = source.value;
+			if (!isRelativeImport(value)) return;
+			const ext = getJsExtension(value);
+			if (!ext) return;
+			const tsExt = extensionMap[ext];
+			const fixedSource = value.slice(0, -ext.length) + tsExt;
+			context.report({
+				node: source,
+				message: `Use "${tsExt}" extension instead of "${ext}" for relative imports`,
+				fix: (fixer) => fixer.replaceTextRange(source.range, JSON.stringify(fixedSource))
+			});
+		}
+		function handleImportDeclaration(node) {
+			checkSource(node.source);
+		}
+		function handleExportAllDeclaration(node) {
+			checkSource(node.source);
+		}
+		function handleExportNamedDeclaration(node) {
+			if (node.source) checkSource(node.source);
+		}
+		return {
+			ImportDeclaration: handleImportDeclaration,
+			ExportAllDeclaration: handleExportAllDeclaration,
+			ExportNamedDeclaration: handleExportNamedDeclaration
+		};
+	}
+};
+//#endregion
+//#region src/upstream/effect/no-opaque-instance-fields.ts
+const SCHEMA_SOURCES = /* @__PURE__ */ new Set(["effect", "effect/Schema"]);
+const SCHEMA_NAMESPACE_SOURCES = /* @__PURE__ */ new Set(["effect/Schema"]);
+const rule$1 = {
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow instance members in Schema.Opaque classes" }
+	},
+	create(context) {
+		const schemaIdentifiers = /* @__PURE__ */ new Set();
+		const opaqueIdentifiers = /* @__PURE__ */ new Set();
+		function isSchemaOpaqueExtension(node) {
+			const sc = node.superClass;
+			if (!sc || sc.type !== "CallExpression") return false;
+			const inner = sc.callee;
+			if (!inner || inner.type !== "CallExpression") return false;
+			return isOpaqueCallee(inner.callee);
+		}
+		function isOpaqueCallee(node) {
+			if (!node) return false;
+			if (node.type === "Identifier") return opaqueIdentifiers.has(node.name);
+			if (node.type !== "MemberExpression") return false;
+			if (node.property?.type !== "Identifier" || node.property.name !== "Opaque") return false;
+			return isSchemaObject(node.object);
+		}
+		function isSchemaObject(node) {
+			if (!node) return false;
+			if (node.type === "Identifier") return schemaIdentifiers.has(node.name);
+			return false;
+		}
+		function checkClass(node) {
+			if (!isSchemaOpaqueExtension(node)) return;
+			for (const element of node.body.body) if (element.type === "PropertyDefinition" && !element.static) context.report({
+				node: element,
+				message: "Classes extending Schema.Opaque must not have instance members"
+			});
+			else if (element.type === "MethodDefinition" && !element.static) context.report({
+				node: element,
+				message: "Classes extending Schema.Opaque must not have instance members"
+			});
+		}
+		return {
+			ImportDeclaration(node) {
+				if (node.importKind === "type") return;
+				const source = node.source.value;
+				if (typeof source !== "string" || !SCHEMA_SOURCES.has(source)) return;
+				for (const specifier of node.specifiers) if (specifier.type === "ImportNamespaceSpecifier") {
+					if (SCHEMA_NAMESPACE_SOURCES.has(source)) schemaIdentifiers.add(specifier.local.name);
+				} else if (specifier.type === "ImportSpecifier" && specifier.importKind !== "type") {
+					if (specifier.imported.type !== "Identifier") continue;
+					const importedName = specifier.imported.name;
+					if (importedName === "Schema") schemaIdentifiers.add(specifier.local.name);
+					else if (importedName === "Opaque") opaqueIdentifiers.add(specifier.local.name);
+				}
+			},
+			ClassDeclaration: checkClass,
+			ClassExpression: checkClass
+		};
+	}
+};
+//#endregion
+//#region src/upstream/effect/no-unused-internal.ts
+const cache = /* @__PURE__ */ new Map();
+const sourceExtensions = /* @__PURE__ */ new Set([".ts"]);
+function getCwd(context) {
+	return context.cwd ?? context.getCwd?.() ?? process.cwd();
+}
+function normalizePathName(filename) {
+	return path.resolve(filename).split(path.sep).join("/");
+}
+function rangeNode(range) {
+	return { range: [range[0], range[1]] };
+}
+function isSourceFile(fileName) {
+	return sourceExtensions.has(path.extname(fileName)) && !fileName.endsWith(".d.ts");
+}
+function findSourceFiles(cwd) {
+	const packagesDir = path.join(cwd, "packages");
+	if (!fs.existsSync(packagesDir)) return [];
+	const files = [];
+	const visit = (directory) => {
+		for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+			const entryPath = path.join(directory, entry.name);
+			if (entry.isDirectory()) {
+				if (entry.name !== "dist" && entry.name !== "build" && entry.name !== "node_modules") visit(entryPath);
+			} else if (entry.isFile() && isSourceFile(entryPath) && normalizePathName(entryPath).includes("/src/")) files.push(entryPath);
+		}
+	};
+	visit(packagesDir);
+	return files;
+}
+function findWorkspacePackages(cwd) {
+	const packagesDir = path.join(cwd, "packages");
+	const packages = /* @__PURE__ */ new Map();
+	if (!fs.existsSync(packagesDir)) return packages;
+	const visit = (directory) => {
+		const packageJson = path.join(directory, "package.json");
+		if (fs.existsSync(packageJson)) {
+			try {
+				const json = JSON.parse(fs.readFileSync(packageJson, "utf8"));
+				if (typeof json.name === "string") packages.set(json.name, directory);
+			} catch {}
+			return;
+		}
+		for (const entry of fs.readdirSync(directory, { withFileTypes: true })) if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist" && entry.name !== "build") visit(path.join(directory, entry.name));
+	};
+	visit(packagesDir);
+	return packages;
+}
+function resolveSourceFile(basePath) {
+	const candidates = path.extname(basePath) === ".ts" ? [basePath] : [
+		basePath,
+		`${basePath}.ts`,
+		path.join(basePath, "index.ts")
+	];
+	for (const candidate of candidates) if (fs.existsSync(candidate) && isSourceFile(candidate)) return normalizePathName(candidate);
+}
+function resolveModule(source, containingFile, workspacePackages) {
+	if (source.startsWith("./") || source.startsWith("../")) return resolveSourceFile(path.resolve(path.dirname(containingFile), source));
+	let packageName;
+	for (const name of workspacePackages.keys()) if (source === name || source.startsWith(`${name}/`)) {
+		if (packageName === void 0 || name.length > packageName.length) packageName = name;
+	}
+	if (packageName === void 0) return void 0;
+	const packageRoot = workspacePackages.get(packageName);
+	if (packageRoot === void 0) return void 0;
+	if (source === packageName) return resolveSourceFile(path.join(packageRoot, "src", "index.ts"));
+	const subpath = source.slice(packageName.length + 1);
+	return resolveSourceFile(path.join(packageRoot, "src", subpath));
+}
+function hasModifier(node, kind) {
+	return ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === kind);
+}
+function hasExportModifier(node) {
+	return hasModifier(node, ts.SyntaxKind.ExportKeyword);
+}
+function hasPrivateOrProtectedModifier(node) {
+	return hasModifier(node, ts.SyntaxKind.PrivateKeyword) || hasModifier(node, ts.SyntaxKind.ProtectedKeyword);
+}
+function hasInternalJSDoc(node) {
+	return ts.getJSDocTags(node).some((tag) => tag.tagName.getText() === "internal");
+}
+function hasInternalApiJSDoc(node) {
+	if (hasInternalJSDoc(node)) return true;
+	if (ts.isVariableDeclaration(node)) return hasInternalJSDoc(node.parent.parent);
+	if (ts.isBindingElement(node) && ts.isVariableDeclaration(node.parent.parent)) return hasInternalJSDoc(node.parent.parent.parent);
+	return false;
+}
+function isInternalPath(fileName) {
+	return /\/src\/(?:.*\/)?internal\//.test(normalizePathName(fileName));
+}
+function collectBindingNames(name, out) {
+	if (ts.isIdentifier(name)) {
+		out.push(name);
+		return;
+	}
+	for (const element of name.elements) if (ts.isBindingElement(element)) collectBindingNames(element.name, out);
+}
+function getTopLevelDeclarationNameNodes(node) {
+	if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) && node.name !== void 0 && ts.isIdentifier(node.name)) return [node.name];
+	if (ts.isVariableStatement(node)) {
+		const names = [];
+		for (const declaration of node.declarationList.declarations) collectBindingNames(declaration.name, names);
+		return names;
+	}
+	return [];
+}
+function getDeclarationForName(node, name) {
+	if (!ts.isVariableStatement(node)) return node;
+	let result = node;
+	const visit = (current) => {
+		if (ts.isVariableDeclaration(current) || ts.isBindingElement(current)) {
+			const names = [];
+			collectBindingNames(current.name, names);
+			if (names.includes(name)) {
+				result = current;
+				return;
+			}
+		}
+		ts.forEachChild(current, visit);
+	};
+	visit(node.declarationList);
+	return result;
+}
+function isImportOrExportBinding(identifier) {
+	const parent = identifier.parent;
+	return ts.isImportSpecifier(parent) && (parent.name === identifier || parent.propertyName === identifier) || ts.isImportClause(parent) && parent.name === identifier || ts.isNamespaceImport(parent) && parent.name === identifier || ts.isExportSpecifier(parent) && (parent.name === identifier || parent.propertyName === identifier);
+}
+function isDeclarationName(identifier) {
+	const parent = identifier.parent;
+	return ts.isVariableDeclaration(parent) && parent.name === identifier || ts.isBindingElement(parent) && parent.name === identifier || ts.isParameter(parent) && parent.name === identifier || ts.isFunctionDeclaration(parent) && parent.name === identifier || ts.isClassDeclaration(parent) && parent.name === identifier || ts.isInterfaceDeclaration(parent) && parent.name === identifier || ts.isTypeAliasDeclaration(parent) && parent.name === identifier || ts.isEnumDeclaration(parent) && parent.name === identifier || ts.isEnumMember(parent) && parent.name === identifier || ts.isModuleDeclaration(parent) && parent.name === identifier;
+}
+function isNonReferenceName(identifier) {
+	const parent = identifier.parent;
+	return isImportOrExportBinding(identifier) || isDeclarationName(identifier) || ts.isPropertyAccessExpression(parent) && parent.name === identifier || ts.isPropertyAssignment(parent) && parent.name === identifier || ts.isPropertyDeclaration(parent) && parent.name === identifier || ts.isPropertySignature(parent) && parent.name === identifier || ts.isMethodDeclaration(parent) && parent.name === identifier || ts.isMethodSignature(parent) && parent.name === identifier || ts.isGetAccessorDeclaration(parent) && parent.name === identifier || ts.isSetAccessorDeclaration(parent) && parent.name === identifier;
+}
+function isInside(node, container) {
+	if (node.getSourceFile() !== container.getSourceFile()) return false;
+	return node.getStart() >= container.getStart() && node.getEnd() <= container.getEnd();
+}
+function getExports(fileInfos, fileName, exportName) {
+	if (fileName === void 0) return [];
+	return fileInfos.get(fileName)?.internalExports.get(exportName) ?? [];
+}
+function getReExportedInternals(fileInfos, fileInfo, workspacePackages, specifier) {
+	const exportDeclaration = specifier.parent.parent;
+	const importedName = (specifier.propertyName ?? specifier.name).text;
+	if (exportDeclaration.moduleSpecifier !== void 0 && ts.isStringLiteral(exportDeclaration.moduleSpecifier)) return getExports(fileInfos, resolveModule(exportDeclaration.moduleSpecifier.text, fileInfo.sourceFile.fileName, workspacePackages), importedName);
+	const imported = fileInfo.imports.get(importedName);
+	return [...fileInfo.internalExports.get(importedName) ?? [], ...getExports(fileInfos, imported?.fileName, imported?.importedName ?? "")];
+}
+function markUsed(exports, node) {
+	for (const internal of exports) if (!isInside(node, internal.declaration)) internal.used = true;
+}
+function addFileDiagnostic(diagnosticsByFile, diagnostic) {
+	const normalized = normalizePathName(diagnostic.fileName);
+	const diagnostics = diagnosticsByFile.get(normalized) ?? [];
+	diagnostics.push(diagnostic);
+	diagnosticsByFile.set(normalized, diagnostics);
+}
+function addInternalExport(fileInfo, internal) {
+	const exports = fileInfo.internalExports.get(internal.name) ?? [];
+	exports.push(internal);
+	fileInfo.internalExports.set(internal.name, exports);
+}
+function collectFileInfo(sourceFile, workspacePackages) {
+	const fileInfo = {
+		fileName: normalizePathName(sourceFile.fileName),
+		sourceFile,
+		imports: /* @__PURE__ */ new Map(),
+		namespaceImports: /* @__PURE__ */ new Map(),
+		internalExports: /* @__PURE__ */ new Map(),
+		publicDeclarations: []
+	};
+	const publicDeclarationSet = /* @__PURE__ */ new Set();
+	const isInternalFile = isInternalPath(sourceFile.fileName);
+	for (const statement of sourceFile.statements) {
+		if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+			const importedFile = resolveModule(statement.moduleSpecifier.text, sourceFile.fileName, workspacePackages);
+			const importClause = statement.importClause;
+			if (importedFile === void 0 || importClause === void 0) continue;
+			if (importClause.name !== void 0) fileInfo.imports.set(importClause.name.text, {
+				fileName: importedFile,
+				importedName: "default"
+			});
+			const namedBindings = importClause.namedBindings;
+			if (namedBindings === void 0) continue;
+			if (ts.isNamespaceImport(namedBindings)) fileInfo.namespaceImports.set(namedBindings.name.text, importedFile);
+			else for (const specifier of namedBindings.elements) {
+				const importedName = (specifier.propertyName ?? specifier.name).text;
+				fileInfo.imports.set(specifier.name.text, {
+					fileName: importedFile,
+					importedName
+				});
+			}
+			continue;
+		}
+		if (!isInternalFile && ts.isExportDeclaration(statement) && !hasInternalApiJSDoc(statement) && statement.exportClause !== void 0 && ts.isNamedExports(statement.exportClause)) {
+			fileInfo.publicDeclarations.push(statement);
+			continue;
+		}
+		if (!hasExportModifier(statement)) continue;
+		const names = getTopLevelDeclarationNameNodes(statement);
+		if (names.length === 0) continue;
+		const statementIsInternal = hasInternalApiJSDoc(statement);
+		for (const name of names) {
+			const declaration = getDeclarationForName(statement, name);
+			if (statementIsInternal || hasInternalApiJSDoc(declaration)) addInternalExport(fileInfo, {
+				fileName: sourceFile.fileName,
+				declaration,
+				name: name.text,
+				range: [name.getStart(sourceFile), name.getEnd()],
+				used: false
+			});
+			else if (!isInternalFile && !publicDeclarationSet.has(statement)) {
+				fileInfo.publicDeclarations.push(statement);
+				publicDeclarationSet.add(statement);
+			}
+		}
+	}
+	return fileInfo;
+}
+function markNamespaceReference(fileInfos, fileInfo, namespace, name) {
+	markUsed(getExports(fileInfos, fileInfo.namespaceImports.get(namespace.text), name.text), name);
+}
+function scanUsage(fileInfos, fileInfo, workspacePackages) {
+	const visit = (node) => {
+		if (ts.isExportSpecifier(node)) markUsed(getReExportedInternals(fileInfos, fileInfo, workspacePackages, node), node);
+		else if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && ts.isIdentifier(node.name)) markNamespaceReference(fileInfos, fileInfo, node.expression, node.name);
+		else if (ts.isQualifiedName(node) && ts.isIdentifier(node.left)) markNamespaceReference(fileInfos, fileInfo, node.left, node.right);
+		else if (ts.isIdentifier(node) && !isNonReferenceName(node)) {
+			markUsed(fileInfo.internalExports.get(node.text) ?? [], node);
+			const imported = fileInfo.imports.get(node.text);
+			markUsed(getExports(fileInfos, imported?.fileName, imported?.importedName ?? ""), node);
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(fileInfo.sourceFile);
+}
+function findInternalReferences(fileInfos, fileInfo, diagnostics, node) {
+	const visit = (current) => {
+		if (ts.isPropertyAccessExpression(current) && ts.isIdentifier(current.expression)) {
+			const importedFile = fileInfo.namespaceImports.get(current.expression.text);
+			for (const internal of getExports(fileInfos, importedFile, current.name.text)) diagnostics.push({
+				fileName: fileInfo.fileName,
+				range: [current.name.getStart(), current.name.getEnd()],
+				message: `Do not reference @internal export "${internal.name}" in a public exported type signature`
+			});
+		} else if (ts.isQualifiedName(current) && ts.isIdentifier(current.left)) {
+			const importedFile = fileInfo.namespaceImports.get(current.left.text);
+			for (const internal of getExports(fileInfos, importedFile, current.right.text)) diagnostics.push({
+				fileName: fileInfo.fileName,
+				range: [current.right.getStart(), current.right.getEnd()],
+				message: `Do not reference @internal export "${internal.name}" in a public exported type signature`
+			});
+		} else if (ts.isIdentifier(current) && !isNonReferenceName(current)) {
+			const localExports = fileInfo.internalExports.get(current.text) ?? [];
+			const imported = fileInfo.imports.get(current.text);
+			const importedExports = getExports(fileInfos, imported?.fileName, imported?.importedName ?? "");
+			for (const internal of [...localExports, ...importedExports]) diagnostics.push({
+				fileName: fileInfo.fileName,
+				range: [current.getStart(), current.getEnd()],
+				message: `Do not reference @internal export "${internal.name}" in a public exported type signature`
+			});
+		}
+		ts.forEachChild(current, visit);
+	};
+	visit(node);
+}
+function scanTypeParameters(fileInfos, fileInfo, diagnostics, typeParameters) {
+	if (typeParameters === void 0) return;
+	for (const typeParameter of typeParameters) {
+		if (typeParameter.constraint !== void 0) findInternalReferences(fileInfos, fileInfo, diagnostics, typeParameter.constraint);
+		if (typeParameter.default !== void 0) findInternalReferences(fileInfos, fileInfo, diagnostics, typeParameter.default);
+	}
+}
+function scanParameterTypes(fileInfos, fileInfo, diagnostics, parameters) {
+	for (const parameter of parameters) if (parameter.type !== void 0) findInternalReferences(fileInfos, fileInfo, diagnostics, parameter.type);
+}
+function scanFunctionLikeSignature(fileInfos, fileInfo, diagnostics, node) {
+	scanTypeParameters(fileInfos, fileInfo, diagnostics, node.typeParameters);
+	scanParameterTypes(fileInfos, fileInfo, diagnostics, node.parameters);
+	if (node.type !== void 0) findInternalReferences(fileInfos, fileInfo, diagnostics, node.type);
+}
+function scanClassMemberSignature(fileInfos, fileInfo, diagnostics, member) {
+	if (hasInternalJSDoc(member)) return;
+	if (hasPrivateOrProtectedModifier(member)) return;
+	if (ts.isMethodDeclaration(member) || ts.isConstructorDeclaration(member) || ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) scanFunctionLikeSignature(fileInfos, fileInfo, diagnostics, member);
+	else if (ts.isPropertyDeclaration(member) && member.type !== void 0) findInternalReferences(fileInfos, fileInfo, diagnostics, member.type);
+}
+function scanInterfaceMemberSignature(fileInfos, fileInfo, diagnostics, member) {
+	if (hasInternalJSDoc(member)) return;
+	if (ts.isMethodSignature(member) || ts.isCallSignatureDeclaration(member) || ts.isConstructSignatureDeclaration(member)) scanFunctionLikeSignature(fileInfos, fileInfo, diagnostics, member);
+	else if (ts.isPropertySignature(member) && member.type !== void 0) findInternalReferences(fileInfos, fileInfo, diagnostics, member.type);
+	else if (ts.isIndexSignatureDeclaration(member)) scanFunctionLikeSignature(fileInfos, fileInfo, diagnostics, member);
+}
+function scanPublicSignature(fileInfos, fileInfo, diagnostics, node, workspacePackages) {
+	if (ts.isFunctionDeclaration(node)) scanFunctionLikeSignature(fileInfos, fileInfo, diagnostics, node);
+	else if (ts.isVariableStatement(node)) {
+		for (const declaration of node.declarationList.declarations) if (declaration.type !== void 0) findInternalReferences(fileInfos, fileInfo, diagnostics, declaration.type);
+	} else if (ts.isTypeAliasDeclaration(node)) {
+		scanTypeParameters(fileInfos, fileInfo, diagnostics, node.typeParameters);
+		findInternalReferences(fileInfos, fileInfo, diagnostics, node.type);
+	} else if (ts.isInterfaceDeclaration(node)) {
+		scanTypeParameters(fileInfos, fileInfo, diagnostics, node.typeParameters);
+		for (const heritage of node.heritageClauses ?? []) for (const type of heritage.types) findInternalReferences(fileInfos, fileInfo, diagnostics, type);
+		for (const member of node.members) scanInterfaceMemberSignature(fileInfos, fileInfo, diagnostics, member);
+	} else if (ts.isClassDeclaration(node)) {
+		scanTypeParameters(fileInfos, fileInfo, diagnostics, node.typeParameters);
+		for (const heritage of node.heritageClauses ?? []) for (const type of heritage.types) findInternalReferences(fileInfos, fileInfo, diagnostics, type);
+		for (const member of node.members) scanClassMemberSignature(fileInfos, fileInfo, diagnostics, member);
+	} else if (ts.isExportDeclaration(node) && node.exportClause !== void 0 && ts.isNamedExports(node.exportClause)) for (const specifier of node.exportClause.elements) for (const internal of getReExportedInternals(fileInfos, fileInfo, workspacePackages, specifier)) {
+		const name = specifier.propertyName ?? specifier.name;
+		diagnostics.push({
+			fileName: fileInfo.fileName,
+			range: [name.getStart(), name.getEnd()],
+			message: `Do not re-export @internal export "${internal.name}" from a public module`
+		});
+	}
+}
+function analyze(cwd) {
+	const normalizedCwd = normalizePathName(cwd);
+	const cached = cache.get(normalizedCwd);
+	if (cached !== void 0) return cached;
+	const workspacePackages = findWorkspacePackages(cwd);
+	const fileInfos = /* @__PURE__ */ new Map();
+	for (const fileName of findSourceFiles(cwd)) {
+		const fileInfo = collectFileInfo(ts.createSourceFile(fileName, fs.readFileSync(fileName, "utf8"), ts.ScriptTarget.Latest, true), workspacePackages);
+		fileInfos.set(fileInfo.fileName, fileInfo);
+	}
+	for (const fileInfo of fileInfos.values()) scanUsage(fileInfos, fileInfo, workspacePackages);
+	const diagnosticsByFile = /* @__PURE__ */ new Map();
+	for (const fileInfo of fileInfos.values()) {
+		const diagnostics = [];
+		for (const declaration of fileInfo.publicDeclarations) scanPublicSignature(fileInfos, fileInfo, diagnostics, declaration, workspacePackages);
+		for (const diagnostic of diagnostics) addFileDiagnostic(diagnosticsByFile, diagnostic);
+		for (const exportsForName of fileInfo.internalExports.values()) for (const internal of exportsForName) if (!internal.used) addFileDiagnostic(diagnosticsByFile, {
+			fileName: internal.fileName,
+			range: internal.range,
+			message: `@internal export "${internal.name}" is not used by production sources`
+		});
+	}
+	for (const diagnostics of diagnosticsByFile.values()) diagnostics.sort((self, that) => self.range[0] - that.range[0]);
+	const analysis = { diagnosticsByFile };
+	cache.set(normalizedCwd, analysis);
+	return analysis;
+}
+//#endregion
+//#region src/index.ts
+const plugin = {
+	meta: { name: "rules" },
+	rules: {
+		"no-bigint-literals": rule$4,
+		"no-import-from-barrel-package": rule$3,
+		"no-js-extension-imports": rule$2,
+		"no-opaque-instance-fields": rule$1,
+		"no-unused-internal": {
+			meta: {
+				type: "problem",
+				docs: { description: "Disallow unused @internal exports, public re-exports, and references from public type signatures" }
+			},
+			create(context) {
+				const diagnostics = analyze(getCwd(context)).diagnosticsByFile.get(normalizePathName(context.filename)) ?? [];
+				return { Program() {
+					for (const diagnostic of diagnostics) context.report({
+						node: rangeNode(diagnostic.range),
+						message: diagnostic.message
+					});
+				} };
+			}
+		},
+		"consistent-import-extension": rule$32,
+		"require-import-extension": rule$6,
+		"force-array-empty": rule$31,
+		"force-iterable-empty": rule$30,
+		"force-predicate": rule$29,
+		"force-string-empty": rule$28,
+		"force-ts-extension": rule$33,
+		"no-effect-import-as": rule$27,
+		"no-effect-runtime-run": rule$26,
+		"no-effect-subpath-import": rule$25,
+		"no-error-cause-option": rule$24,
+		"no-error-property-access": rule$23,
+		"no-eslint-disable-comments": rule$22,
+		"no-fetch": rule$21,
+		"no-instanceof-error": rule$20,
+		"no-js-date": rule$19,
+		"no-jsx-script-tag": rule$18,
+		"no-let": rule$17,
+		"no-node-imports": rule$16,
+		"no-option-tag-comparison": rule$15,
+		"no-raw-hono-create-middleware": rule$14,
+		"no-redundant-alias": rule$13,
+		"no-string-style": rule$12,
+		"no-sync-decode": rule$11,
+		"no-type-predicate": rule$10,
+		"prefer-is-nullish": rule$9,
+		"prefer-non-unknown-decode": rule$8,
+		"require-disable-reason": rule$7,
+		"require-top-level-decoder": rule$5
+	}
+};
+//#endregion
+export { compatibilityRuleNames, plugin as default, effectRuleNames, typescriptRuleNames };