@adamaho/nopeus-oxlint-plugin 0.7.0

package/dist/index.mjs

@@ -0,0 +1,2693 @@
+import { defineRule, eslintCompatPlugin } from "@oxlint/plugins";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { ResolverFactory } from "oxc-resolver";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+//#region src/effect/rules/effect-call.ts
+/** Describe the barrel and direct module imports for one Effect module. */
+function moduleBindings(moduleName, barrelName) {
+	return {
+		barrelName,
+		moduleName
+	};
+}
+function importedName$2(specifier) {
+	return specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+}
+function resolveVariable$4(sourceCode, identifier) {
+	let scope = sourceCode.getScope(identifier);
+	while (scope !== null) {
+		const variable = scope.set.get(identifier.name);
+		if (variable !== void 0) return variable;
+		scope = scope.upper;
+	}
+	return null;
+}
+/** Test whether an identifier resolves to one global binding. */
+function isGlobalIdentifier(sourceCode, identifier, name) {
+	if (identifier.name !== name) return false;
+	if (sourceCode.isGlobalReference(identifier)) return true;
+	const variable = resolveVariable$4(sourceCode, identifier);
+	return variable === null || variable.defs.length === 0;
+}
+function isNamedModuleImport(sourceCode, identifier, bindings, name) {
+	return resolveVariable$4(sourceCode, identifier)?.defs.some((definition) => definition.type === "ImportBinding" && definition.parent?.type === "ImportDeclaration" && definition.parent.source.value === bindings.moduleName && definition.node.type === "ImportSpecifier" && importedName$2(definition.node) === name) === true;
+}
+function isModuleNamespace(sourceCode, identifier, bindings) {
+	return resolveVariable$4(sourceCode, identifier)?.defs.some((definition) => {
+		if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") return false;
+		if (definition.parent.source.value === bindings.moduleName) return definition.node.type === "ImportNamespaceSpecifier";
+		return definition.parent.source.value === "effect" && definition.node.type === "ImportSpecifier" && importedName$2(definition.node) === bindings.barrelName;
+	}) === true;
+}
+function isBarrelModule(sourceCode, expression, bindings) {
+	if (expression.object.type !== "Identifier" || expression.computed || expression.property.type !== "Identifier" || expression.property.name !== bindings.barrelName) return false;
+	return resolveVariable$4(sourceCode, expression.object)?.defs.some((definition) => definition.type === "ImportBinding" && definition.parent?.type === "ImportDeclaration" && definition.parent.source.value === "effect" && definition.node.type === "ImportNamespaceSpecifier") === true;
+}
+/** Test whether a type name resolves to an imported Effect module type. */
+function isModuleType(sourceCode, typeName, bindings, name) {
+	if (typeName.type === "Identifier") return isNamedModuleImport(sourceCode, typeName, bindings, name);
+	return typeName.type === "TSQualifiedName" && typeName.left.type === "Identifier" && isModuleNamespace(sourceCode, typeName.left, bindings) && typeName.right.name === name;
+}
+/** Test whether a callee resolves to an imported Effect module function. */
+function isModuleCall(sourceCode, callee, bindings, name) {
+	if (callee.type === "Identifier") return isNamedModuleImport(sourceCode, callee, bindings, name);
+	return callee.type === "MemberExpression" && !callee.computed && (callee.object.type === "Identifier" && isModuleNamespace(sourceCode, callee.object, bindings) || callee.object.type === "MemberExpression" && isBarrelModule(sourceCode, callee.object, bindings)) && callee.property.type === "Identifier" && callee.property.name === name;
+}
+//#endregion
+//#region src/effect/rules/no-effect-runners-in-library.ts
+const runners = [
+	"runCallback",
+	"runCallbackWith",
+	"runFork",
+	"runForkWith",
+	"runPromise",
+	"runPromiseExit",
+	"runPromiseExitWith",
+	"runPromiseWith",
+	"runSync",
+	"runSyncExit",
+	"runSyncExitWith",
+	"runSyncWith"
+];
+function normalizedPath(path) {
+	return path.replaceAll("\\", "/");
+}
+function repositoryRelativePath(filename, cwd) {
+	const normalizedFilename = normalizedPath(filename);
+	const normalizedCwd = normalizedPath(cwd).replace(/\/$/u, "");
+	return normalizedFilename.startsWith(normalizedCwd + "/") ? normalizedFilename.slice(normalizedCwd.length + 1) : normalizedFilename;
+}
+function isAllowed(filename, cwd, allowFiles) {
+	const relativeFilename = repositoryRelativePath(filename, cwd);
+	return allowFiles.some((path) => relativeFilename === normalizedPath(path).replace(/^\.\//u, ""));
+}
+/** Keep Effect runtime execution in explicitly configured entrypoints. */
+const noEffectRunnersInLibraryRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow Effect runtime runners outside configured entrypoint files." },
+		schema: [{
+			type: "object",
+			properties: { allowFiles: {
+				type: "array",
+				items: {
+					type: "string",
+					minLength: 1
+				},
+				uniqueItems: true
+			} },
+			required: ["allowFiles"],
+			additionalProperties: false
+		}],
+		defaultOptions: [{ allowFiles: [] }],
+		messages: { libraryRunner: "Run Effects only in a configured application entrypoint; return or compose this Effect instead." }
+	},
+	createOnce(context) {
+		const effect = moduleBindings("effect/Effect", "Effect");
+		return { CallExpression(node) {
+			const option = context.options?.[0];
+			const allowFiles = typeof option === "object" && option !== null && !Array.isArray(option) && Array.isArray(option.allowFiles) ? option.allowFiles.filter((value) => typeof value === "string") : [];
+			if (isAllowed(context.filename, context.cwd, allowFiles)) return;
+			if (runners.some((name) => isModuleCall(context.sourceCode, node.callee, effect, name))) context.report({
+				node: node.callee,
+				messageId: "libraryRunner"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/effect/rules/no-fallible-effect-promise.ts
+/** Keep rejected promises in Effect's typed error channel. */
+const noFallibleEffectPromiseRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require Effect.tryPromise for promise-producing operations." },
+		messages: { useTryPromise: "Use Effect.tryPromise and map rejection into a domain error; Effect.promise turns rejection into a defect." }
+	},
+	createOnce(context) {
+		const effect = moduleBindings("effect/Effect", "Effect");
+		return { CallExpression(node) {
+			if (isModuleCall(context.sourceCode, node.callee, effect, "promise")) context.report({
+				node: node.callee,
+				messageId: "useTryPromise"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/effect/rules/no-inline-live-layer.ts
+const liveConstructors = [
+	"effect",
+	"effectContext",
+	"effectDiscard",
+	"sync",
+	"syncContext",
+	"unwrap"
+];
+function unwrapExpression$1(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") current = current.expression;
+	return current;
+}
+function isInlineLayer(sourceCode, argument, layer) {
+	if (argument === void 0 || argument.type === "SpreadElement") return false;
+	const current = unwrapExpression$1(argument);
+	if (current.type !== "CallExpression") return false;
+	if (liveConstructors.some((name) => isModuleCall(sourceCode, current.callee, layer, name))) return true;
+	if (current.arguments.some((child) => isInlineLayer(sourceCode, child, layer))) return true;
+	const callee = current.callee;
+	return callee.type === "MemberExpression" && callee.object.type !== "Super" && isInlineLayer(sourceCode, callee.object, layer);
+}
+/** Keep live Layer construction at stable module composition boundaries. */
+const noInlineLiveLayerRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow constructing live Layers inside Effect.provide calls." },
+		messages: { extractLayer: "Extract this live Layer to a module-level binding and provide it at the application boundary." }
+	},
+	createOnce(context) {
+		const effect = moduleBindings("effect/Effect", "Effect");
+		const layer = moduleBindings("effect/Layer", "Layer");
+		return { CallExpression(node) {
+			if (!isModuleCall(context.sourceCode, node.callee, effect, "provide")) return;
+			if (node.arguments.some((argument) => isInlineLayer(context.sourceCode, argument, layer))) context.report({
+				node,
+				messageId: "extractLayer"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/effect/rules/no-module-level-mutable-state.ts
+const collections = /* @__PURE__ */ new Set([
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet"
+]);
+function isModuleDeclaration(node) {
+	return node.parent.type === "Program" || node.parent.type === "ExportNamedDeclaration" && node.parent.parent.type === "Program";
+}
+function hasReadonlyContract(declarator, collection) {
+	const annotation = declarator.id.typeAnnotation?.typeAnnotation;
+	return (collection === "Map" || collection === "Set") && annotation?.type === "TSTypeReference" && annotation.typeName.type === "Identifier" && annotation.typeName.name === "Readonly" + collection;
+}
+function globalCollection(sourceCode, node) {
+	const callee = node.callee;
+	if (callee.type === "Identifier") return collections.has(callee.name) && isGlobalIdentifier(sourceCode, callee, callee.name) ? callee.name : null;
+	if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier" || !isGlobalIdentifier(sourceCode, callee.object, "globalThis")) return null;
+	const property = callee.property;
+	const name = !callee.computed && property.type === "Identifier" ? property.name : property.type === "Literal" && typeof property.value === "string" ? property.value : null;
+	return name !== null && collections.has(name) ? name : null;
+}
+function unwrap$2(node) {
+	let current = node;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSAsExpression" || current.type === "TSTypeAssertion") current = current.expression;
+	return current;
+}
+/** Allocate service state during construction, allowing explicitly readonly lookup collections. */
+const noModuleLevelMutableStateRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow module-level mutable bindings and writable collection construction." },
+		messages: {
+			mutableBinding: "Allocate mutable state inside make so its lifetime belongs to the constructed service.",
+			mutableCollection: "Allocate this collection inside make. For an immutable lookup table, expose a ReadonlyMap or ReadonlySet contract."
+		}
+	},
+	createOnce(context) {
+		return { VariableDeclaration(node) {
+			if (!isModuleDeclaration(node) || node.declare) return;
+			if (node.kind === "let" || node.kind === "var") {
+				context.report({
+					node,
+					messageId: "mutableBinding"
+				});
+				return;
+			}
+			for (const declarator of node.declarations) {
+				if (declarator.init === null) continue;
+				const value = unwrap$2(declarator.init);
+				if (value.type !== "NewExpression") continue;
+				const collection = globalCollection(context.sourceCode, value);
+				if (collection === null || hasReadonlyContract(declarator, collection)) continue;
+				context.report({
+					node: value,
+					messageId: "mutableCollection"
+				});
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/effect/rules/no-unscoped-fork.ts
+/** Keep background fibers attached to an explicit lifetime. */
+const noUnscopedForkRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require forkScoped or forkIn for background Effect fibers." },
+		messages: { scopedFork: "Use Effect.forkScoped or Effect.forkIn so the background fiber has an explicit lifetime." }
+	},
+	createOnce(context) {
+		const effect = moduleBindings("effect/Effect", "Effect");
+		return { CallExpression(node) {
+			if (isModuleCall(context.sourceCode, node.callee, effect, "forkDetach")) context.report({
+				node: node.callee,
+				messageId: "scopedFork"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/effect/rules/no-untyped-effect-errors.ts
+const builtInErrors = /* @__PURE__ */ new Set([
+	"AggregateError",
+	"Error",
+	"EvalError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"TypeError",
+	"URIError"
+]);
+function unwrap$1(node) {
+	if (node === void 0 || node.type === "SpreadElement") return void 0;
+	let current = node;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") current = current.expression;
+	return current;
+}
+function memberName(node) {
+	if (!node.computed && node.property.type === "Identifier") return node.property.name;
+	return node.computed && node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : null;
+}
+function isGlobalBuiltInError(sourceCode, callee) {
+	if (callee.type === "Identifier") return builtInErrors.has(callee.name) && isGlobalIdentifier(sourceCode, callee, callee.name);
+	if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier" || !isGlobalIdentifier(sourceCode, callee.object, "globalThis")) return false;
+	const name = memberName(callee);
+	return name !== null && builtInErrors.has(name);
+}
+function isUntypedError(sourceCode, node) {
+	const argument = unwrap$1(node);
+	if (argument === void 0) return false;
+	if (argument.type === "Literal" || argument.type === "TemplateLiteral" || argument.type === "ObjectExpression" || argument.type === "Identifier" && isGlobalIdentifier(sourceCode, argument, "undefined") || argument.type === "UnaryExpression" && argument.operator === "void") return true;
+	if (argument.type !== "NewExpression" && argument.type !== "CallExpression") return false;
+	const callee = argument.callee;
+	return callee.type !== "Super" && callee.type !== "V8IntrinsicExpression" && isGlobalBuiltInError(sourceCode, callee);
+}
+/** Keep expected failures in explicit domain error types. */
+const noUntypedEffectErrorsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Reject untyped values and built-in errors in Effect.fail." },
+		messages: { domainError: "Fail with a tagged domain error (for example Schema.TaggedError), not a primitive or built-in Error." }
+	},
+	createOnce(context) {
+		const effect = moduleBindings("effect/Effect", "Effect");
+		return { CallExpression(node) {
+			if (isModuleCall(context.sourceCode, node.callee, effect, "fail") && isUntypedError(context.sourceCode, node.arguments[0])) context.report({
+				node,
+				messageId: "domainError"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/effect/rules/prefer-effect-platform-services.ts
+const moduleReplacements = /* @__PURE__ */ new Map([
+	["fs", {
+		effect: "FileSystem.FileSystem",
+		provider: "NodeFileSystem.layer (or NodeServices.layer)"
+	}],
+	["fs/promises", {
+		effect: "FileSystem.FileSystem",
+		provider: "NodeFileSystem.layer (or NodeServices.layer)"
+	}],
+	["path", {
+		effect: "Path.Path",
+		provider: "NodePath.layer (or NodeServices.layer)"
+	}],
+	["child_process", {
+		effect: "ChildProcess commands and ChildProcessSpawner.ChildProcessSpawner",
+		provider: "NodeChildProcessSpawner.layer (or NodeServices.layer)"
+	}]
+]);
+const cryptoReplacements = /* @__PURE__ */ new Map([
+	["randomUUID", {
+		effect: "Crypto.Crypto.randomUUIDv4",
+		provider: "NodeCrypto.layer (or NodeServices.layer)"
+	}],
+	["randomUUIDv7", {
+		effect: "Crypto.Crypto.randomUUIDv7",
+		provider: "NodeCrypto.layer (or NodeServices.layer)"
+	}],
+	["randomBytes", {
+		effect: "Crypto.Crypto.randomBytes",
+		provider: "NodeCrypto.layer (or NodeServices.layer)"
+	}],
+	["randomInt", {
+		effect: "Crypto.Crypto.randomIntBetween",
+		provider: "NodeCrypto.layer (or NodeServices.layer)"
+	}],
+	["createHash", {
+		effect: "Crypto.Crypto.digest",
+		provider: "NodeCrypto.layer (or NodeServices.layer)"
+	}],
+	["hash", {
+		effect: "Crypto.Crypto.digest",
+		provider: "NodeCrypto.layer (or NodeServices.layer)"
+	}],
+	["subtle.digest", {
+		effect: "Crypto.Crypto.digest",
+		provider: "NodeCrypto.layer (or NodeServices.layer)"
+	}],
+	["webcrypto.subtle.digest", {
+		effect: "Crypto.Crypto.digest",
+		provider: "NodeCrypto.layer (or NodeServices.layer)"
+	}]
+]);
+const urlReplacements = /* @__PURE__ */ new Map([["fileURLToPath", {
+	effect: "Path.Path.fromFileUrl",
+	provider: "NodePath.layer (or NodeServices.layer)"
+}], ["pathToFileURL", {
+	effect: "Path.Path.toFileUrl",
+	provider: "NodePath.layer (or NodeServices.layer)"
+}]]);
+const consoleReplacements = new Map([
+	"assert",
+	"clear",
+	"count",
+	"countReset",
+	"debug",
+	"dir",
+	"dirxml",
+	"error",
+	"group",
+	"groupCollapsed",
+	"groupEnd",
+	"info",
+	"log",
+	"table",
+	"time",
+	"timeEnd",
+	"timeLog",
+	"trace",
+	"warn"
+].map((method) => [method, {
+	effect: `Console.Console.${method}`,
+	provider: "the runtime-provided Console.Console service"
+}]));
+const processReplacements = /* @__PURE__ */ new Map([
+	["argv", {
+		effect: "Stdio.Stdio.args",
+		provider: "NodeStdio.layer (or NodeServices.layer)"
+	}],
+	["stdin", {
+		effect: "Stdio.Stdio.stdin",
+		provider: "NodeStdio.layer (or NodeServices.layer)"
+	}],
+	["stdout", {
+		effect: "Stdio.Stdio.stdout",
+		provider: "NodeStdio.layer (or NodeServices.layer)"
+	}],
+	["stderr", {
+		effect: "Stdio.Stdio.stderr",
+		provider: "NodeStdio.layer (or NodeServices.layer)"
+	}],
+	["hrtime", {
+		effect: "Clock.Clock.monotonicTimeNanos",
+		provider: "the runtime-provided Clock.Clock service"
+	}]
+]);
+const timerReplacements = /* @__PURE__ */ new Map([["setTimeout", {
+	effect: "Effect.sleep",
+	provider: "the runtime-provided Clock.Clock service"
+}], ["setInterval", {
+	effect: "Effect.repeat or Stream.fromEffectSchedule",
+	provider: "the runtime-provided Clock.Clock service"
+}]]);
+const httpReplacements = /* @__PURE__ */ new Map([
+	["get", {
+		effect: "HttpClient.get through HttpClient.HttpClient",
+		provider: "NodeHttpClient.layerUndici or NodeHttpClient.layerNodeHttp"
+	}],
+	["request", {
+		effect: "HttpClient.execute through HttpClient.HttpClient",
+		provider: "NodeHttpClient.layerUndici or NodeHttpClient.layerNodeHttp"
+	}],
+	["createServer", {
+		effect: "HttpServer.HttpServer for server behavior",
+		provider: "NodeHttpServer.layer or NodeHttpServer.layerConfig"
+	}]
+]);
+const symbolReplacements = /* @__PURE__ */ new Map([
+	["console", consoleReplacements],
+	["crypto", cryptoReplacements],
+	["http", httpReplacements],
+	["https", httpReplacements],
+	["net", /* @__PURE__ */ new Map([
+		["connect", {
+			effect: "Socket.Socket",
+			provider: "NodeSocket.makeNet or NodeSocket.layerNet"
+		}],
+		["createConnection", {
+			effect: "Socket.Socket",
+			provider: "NodeSocket.makeNet or NodeSocket.layerNet"
+		}],
+		["createServer", {
+			effect: "SocketServer.SocketServer",
+			provider: "NodeSocketServer.layer"
+		}]
+	])],
+	["perf_hooks", /* @__PURE__ */ new Map([["performance.now", {
+		effect: "Clock.Clock.monotonicTimeNanos",
+		provider: "the runtime-provided Clock.Clock service"
+	}]])],
+	["process", processReplacements],
+	["timers", timerReplacements],
+	["timers/promises", timerReplacements],
+	["url", urlReplacements]
+]);
+function builtinName(source) {
+	return source.startsWith("node:") ? source.slice(5) : source;
+}
+function importedName$1(specifier) {
+	return specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+}
+function isValueSpecifier(declaration, specifier) {
+	return declaration.importKind !== "type" && (specifier.type !== "ImportSpecifier" || specifier.importKind !== "type");
+}
+function hasValueImport(node) {
+	return node.importKind !== "type" && (node.specifiers.length === 0 || node.specifiers.some((specifier) => isValueSpecifier(node, specifier)));
+}
+function resolveVariable$3(sourceCode, identifier) {
+	if (identifier.type !== "Identifier") return null;
+	let scope = sourceCode.getScope(identifier);
+	while (scope !== null) {
+		const variable = scope.set.get(identifier.name);
+		if (variable !== void 0) return variable;
+		scope = scope.upper;
+	}
+	return null;
+}
+function importBinding(sourceCode, identifier) {
+	const variable = resolveVariable$3(sourceCode, identifier);
+	for (const definition of variable?.defs ?? []) {
+		if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") continue;
+		const specifier = definition.node;
+		if (specifier.type !== "ImportSpecifier" && specifier.type !== "ImportDefaultSpecifier" && specifier.type !== "ImportNamespaceSpecifier") continue;
+		if (definition.parent.importKind === "type" || !isValueSpecifier(definition.parent, specifier)) continue;
+		if (specifier.type === "ImportNamespaceSpecifier") return {
+			imported: null,
+			source: definition.parent.source.value
+		};
+		if (specifier.type === "ImportDefaultSpecifier") return {
+			imported: "default",
+			source: definition.parent.source.value
+		};
+		return {
+			imported: importedName$1(specifier),
+			source: definition.parent.source.value
+		};
+	}
+	return null;
+}
+function propertyName$2(node) {
+	if (!node.computed && node.property.type === "Identifier") return node.property.name;
+	return node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : null;
+}
+function importedMember(sourceCode, node) {
+	const path = [];
+	let current = node;
+	while (current.type === "MemberExpression") {
+		const name = propertyName$2(current);
+		if (name === null) return null;
+		path.unshift(name);
+		current = current.object;
+	}
+	if (current.type !== "Identifier") return null;
+	const binding = importBinding(sourceCode, current);
+	if (binding === null) return null;
+	if (binding.imported !== null && binding.imported !== "default") path.unshift(binding.imported);
+	return {
+		source: binding.source,
+		symbol: path.join(".")
+	};
+}
+function isNodeHttpServerLayerCall(sourceCode, node) {
+	const callee = node.callee;
+	if (callee.type === "Identifier") {
+		const binding = importBinding(sourceCode, callee);
+		return binding !== null && binding.source === "@effect/platform-node/NodeHttpServer" && (binding.imported === "layer" || binding.imported === "layerConfig");
+	}
+	if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier") return false;
+	const name = propertyName$2(callee);
+	if (name !== "layer" && name !== "layerConfig") return false;
+	const binding = importBinding(sourceCode, callee.object);
+	return binding !== null && (binding.source === "@effect/platform-node" && binding.imported === "NodeHttpServer" || binding.source === "@effect/platform-node/NodeHttpServer" && (binding.imported === null || binding.imported === "default"));
+}
+function isNodeHttpServerAdapterArgument(sourceCode, node) {
+	let current = node;
+	while (current.parent !== null && current.parent.type !== "Program") {
+		const parent = current.parent;
+		if (parent.type === "CallExpression" && parent.arguments[0] === current && isNodeHttpServerLayerCall(sourceCode, parent)) return true;
+		current = parent;
+	}
+	return false;
+}
+function isHttpCreateServer(source, symbol) {
+	const module = builtinName(source);
+	return (module === "http" || module === "https") && symbol === "createServer";
+}
+/** Keep platform I/O replaceable through Effect services. */
+const preferEffectPlatformServicesRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Prefer Effect platform services over direct Node platform APIs." },
+		messages: { platformService: "Use {{effect}} (provided by {{provider}}) instead of {{api}} so platform behavior remains typed and replaceable." }
+	},
+	createOnce(context) {
+		const report = (node, source, symbol, replacement) => {
+			const api = symbol === null ? `the ${source} module` : `${source}.${symbol}`;
+			context.report({
+				node,
+				messageId: "platformService",
+				data: {
+					api,
+					effect: replacement.effect,
+					provider: replacement.provider
+				}
+			});
+		};
+		return {
+			ImportDeclaration(node) {
+				const module = builtinName(node.source.value);
+				const moduleReplacement = moduleReplacements.get(module);
+				if (moduleReplacement !== void 0 && hasValueImport(node)) {
+					report(node.source, node.source.value, null, moduleReplacement);
+					return;
+				}
+				const replacements = symbolReplacements.get(module);
+				if (replacements === void 0 || node.importKind === "type") return;
+				for (const specifier of node.specifiers) {
+					if (specifier.type !== "ImportSpecifier" || !isValueSpecifier(node, specifier)) continue;
+					const symbol = importedName$1(specifier);
+					const replacement = replacements.get(symbol);
+					if (replacement === void 0 || symbol === "default" || isHttpCreateServer(node.source.value, symbol)) continue;
+					report(specifier, node.source.value, symbol, replacement);
+				}
+			},
+			MemberExpression(node) {
+				const member = importedMember(context.sourceCode, node);
+				if (member === null) return;
+				const replacement = symbolReplacements.get(builtinName(member.source))?.get(member.symbol);
+				if (replacement === void 0 || isHttpCreateServer(member.source, member.symbol) && isNodeHttpServerAdapterArgument(context.sourceCode, node)) return;
+				report(node, member.source, member.symbol, replacement);
+			},
+			Identifier(node) {
+				if (node.parent.type === "ImportSpecifier" || node.parent.type === "ImportDefaultSpecifier" || node.parent.type === "ImportNamespaceSpecifier") return;
+				const binding = importBinding(context.sourceCode, node);
+				if (binding === null || binding.imported === null || !isHttpCreateServer(binding.source, binding.imported) || isNodeHttpServerAdapterArgument(context.sourceCode, node)) return;
+				const replacement = symbolReplacements.get(builtinName(binding.source))?.get(binding.imported);
+				if (replacement !== void 0) report(node, binding.source, binding.imported, replacement);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/effect/rules/prefer-effect-void.ts
+function isUndefined(sourceCode, node) {
+	if (node === void 0 || node.type === "SpreadElement") return false;
+	if (node.type === "Identifier") return isGlobalIdentifier(sourceCode, node, "undefined");
+	return node.type === "UnaryExpression" && node.operator === "void" && node.argument.type === "Literal" && node.argument.value === 0;
+}
+/** Use the canonical Effect value for successful void results. */
+const preferEffectVoidRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer Effect.void over Effect.succeed(undefined)." },
+		messages: { preferVoid: "Use Effect.void for an Effect that succeeds with undefined." }
+	},
+	createOnce(context) {
+		const effect = moduleBindings("effect/Effect", "Effect");
+		return { CallExpression(node) {
+			if (isModuleCall(context.sourceCode, node.callee, effect, "succeed") && isUndefined(context.sourceCode, node.arguments[0])) context.report({
+				node,
+				messageId: "preferVoid"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/effect/rules/require-effect-fn-name.ts
+function staticName(argument) {
+	if (argument === void 0 || argument.type === "SpreadElement") return null;
+	while (argument.type === "ParenthesizedExpression" || argument.type === "TSSatisfiesExpression" || argument.type === "TSAsExpression" || argument.type === "TSTypeAssertion") argument = argument.expression;
+	if (argument.type === "Literal") return typeof argument.value === "string" ? argument.value : null;
+	if (argument.type === "TemplateLiteral" && argument.expressions.length === 0) return argument.quasis[0]?.value.cooked ?? argument.quasis[0]?.value.raw ?? "";
+	return null;
+}
+function propertyName$1(key) {
+	if (key.type === "Identifier" || key.type === "PrivateIdentifier") return key.name;
+	return key.type === "Literal" && typeof key.value === "string" ? key.value : null;
+}
+function ownerName(node) {
+	let current = node;
+	while (current.parent.type === "CallExpression" && current.parent.callee === current) current = current.parent;
+	const owner = current.parent;
+	if (owner.type === "VariableDeclarator" && owner.id.type === "Identifier") return owner.id.name;
+	if ((owner.type === "Property" || owner.type === "PropertyDefinition" || owner.type === "AccessorProperty") && owner.value === current) return propertyName$1(owner.key);
+	return null;
+}
+function nameMatchesOwner(name, owner) {
+	return name === owner || name.endsWith("." + owner) || name.endsWith("/" + owner);
+}
+/** Require traced Effect functions to carry a stable operation name. */
+const requireEffectFnNameRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require every Effect.fn call to provide a static operation name." },
+		messages: {
+			missingName: "Give this Effect.fn a static operation name so traces and diagnostics identify the workflow.",
+			mismatchedName: "Effect.fn name \"{{name}}\" must match its owning symbol \"{{owner}}\" or end with \".{{owner}}\" or \"/{{owner}}\"."
+		}
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const callee = node.callee;
+			if (!isModuleCall(context.sourceCode, callee, moduleBindings("effect/Effect", "Effect"), "fn")) return;
+			const name = staticName(node.arguments[0]);
+			if (name === null) {
+				context.report({
+					node: callee,
+					messageId: "missingName"
+				});
+				return;
+			}
+			const owner = ownerName(node);
+			if (owner !== null && !nameMatchesOwner(name, owner)) context.report({
+				node: node.arguments[0] ?? callee,
+				messageId: "mismatchedName",
+				data: {
+					name,
+					owner
+				}
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/effect/rules/require-effect-namespace.ts
+function staticString$1(argument) {
+	if (argument === void 0 || argument.type === "SpreadElement") return null;
+	let current = argument;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSAsExpression" || current.type === "TSTypeAssertion") current = current.expression;
+	if (current.type === "Literal") return typeof current.value === "string" ? current.value : null;
+	if (current.type === "TemplateLiteral" && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? null;
+	return null;
+}
+const directNames = [
+	["Effect", "fn"],
+	["Effect", "makeSpan"],
+	["Effect", "makeSpanScoped"],
+	["Effect", "useSpan"],
+	["Layer", "span"]
+];
+const dualNames = [
+	["Effect", "withSpan"],
+	["Effect", "withSpanScoped"],
+	["Effect", "withLogSpan"],
+	["Channel", "withSpan"],
+	["RequestResolver", "withSpan"],
+	["Stream", "withSpan"],
+	["Layer", "withSpan"]
+];
+/** Require readable, repository-owned names for traced Effect operations. */
+const requireEffectNamespaceRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require static Effect trace names in @project/Domain.operation form." },
+		schema: [{
+			type: "object",
+			properties: { prefix: {
+				type: "string",
+				minLength: 1
+			} },
+			required: ["prefix"],
+			additionalProperties: false
+		}],
+		defaultOptions: [{ prefix: "@" }],
+		messages: {
+			invalidFormat: "{{api}} trace name \"{{key}}\" must use \"{{prefix}}Domain.operation\" with PascalCase domain segments and a camelCase operation.",
+			staticKey: "Give {{api}} a static trace name inside the repository namespace.",
+			wrongPrefix: "{{api}} trace name \"{{key}}\" must begin with the owned prefix \"{{prefix}}\" and include a name."
+		}
+	},
+	createOnce(context) {
+		const check = (node, index, api) => {
+			const argument = node.arguments[index];
+			const key = staticString$1(argument);
+			if (key === null) {
+				context.report({
+					node: argument ?? node,
+					messageId: "staticKey",
+					data: { api }
+				});
+				return;
+			}
+			const option = context.options[0];
+			const prefix = typeof option === "object" && option !== null && !Array.isArray(option) && typeof option.prefix === "string" ? option.prefix : "@";
+			if (key.startsWith(prefix) && key.length > prefix.length) {
+				if (/^(?:[A-Z][A-Za-z0-9]*\.)+[a-z][A-Za-z0-9]*$/u.test(key.slice(prefix.length))) return;
+				context.report({
+					node: argument ?? node,
+					messageId: "invalidFormat",
+					data: {
+						api,
+						key,
+						prefix
+					}
+				});
+				return;
+			}
+			context.report({
+				node: argument ?? node,
+				messageId: "wrongPrefix",
+				data: {
+					api,
+					key,
+					prefix
+				}
+			});
+		};
+		return { CallExpression(node) {
+			const matches = (callee, module, name) => isModuleCall(context.sourceCode, callee, moduleBindings("effect/" + module, module), name);
+			for (const [module, name] of directNames) if (matches(node.callee, module, name)) {
+				check(node, 0, module + "." + name);
+				return;
+			}
+			for (const [module, name] of dualNames) if (matches(node.callee, module, name)) {
+				const index = staticString$1(node.arguments[0]) !== null ? 0 : staticString$1(node.arguments[1]) !== null || node.arguments.length >= 3 ? 1 : 0;
+				check(node, index, module + "." + name);
+				return;
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/effect/rules/require-fetch-abort-signal.ts
+function propertyName(node) {
+	const key = node.type === "Property" ? node.key : node.property;
+	if (!node.computed && key.type === "Identifier") return key.name;
+	return key.type === "Literal" && typeof key.value === "string" ? key.value : null;
+}
+function isFetch(sourceCode, callee) {
+	if (callee.type === "Identifier") return isGlobalIdentifier(sourceCode, callee, "fetch");
+	return callee.type === "MemberExpression" && callee.object.type === "Identifier" && isGlobalIdentifier(sourceCode, callee.object, "globalThis") && propertyName(callee) === "fetch";
+}
+function tryPromiseCallback(sourceCode, node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (current.type === "FunctionDeclaration") return null;
+		if (current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") {
+			let owner = current;
+			if (owner.parent.type === "Property" && owner.parent.value === owner && propertyName(owner.parent) === "try" && owner.parent.parent.type === "ObjectExpression") owner = owner.parent.parent;
+			const parent = owner.parent;
+			return parent.type === "CallExpression" && parent.arguments[0] === owner && isModuleCall(sourceCode, parent.callee, moduleBindings("effect/Effect", "Effect"), "tryPromise") ? current : null;
+		}
+		current = current.parent;
+	}
+	return null;
+}
+function isCallbackSignal(sourceCode, value, callback) {
+	const parameter = callback.params[0];
+	if (parameter?.type !== "Identifier" || value.type !== "Identifier") return false;
+	let scope = sourceCode.getScope(value);
+	while (true) {
+		const variable = scope.set.get(value.name);
+		if (variable !== void 0) return variable.defs.some((definition) => definition.type === "Parameter" && definition.name === parameter);
+		if (scope.upper === null) return false;
+		scope = scope.upper;
+	}
+}
+function forwardsSignal(sourceCode, options, callback) {
+	if (options?.type !== "ObjectExpression") return false;
+	for (let index = options.properties.length - 1; index >= 0; index--) {
+		const property = options.properties[index];
+		if (property === void 0 || property.type === "SpreadElement") return false;
+		const name = propertyName(property);
+		if (name === null) return false;
+		if (name === "signal") return isCallbackSignal(sourceCode, property.value, callback);
+	}
+	return false;
+}
+/** Forward Effect interruption to global fetch at a direct Promise adapter boundary. */
+const requireFetchAbortSignalRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require global fetch in Effect.tryPromise callbacks to forward their AbortSignal." },
+		messages: { missingSignal: "Forward the Effect.tryPromise callback's signal with fetch(url, { ...options, signal }) so interruption cancels the request." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			if (!isFetch(context.sourceCode, node.callee)) return;
+			const callback = tryPromiseCallback(context.sourceCode, node);
+			if (callback === null || forwardsSignal(context.sourceCode, node.arguments[1], callback)) return;
+			context.report({
+				node,
+				messageId: "missingSignal"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/effect/rules/require-service-constructor-names.ts
+const layerMethods = [
+	"effect",
+	"effectContext",
+	"effectDiscard",
+	"succeed",
+	"succeedContext",
+	"sync",
+	"syncContext",
+	"unwrap",
+	"suspend",
+	"merge",
+	"mergeAll",
+	"fresh",
+	"orDie"
+];
+const layerCombinators = [
+	"provide",
+	"provideMerge",
+	"catch",
+	"catchCause"
+];
+function isFactory(node) {
+	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function unwrap(node) {
+	let current = node;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSAsExpression" || current.type === "TSNonNullExpression" || current.type === "TSTypeAssertion") current = current.expression;
+	return current;
+}
+function exportName(node) {
+	return node.type === "Identifier" ? node.name : node.value;
+}
+/** Name public service constructors consistently without requiring paired exports. */
+const requireServiceConstructorNamesRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Name exported Layers layer/layerX and service constructors make/makeX." },
+		messages: {
+			layer: "Name this exported Layer or Layer factory layer or layerX (for example layerConfig).",
+			make: "Name this exported service constructor make or makeX (for example makeMemory)."
+		}
+	},
+	createOnce(context) {
+		const layer = moduleBindings("effect/Layer", "Layer");
+		const effect = moduleBindings("effect/Effect", "Effect");
+		const service = moduleBindings("effect/Context", "Context");
+		const services = /* @__PURE__ */ new Set();
+		const interfaces = /* @__PURE__ */ new Set();
+		const constructors = /* @__PURE__ */ new Set();
+		const returns = /* @__PURE__ */ new Map();
+		const exports = [];
+		function variable(node) {
+			let scope = context.sourceCode.getScope(node);
+			while (true) {
+				const found = scope.set.get(node.name);
+				if (found !== void 0) return found;
+				if (scope.upper === null) return void 0;
+				scope = scope.upper;
+			}
+		}
+		function hasBinding(bindings, node) {
+			const binding = variable(node);
+			return binding !== void 0 && bindings.has(binding);
+		}
+		function serviceCall(expression) {
+			if (expression === null) return null;
+			const node = unwrap(expression);
+			if (node.type !== "CallExpression") return null;
+			const call = node.callee.type === "CallExpression" ? node.callee : node;
+			return isModuleCall(context.sourceCode, call.callee, service, "Service") ? call : null;
+		}
+		function registerService(id, call) {
+			const binding = variable(id);
+			if (binding !== void 0) services.add(binding);
+			if (id.parent.type === "ClassDeclaration") for (const declared of context.sourceCode.getDeclaredVariables(id.parent)) services.add(declared);
+			const shape = call.typeArguments?.params.at(-1);
+			if (shape?.type === "TSTypeReference" && shape.typeName.type === "Identifier") {
+				const shapeBinding = variable(shape.typeName);
+				if (shapeBinding !== void 0) interfaces.add(shapeBinding);
+			}
+		}
+		function typeKind(type) {
+			if (type?.type !== "TSTypeReference") return null;
+			if (isModuleType(context.sourceCode, type.typeName, layer, "Layer")) return "layer";
+			if (isModuleType(context.sourceCode, type.typeName, effect, "Effect")) return typeKind(type.typeArguments?.params[0]);
+			return type.typeName.type === "Identifier" && hasBinding(interfaces, type.typeName) ? "make" : null;
+		}
+		function kind(node, seen = /* @__PURE__ */ new Set()) {
+			if (seen.has(node)) return null;
+			const visited = new Set(seen).add(node);
+			if (node.type === "VariableDeclarator") return (node.id.type === "Identifier" ? typeKind(node.id.typeAnnotation?.typeAnnotation) ?? (hasBinding(constructors, node.id) ? "make" : null) : null) ?? (node.init === null ? null : kind(node.init, visited));
+			if (isFactory(node)) return typeKind(node.returnType?.typeAnnotation) ?? (node.type !== "ArrowFunctionExpression" && node.id !== null && hasBinding(constructors, node.id) ? "make" : null) ?? (node.body !== null && node.body.type !== "BlockStatement" ? kind(node.body, visited) : (returns.get(node) ?? []).map((value) => kind(value, visited)).find((value) => value !== null) ?? null);
+			if (node.type === "Identifier") {
+				const binding = variable(node);
+				if (binding === void 0 || services.has(binding)) return null;
+				if (constructors.has(binding)) return "make";
+				for (const definition of binding.defs) if (definition.type !== "ImportBinding") {
+					const result = kind(definition.node, visited);
+					if (result !== null) return result;
+				}
+				return null;
+			}
+			if (node.type === "ParenthesizedExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression") return kind(node.expression, visited);
+			if (node.type === "AwaitExpression") return kind(node.argument, visited);
+			if (node.type === "YieldExpression") return node.argument === null ? null : kind(node.argument, visited);
+			if (node.type === "ConditionalExpression") return kind(node.consequent, visited) ?? kind(node.alternate, visited);
+			if (node.type === "MemberExpression" && isModuleCall(context.sourceCode, node, layer, "empty")) return "layer";
+			if (node.type !== "CallExpression") return null;
+			const call = node.callee.type === "CallExpression" ? node.callee : node;
+			if (layerMethods.some((name) => isModuleCall(context.sourceCode, call.callee, layer, name))) return "layer";
+			if ((call !== node || node.arguments.length >= 2) && layerCombinators.some((name) => isModuleCall(context.sourceCode, call.callee, layer, name))) return "layer";
+			if (node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier") {
+				const receiver = node.callee.object;
+				if (node.callee.property.name === "of" && receiver.type === "Identifier" && hasBinding(services, receiver)) return "make";
+				if (node.callee.property.name === "pipe" && receiver.type !== "Super") {
+					const last = node.arguments.at(-1);
+					if (last?.type === "CallExpression" && [
+						"map",
+						"flatMap",
+						"as",
+						"asVoid"
+					].some((name) => isModuleCall(context.sourceCode, last.callee, effect, name))) return kind(last, visited);
+					return kind(receiver, visited);
+				}
+			}
+			if ([
+				"gen",
+				"fn",
+				"fnUntraced",
+				"sync",
+				"succeed",
+				"map",
+				"flatMap",
+				"suspend"
+			].some((name) => isModuleCall(context.sourceCode, call.callee, effect, name))) {
+				const result = node.arguments.filter((arg) => arg.type !== "SpreadElement").at(-1);
+				return result === void 0 ? null : kind(result, visited);
+			}
+			return node.callee.type === "Identifier" ? kind(node.callee, visited) : null;
+		}
+		function registerConstructor(expression) {
+			const node = unwrap(expression);
+			if (node.type === "Identifier") {
+				const binding = variable(node);
+				if (binding !== void 0 && binding.defs.some((def) => def.type !== "ImportBinding")) constructors.add(binding);
+			} else if (node.type === "CallExpression" && node.callee.type === "Identifier") registerConstructor(node.callee);
+			else if (isFactory(node)) {
+				if (node.body !== null && node.body.type !== "BlockStatement") registerConstructor(node.body);
+				else for (const value of returns.get(node) ?? []) registerConstructor(value);
+			}
+		}
+		return {
+			Program() {
+				services.clear();
+				interfaces.clear();
+				constructors.clear();
+				returns.clear();
+				exports.length = 0;
+			},
+			ClassDeclaration(node) {
+				const call = serviceCall(node.superClass);
+				if (node.id !== null && call !== null) registerService(node.id, call);
+			},
+			VariableDeclarator(node) {
+				const call = serviceCall(node.init);
+				if (node.id.type === "Identifier" && call !== null) registerService(node.id, call);
+			},
+			ReturnStatement(node) {
+				if (node.argument === null) return;
+				let parent = node.parent;
+				while (parent !== null && !isFactory(parent)) parent = parent.parent;
+				if (parent === null) return;
+				const values = returns.get(parent) ?? [];
+				values.push(node.argument);
+				returns.set(parent, values);
+			},
+			"CallExpression:exit"(node) {
+				const call = node.callee.type === "CallExpression" ? node.callee : node;
+				if (![
+					"effect",
+					"succeed",
+					"sync"
+				].some((name) => isModuleCall(context.sourceCode, call.callee, layer, name))) return;
+				const construction = node.arguments[call === node ? 1 : 0];
+				if (construction !== void 0 && construction.type !== "SpreadElement") registerConstructor(construction);
+			},
+			ExportNamedDeclaration(node) {
+				if (node.exportKind === "type" || node.source !== null) return;
+				const declaration = node.declaration;
+				if (declaration?.type === "VariableDeclaration") {
+					for (const item of declaration.declarations) if (item.id.type === "Identifier") exports.push({
+						name: item.id.name,
+						node: item.id,
+						value: item
+					});
+				} else if (declaration?.type === "FunctionDeclaration" && declaration.id !== null) exports.push({
+					name: declaration.id.name,
+					node: declaration.id,
+					value: declaration
+				});
+				for (const specifier of node.specifiers) if (specifier.type === "ExportSpecifier" && specifier.exportKind !== "type") exports.push({
+					name: exportName(specifier.exported),
+					node: specifier.exported,
+					value: specifier.local
+				});
+			},
+			ExportDefaultDeclaration(node) {
+				exports.push({
+					name: "default",
+					node,
+					value: node.declaration
+				});
+			},
+			"Program:exit"() {
+				for (const entry of exports) {
+					const result = kind(entry.value);
+					if (result === null) continue;
+					if (!(result === "layer" ? /^layer(?:[A-Z][a-zA-Z0-9]*)?$/u : /^make(?:[A-Z][a-zA-Z0-9]*)?$/u).test(entry.name)) context.report({
+						node: entry.node,
+						messageId: result
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+//#region src/effect/rules/require-service-key-prefix.ts
+function staticString(argument) {
+	if (argument === void 0 || argument.type === "SpreadElement") return null;
+	let current = argument;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSSatisfiesExpression") current = current.expression;
+	if (current.type === "Literal") return typeof current.value === "string" ? current.value : null;
+	if (current.type === "TemplateLiteral" && current.expressions.length === 0) return current.quasis[0]?.value.cooked ?? current.quasis[0]?.value.raw ?? "";
+	return null;
+}
+/** Keep Effect service identifiers inside the repository's owned namespace. */
+const requireServiceKeyPrefixRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require Context.Service and Context.Reference keys to use a configured static prefix." },
+		schema: [{
+			type: "object",
+			properties: { prefix: {
+				type: "string",
+				minLength: 1
+			} },
+			required: ["prefix"],
+			additionalProperties: false
+		}],
+		defaultOptions: [{ prefix: "@" }],
+		messages: {
+			staticKey: "Give this Context service/reference a static string key inside the repository namespace.",
+			wrongPrefix: "Service key \"{{key}}\" must begin with the owned prefix \"{{prefix}}\" and include a name."
+		}
+	},
+	createOnce(context) {
+		const checkKey = (node, keyArgument) => {
+			const key = staticString(keyArgument);
+			if (key === null) {
+				context.report({
+					node,
+					messageId: "staticKey"
+				});
+				return;
+			}
+			const option = context.options?.[0];
+			const prefix = typeof option === "object" && option !== null && !Array.isArray(option) && typeof option.prefix === "string" ? option.prefix : "@";
+			if (key.startsWith(prefix) && key.length > prefix.length) return;
+			context.report({
+				node: keyArgument ?? node,
+				messageId: "wrongPrefix",
+				data: {
+					key,
+					prefix
+				}
+			});
+		};
+		return { CallExpression(node) {
+			const matches = (callee, name) => isModuleCall(context.sourceCode, callee, moduleBindings("effect/Context", "Context"), name);
+			if (matches(node.callee, "Reference")) {
+				checkKey(node, node.arguments[0]);
+				return;
+			}
+			if (node.callee.type === "CallExpression" && matches(node.callee.callee, "Service") && node.callee.arguments.length === 0) {
+				checkKey(node, node.arguments[0]);
+				return;
+			}
+			if (!matches(node.callee, "Service")) return;
+			if (node.arguments.length === 0 && node.parent.type === "CallExpression" && node.parent.callee === node) return;
+			checkKey(node, node.arguments[0]);
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-conditional-empty-object-spread.ts
+function unwrapParentheses(node) {
+	let current = node;
+	while (current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+function isEmptyObjectExpression$1(node) {
+	return node.type === "ObjectExpression" && node.properties.length === 0;
+}
+function isConditionalEmptyObjectSpread(node) {
+	const conditional = unwrapParentheses(node);
+	return conditional.type === "ConditionalExpression" && (isEmptyObjectExpression$1(conditional.consequent) || isEmptyObjectExpression$1(conditional.alternate));
+}
+/** Ban conditional empty-object spreads without changing their omission semantics. */
+const noConditionalEmptyObjectSpreadRule = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow object spreads that conditionally spread an empty object to omit fields." },
+		messages: { avoid: "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present." }
+	},
+	createOnce(context) {
+		return { SpreadElement(node) {
+			if (node.parent.type !== "ObjectExpression") return;
+			if (isConditionalEmptyObjectSpread(node.argument)) context.report({
+				node,
+				messageId: "avoid"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/shared/package-layout.ts
+/** Normalize existing symlinks without requiring editor buffers to exist on disk. */
+function physicalPath(filename) {
+	const absolute = resolve(filename);
+	return existsSync(absolute) ? realpathSync(absolute) : absolute;
+}
+/** Find the package that owns a source file or an unsaved editor buffer. */
+function packageOwner(filename) {
+	let directory = dirname(physicalPath(filename));
+	while (true) {
+		const manifest = join(directory, "package.json");
+		if (existsSync(manifest)) {
+			const value = JSON.parse(readFileSync(manifest, "utf8"));
+			if (!((value?.type === "module" || value?.type === "commonjs") && Object.keys(value).length === 1)) return {
+				root: directory,
+				name: typeof value?.name === "string" ? value.name : null,
+				hasExports: value !== null && Object.hasOwn(value, "exports")
+			};
+		}
+		const parent = dirname(directory);
+		if (parent === directory) return null;
+		directory = parent;
+	}
+}
+/** Return a portable package-relative path, including for Windows hosts. */
+function packagePath(owner, filename) {
+	return relative(owner.root, physicalPath(filename)).split(sep).join("/");
+}
+/** Recognize test/spec suffixes on supported JavaScript and TypeScript files. */
+function isTestFile(filename) {
+	return /\.(?:test|spec)\.(?:[cm]?[jt]s|[jt]sx)$/u.test(filename);
+}
+/** Include test resources and legacy test locations in the production boundary. */
+function isTestPath(path) {
+	return path.startsWith("test/") || path.startsWith("tests/") || path.split("/").includes("__tests__") || isTestFile(path);
+}
+//#endregion
+//#region src/shared/import-resolution.ts
+/** Resolve TS paths and Node package exports with the same conditions. */
+function importResolution() {
+	const options = {
+		extensions: [
+			".ts",
+			".tsx",
+			".mts",
+			".cts",
+			".js",
+			".jsx",
+			".mjs",
+			".cjs",
+			".json"
+		],
+		extensionAlias: {
+			".js": [
+				".ts",
+				".tsx",
+				".js"
+			],
+			".mjs": [".mts", ".mjs"],
+			".cjs": [".cts", ".cjs"]
+		},
+		conditionNames: [
+			"types",
+			"import",
+			"node",
+			"default"
+		],
+		builtinModules: true
+	};
+	const resolver = new ResolverFactory({
+		...options,
+		tsconfig: "auto"
+	});
+	const internals = resolver.cloneWithOptions({
+		...options,
+		tsconfig: "auto",
+		exportsFields: []
+	});
+	return {
+		target(filename, specifier) {
+			const resolved = resolver.resolveFileSync(filename, specifier);
+			if (resolved.builtin) return null;
+			if (resolved.path) return physicalPath(resolved.path);
+			const fallback = internals.resolveFileSync(filename, specifier);
+			if (fallback.path) return physicalPath(fallback.path);
+			if (resolved.error?.includes("is not exported")) {
+				const name = specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+				const manifest = internals.sync(dirname(filename), name + "/package.json");
+				if (manifest.path) return physicalPath(manifest.path);
+			}
+			if (specifier.startsWith(".") || isAbsolute(specifier)) return physicalPath(resolve(dirname(filename), specifier));
+			return null;
+		},
+		publicTarget(filename, specifier) {
+			const result = resolver.sync(dirname(filename), specifier);
+			return result.path ? physicalPath(result.path) : null;
+		}
+	};
+}
+//#endregion
+//#region src/shared/import-sources.ts
+function isUnshadowedRequire(sourceCode, node) {
+	let scope = sourceCode.getScope(node);
+	while (true) {
+		const variable = scope.set.get("require");
+		if (variable) return variable.defs.length === 0;
+		if (!scope.upper) return true;
+		scope = scope.upper;
+	}
+}
+/** Visit literal module references, including re-exports and type-only imports. */
+function importSources(sourceCode, check) {
+	return {
+		TSImportType(node) {
+			check(node.source, node.source.value);
+		},
+		TSExternalModuleReference(node) {
+			check(node.expression, node.expression.value);
+		},
+		ImportDeclaration(node) {
+			check(node.source, node.source.value);
+		},
+		ExportNamedDeclaration(node) {
+			if (node.source) check(node.source, node.source.value);
+		},
+		ExportAllDeclaration(node) {
+			check(node.source, node.source.value);
+		},
+		ImportExpression(node) {
+			if (node.source.type === "Literal" && typeof node.source.value === "string") check(node.source, node.source.value);
+		},
+		CallExpression(node) {
+			const first = node.arguments[0];
+			if (node.callee.type === "Identifier" && node.callee.name === "require" && isUnshadowedRequire(sourceCode(), node.callee) && first?.type === "Literal" && typeof first.value === "string") check(first, first.value);
+		}
+	};
+}
+//#endregion
+//#region src/rules/no-cross-package-internals.ts
+/** Require imports across package boundaries to use the target's public API. */
+const noCrossPackageInternalsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow cross-package filesystem imports and private deep imports." },
+		schema: [],
+		messages: { boundary: "Import {{package}} through its package name and public exports, not another package's files." }
+	},
+	create(context) {
+		const filename = physicalPath(context.filename);
+		const owner = packageOwner(filename);
+		if (!owner) return {};
+		const resolution = importResolution();
+		return importSources(() => context.sourceCode, (node, specifier) => {
+			const target = resolution.target(filename, specifier);
+			if (!target) return;
+			const destination = packageOwner(target);
+			if (!destination || destination.root === owner.root) return;
+			const name = destination.name;
+			if (name && (specifier === name || destination.hasExports && specifier.startsWith(name + "/")) && resolution.publicTarget(filename, specifier) === target) return;
+			context.report({
+				node,
+				messageId: "boundary",
+				data: { package: name ?? destination.root }
+			});
+		});
+	}
+});
+//#endregion
+//#region src/rules/no-export-assignment.ts
+/** Reject the TypeScript CommonJS export form not covered by import/no-commonjs. */
+const noExportAssignmentRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require ESM exports instead of TypeScript export assignments." },
+		schema: [],
+		messages: { commonjs: "Use ESM export syntax instead of CommonJS export =." }
+	},
+	createOnce(context) {
+		return { TSExportAssignment(node) {
+			context.report({
+				node,
+				messageId: "commonjs"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/shared/dictionary-types.ts
+const BUILT_INS = /* @__PURE__ */ new Set([
+	"Record",
+	"Readonly",
+	"Partial",
+	"Required",
+	"Pick",
+	"Omit",
+	"PropertyKey",
+	"NonNullable"
+]);
+const TRANSPARENT_WRAPPERS = /* @__PURE__ */ new Set([
+	"Readonly",
+	"Partial",
+	"Required",
+	"NonNullable"
+]);
+function declaredStatement(statement) {
+	return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration ?? null : statement;
+}
+function createTypeEnvironment(program) {
+	const aliases = /* @__PURE__ */ new Map();
+	const interfaces = /* @__PURE__ */ new Map();
+	const shadowedBuiltIns = /* @__PURE__ */ new Set();
+	for (const statement of program.body) {
+		const declaration = declaredStatement(statement);
+		if (declaration?.type === "ImportDeclaration") {
+			for (const specifier of declaration.specifiers) if (BUILT_INS.has(specifier.local.name)) shadowedBuiltIns.add(specifier.local.name);
+			continue;
+		}
+		if (declaration?.type === "TSTypeAliasDeclaration") {
+			if (aliases.get(declaration.id.name) === void 0) aliases.set(declaration.id.name, declaration);
+			else shadowedBuiltIns.add(declaration.id.name);
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+		if (declaration?.type === "TSInterfaceDeclaration") {
+			const declarations = interfaces.get(declaration.id.name) ?? [];
+			declarations.push(declaration);
+			interfaces.set(declaration.id.name, declarations);
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+		if (declaration?.type === "TSEnumDeclaration") {
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+			continue;
+		}
+		if ((declaration?.type === "ClassDeclaration" || declaration?.type === "FunctionDeclaration") && declaration.id !== null) {
+			if (BUILT_INS.has(declaration.id.name)) shadowedBuiltIns.add(declaration.id.name);
+		}
+	}
+	return {
+		aliases,
+		interfaces,
+		shadowedBuiltIns
+	};
+}
+function typeReferenceName$1(type) {
+	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isBuiltIn(name, environment) {
+	return BUILT_INS.has(name) && !environment.shadowedBuiltIns.has(name);
+}
+function isUnappliedReferenceTo(type, name) {
+	const unwrapped = unwrapTransparentType(type);
+	return unwrapped.type === "TSTypeReference" && typeReferenceName$1(unwrapped) === name && (unwrapped.typeArguments === null || unwrapped.typeArguments === void 0 || unwrapped.typeArguments.params.length === 0);
+}
+function unwrapTransparentType(type) {
+	let current = type;
+	while (current.type === "TSParenthesizedType" || current.type === "TSTypeOperator" && current.operator === "readonly") current = current.typeAnnotation;
+	return current;
+}
+function isNeverType(type) {
+	return unwrapTransparentType(type).type === "TSNeverKeyword";
+}
+function isEffectivelyEmptyMember(member) {
+	return member.type === "TSPropertySignature" && member.optional === true && member.typeAnnotation !== null && member.typeAnnotation !== void 0 && isNeverType(member.typeAnnotation.typeAnnotation);
+}
+function isEffectivelyEmptyTypeLiteral(type) {
+	return type.members.length === 0 || type.members.every(isEffectivelyEmptyMember);
+}
+function isEffectivelyEmptyInterface(declarations) {
+	if (declarations.length !== 1) return false;
+	const [type] = declarations;
+	return type !== void 0 && type.extends.length === 0 && (type.body.body.length === 0 || type.body.body.every(isEffectivelyEmptyMember));
+}
+function resolvedSubstitutionArgument(type, base, resolving = /* @__PURE__ */ new Set()) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type !== "TSTypeReference") return type;
+	const name = typeReferenceName$1(unwrapped);
+	if (name === null || resolving.has(name)) return type;
+	const substitution = base.get(name);
+	if (substitution === void 0) return type;
+	const nextResolving = new Set(resolving);
+	nextResolving.add(name);
+	return resolvedSubstitutionArgument(substitution, base, nextResolving);
+}
+function aliasSubstitution(alias, type, base) {
+	const parameters = alias.typeParameters?.params ?? [];
+	const arguments_ = type.typeArguments?.params ?? [];
+	const next = new Map(base);
+	for (const [index, parameter] of parameters.entries()) {
+		const argument = arguments_[index] ?? parameter.default;
+		if (argument === null || argument === void 0) return null;
+		next.set(parameter.name.name, resolvedSubstitutionArgument(argument, next));
+	}
+	return next;
+}
+function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSUnknownKeyword") return "unknown";
+	if (unwrapped.type === "TSAnyKeyword") return "any";
+	if (unwrapped.type === "TSObjectKeyword") return "object";
+	if (unwrapped.type === "TSTypeLiteral" && isEffectivelyEmptyTypeLiteral(unwrapped)) return "empty-object";
+	if (unwrapped.type === "TSUnionType") return unwrapped.types.some((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases) !== null) ? "union" : null;
+	if (unwrapped.type === "TSIntersectionType") {
+		const unsafeMembers = unwrapped.types.map((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases));
+		if (unsafeMembers.includes("any")) return "any";
+		const [firstUnsafeMember] = unsafeMembers;
+		return firstUnsafeMember !== void 0 && unsafeMembers.every((member) => member !== null) ? firstUnsafeMember : null;
+	}
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName$1(unwrapped);
+	if (name === null) return null;
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : unsafeDirectValue(wrapped, environment, substitutions, resolvingAliases);
+	}
+	const substitution = substitutions.get(name);
+	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? null : unsafeDirectValue(substitution, environment, substitutions, resolvingAliases);
+	const interfaceDeclarations = environment.interfaces.get(name);
+	if (interfaceDeclarations !== void 0) return isEffectivelyEmptyInterface(interfaceDeclarations) ? "empty-object" : null;
+	const alias = environment.aliases.get(name);
+	if (alias === void 0 || resolvingAliases.has(name)) return null;
+	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+	if (nextSubstitutions === null) return null;
+	const nextResolving = new Set(resolvingAliases);
+	nextResolving.add(name);
+	return unsafeDirectValue(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+function dictionaryValueTypes(type, environment, substitutions, resolvingAliases) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.flatMap((member) => member.type === "TSIndexSignature" && member.typeAnnotation !== null ? [{
+		type: member.typeAnnotation.typeAnnotation,
+		substitutions
+	}] : []);
+	if (unwrapped.type === "TSMappedType") return unwrapped.typeAnnotation === null ? [] : [{
+		type: unwrapped.typeAnnotation,
+		substitutions
+	}];
+	if (unwrapped.type !== "TSTypeReference") return [];
+	const name = typeReferenceName$1(unwrapped);
+	if (name === null) return [];
+	const substitution = substitutions.get(name);
+	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? [] : dictionaryValueTypes(substitution, environment, substitutions, resolvingAliases);
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? [] : dictionaryValueTypes(wrapped, environment, substitutions, resolvingAliases);
+	}
+	if (name === "Record" && isBuiltIn(name, environment)) {
+		const value = unwrapped.typeArguments?.params[1] ?? null;
+		return value === null ? [] : [{
+			type: value,
+			substitutions
+		}];
+	}
+	if ((name === "Pick" || name === "Omit") && isBuiltIn(name, environment)) {
+		const source = unwrapped.typeArguments?.params[0];
+		return source === void 0 ? [] : dictionaryValueTypes(source, environment, substitutions, resolvingAliases);
+	}
+	const alias = environment.aliases.get(name);
+	if (alias === void 0 || resolvingAliases.has(name)) return [];
+	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+	if (nextSubstitutions === null) return [];
+	const nextResolving = new Set(resolvingAliases);
+	nextResolving.add(name);
+	return dictionaryValueTypes(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+function classifyUnsafeDictionaryValue(valueType, environment) {
+	const unsafeValue = unsafeDirectValue(valueType, environment, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+	return unsafeValue === null ? null : {
+		kind: "unsafe-dictionary",
+		unsafeValue
+	};
+}
+function classifyUnsafeDictionary(type, environment) {
+	for (const valueType of dictionaryValueTypes(type, environment, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set())) {
+		const unsafeValue = unsafeDirectValue(valueType.type, environment, valueType.substitutions, /* @__PURE__ */ new Set());
+		if (unsafeValue !== null) return {
+			kind: "unsafe-dictionary",
+			unsafeValue
+		};
+	}
+	return null;
+}
+function resolvesToDictionary(type, environment, substitutions, resolvingAliases) {
+	return dictionaryValueTypes(type, environment, substitutions, resolvingAliases).length > 0;
+}
+function classifyWideningTarget(type, environment) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSUnknownKeyword") return { kind: "unknown" };
+	if (unwrapped.type === "TSObjectKeyword") return { kind: "object" };
+	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.some((member) => member.type === "TSIndexSignature") ? { kind: "open dictionary" } : unwrapped.members.length > 0 ? { kind: "anonymous object" } : null;
+	if (unwrapped.type === "TSMappedType") return { kind: "open dictionary" };
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName$1(unwrapped);
+	if (name === null) return null;
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : classifyWideningTarget(wrapped, environment);
+	}
+	if (name === "Record" && isBuiltIn(name, environment)) return { kind: "open dictionary" };
+	const alias = environment.aliases.get(name);
+	if (alias === void 0) return null;
+	if ((alias.typeParameters?.params.length ?? 0) > 0) {
+		const substitutions = aliasSubstitution(alias, unwrapped, /* @__PURE__ */ new Map());
+		return substitutions !== null && resolvesToDictionary(alias.typeAnnotation, environment, substitutions, /* @__PURE__ */ new Set([name])) ? { kind: "generic container" } : null;
+	}
+	const substitutions = aliasSubstitution(alias, unwrapped, /* @__PURE__ */ new Map());
+	if (substitutions === null) return null;
+	return classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, /* @__PURE__ */ new Set([name]));
+}
+function isBroadMappedKey(type, environment, substitutions) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSStringKeyword" || unwrapped.type === "TSNumberKeyword" || unwrapped.type === "TSSymbolKeyword") return true;
+	if (unwrapped.type === "TSUnionType") return unwrapped.types.every((member) => isBroadMappedKey(member, environment, substitutions));
+	if (unwrapped.type !== "TSTypeReference") return false;
+	const name = typeReferenceName$1(unwrapped);
+	if (name === null) return false;
+	const substitution = substitutions.get(name);
+	if (substitution !== void 0 && !isUnappliedReferenceTo(substitution, name)) return isBroadMappedKey(substitution, environment, substitutions);
+	return name === "PropertyKey" && isBuiltIn(name, environment);
+}
+function classifyAliasBroadTarget(type, environment, substitutions, resolvingAliases) {
+	const unwrapped = unwrapTransparentType(type);
+	if (unwrapped.type === "TSUnknownKeyword") return { kind: "unknown" };
+	if (unwrapped.type === "TSObjectKeyword") return { kind: "object" };
+	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.some((member) => member.type === "TSIndexSignature") ? { kind: "open dictionary" } : null;
+	if (unwrapped.type === "TSMappedType") return isBroadMappedKey(unwrapped.constraint, environment, substitutions) ? { kind: "open dictionary" } : null;
+	if (unwrapped.type !== "TSTypeReference") return null;
+	const name = typeReferenceName$1(unwrapped);
+	if (name === null) return null;
+	const substitution = substitutions.get(name);
+	if (substitution !== void 0) return isUnappliedReferenceTo(substitution, name) ? null : classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
+	if (TRANSPARENT_WRAPPERS.has(name) && isBuiltIn(name, environment)) {
+		const wrapped = unwrapped.typeArguments?.params[0];
+		return wrapped === void 0 ? null : classifyAliasBroadTarget(wrapped, environment, substitutions, resolvingAliases);
+	}
+	if (name === "Record" && isBuiltIn(name, environment)) return { kind: "open dictionary" };
+	const alias = environment.aliases.get(name);
+	if (alias === void 0 || resolvingAliases.has(name)) return null;
+	const nextSubstitutions = aliasSubstitution(alias, unwrapped, substitutions);
+	if (nextSubstitutions === null) return null;
+	const nextResolving = new Set(resolvingAliases);
+	nextResolving.add(name);
+	return classifyAliasBroadTarget(alias.typeAnnotation, environment, nextSubstitutions, nextResolving);
+}
+function isKnownEvidenceExpression(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression" || current.type === "TSSatisfiesExpression") current = current.expression;
+	if (current.type === "ObjectExpression") return true;
+	return current.type === "ArrayExpression" || current.type === "ArrowFunctionExpression" || current.type === "ClassExpression" || current.type === "FunctionExpression" || current.type === "NewExpression" || current.type === "Literal" || current.type === "TemplateLiteral" || current.type === "UnaryExpression";
+}
+//#endregion
+//#region src/rules/no-known-value-widening.ts
+function unwrapExpression(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") current = current.expression;
+	return current;
+}
+function resolveVariable$2(sourceCode, identifier) {
+	let scope = sourceCode.getScope(identifier);
+	while (scope !== null) {
+		const variable = scope.set.get(identifier.name);
+		if (variable !== void 0) return variable;
+		scope = scope.upper;
+	}
+	return null;
+}
+function variableDeclarator(variable) {
+	if (variable.defs.length !== 1) return null;
+	const [definition] = variable.defs;
+	return definition?.type === "Variable" && definition.node.type === "VariableDeclarator" ? definition.node : null;
+}
+function isStableConstVariable(variable, declarator) {
+	return declarator.parent.type === "VariableDeclaration" && declarator.parent.kind === "const" && variable.references.every((reference) => reference.init || !reference.isWrite());
+}
+function hasKnownEvidence(sourceCode, expression, visitedVariables = /* @__PURE__ */ new Set()) {
+	if (isKnownEvidenceExpression(expression)) return true;
+	const unwrapped = unwrapExpression(expression);
+	if (unwrapped.type !== "Identifier") return false;
+	const variable = resolveVariable$2(sourceCode, unwrapped);
+	if (variable === null || visitedVariables.has(variable)) return false;
+	const declarator = variableDeclarator(variable);
+	if (declarator === null || declarator.init === null || !isStableConstVariable(variable, declarator)) return false;
+	visitedVariables.add(variable);
+	return hasKnownEvidence(sourceCode, declarator.init, visitedVariables);
+}
+function annotationTarget(annotation, environment) {
+	return annotation === null || annotation === void 0 ? null : classifyWideningTarget(annotation.typeAnnotation, environment);
+}
+function enclosingFunction(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (current.type === "ArrowFunctionExpression" || current.type === "FunctionDeclaration" || current.type === "FunctionExpression") return current;
+		current = current.parent;
+	}
+	return null;
+}
+function sourceKeyName(sourceCode, key) {
+	if (key.type === "Identifier" || key.type === "PrivateIdentifier") return key.name;
+	if (key.type === "Literal") return String(key.value);
+	return sourceCode.getText(key);
+}
+function functionName(sourceCode, owner) {
+	if (owner === null) return "anonymous function";
+	if (owner.id !== null) return owner.id.name;
+	const parent = owner.parent;
+	if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") return parent.id.name;
+	if (parent.type === "MethodDefinition") return sourceKeyName(sourceCode, parent.key);
+	return "anonymous function";
+}
+function isEmptyObjectExpression(expression) {
+	const unwrapped = unwrapExpression(expression);
+	return unwrapped.type === "ObjectExpression" && unwrapped.properties.length === 0;
+}
+function isDictionaryAccumulatorTarget(destination) {
+	return destination.kind === "open dictionary" || destination.kind === "generic container";
+}
+function hasParentAssertion(node) {
+	return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
+}
+/** Detect sound syntactic cases where a known value is explicitly widened and loses evidence. */
+const noKnownValueWideningRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow syntactically established values from flowing into explicitly broad or anonymous target types that discard useful evidence." },
+		messages: { widening: "The explicit {{target}} type on {{subject}} discards known type evidence. Keep inference, validate with `satisfies`, or use a named owner contract." }
+	},
+	createOnce(context) {
+		let environment = null;
+		const reportFlow = (expression, destination, subject) => {
+			if (destination === null) return;
+			if (isDictionaryAccumulatorTarget(destination) && isEmptyObjectExpression(expression)) return;
+			if (!hasKnownEvidence(context.sourceCode, expression)) return;
+			context.report({
+				node: expression,
+				messageId: "widening",
+				data: {
+					subject,
+					target: destination.kind
+				}
+			});
+		};
+		const targetFromAnnotation = (annotation) => environment === null ? null : annotationTarget(annotation, environment);
+		return {
+			Program(node) {
+				environment = createTypeEnvironment(node);
+			},
+			VariableDeclarator(node) {
+				if (node.init === null || node.id.type !== "Identifier") return;
+				reportFlow(node.init, targetFromAnnotation(node.id.typeAnnotation), `binding \`${node.id.name}\``);
+			},
+			PropertyDefinition(node) {
+				if (node.value === null) return;
+				reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+			},
+			AccessorProperty(node) {
+				if (node.value === null) return;
+				reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+			},
+			AssignmentExpression(node) {
+				if (node.operator !== "=" || node.left.type !== "Identifier") return;
+				const variable = resolveVariable$2(context.sourceCode, node.left);
+				if (variable === null) return;
+				const declarator = variableDeclarator(variable);
+				if (declarator === null || declarator.id.type !== "Identifier") return;
+				reportFlow(node.right, targetFromAnnotation(declarator.id.typeAnnotation), `binding \`${declarator.id.name}\``);
+			},
+			ReturnStatement(node) {
+				if (node.argument === null) return;
+				const owner = enclosingFunction(node);
+				reportFlow(node.argument, targetFromAnnotation(owner?.returnType), `return value of \`${functionName(context.sourceCode, owner)}\``);
+			},
+			ArrowFunctionExpression(node) {
+				if (node.body.type === "BlockStatement") return;
+				reportFlow(node.body, targetFromAnnotation(node.returnType), `return value of \`${functionName(context.sourceCode, node)}\``);
+			},
+			TSAsExpression(node) {
+				if (environment === null || hasParentAssertion(node)) return;
+				reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
+			},
+			TSTypeAssertion(node) {
+				if (environment === null || hasParentAssertion(node)) return;
+				reportFlow(node.expression, classifyWideningTarget(node.typeAnnotation, environment), "assertion");
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-module-mocking.ts
+const moduleMockMethods = /* @__PURE__ */ new Set([
+	"doMock",
+	"mock",
+	"unstable_mockModule"
+]);
+function resolveVariable$1(sourceCode, identifier) {
+	let scope = sourceCode.getScope(identifier);
+	while (scope !== null) {
+		const variable = scope.set.get(identifier.name);
+		if (variable !== void 0) return variable;
+		scope = scope.upper;
+	}
+	return null;
+}
+function importedName(node) {
+	if (node.type !== "ImportSpecifier") return null;
+	return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
+}
+function isTestFrameworkObject(sourceCode, expression) {
+	if (expression.type !== "Identifier") return false;
+	if ((expression.name === "vi" || expression.name === "jest") && sourceCode.isGlobalReference(expression)) return true;
+	const variable = resolveVariable$1(sourceCode, expression);
+	if (variable === null || variable.defs.length === 0) return expression.name === "vi" || expression.name === "jest";
+	return variable.defs.some((definition) => {
+		if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") return false;
+		const source = definition.parent.source.value;
+		const name = importedName(definition.node);
+		return source === "vitest" && name === "vi" || source === "@jest/globals" && name === "jest";
+	});
+}
+function moduleMockCall(sourceCode, callee) {
+	if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) return false;
+	if (!isTestFrameworkObject(sourceCode, callee.object)) return false;
+	const property = callee.property;
+	const method = callee.computed ? property.type === "Literal" && (property.value === "doMock" || property.value === "mock" || property.value === "unstable_mockModule") ? property.value : null : property.type === "Identifier" ? property.name : null;
+	return method !== null && moduleMockMethods.has(method);
+}
+/** Ban test framework module mocking in favor of real dependency seams. */
+const noModuleMockingRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow Vitest and Jest module mocking; tests must replace dependencies through real interfaces." },
+		messages: { moduleMock: "Replace module mocking with dependency injection through a real interface, service layer, or faithful test implementation." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+			if (moduleMockCall(context.sourceCode, node.callee)) context.report({
+				node,
+				messageId: "moduleMock"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/shared/lexical-type-parameters.ts
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function collectInferTypeParameterNames(node, visitorKeys, names) {
+	if (node.type === "TSInferType") names.add(node.typeParameter.name.name);
+	const record = node;
+	for (const key of visitorKeys[node.type] ?? []) {
+		const value = record[key];
+		if (isNode(value)) {
+			collectInferTypeParameterNames(value, visitorKeys, names);
+			continue;
+		}
+		if (!Array.isArray(value)) continue;
+		for (const child of value) if (isNode(child)) collectInferTypeParameterNames(child, visitorKeys, names);
+	}
+}
+/** Collect type binders that are in scope at a node and can shadow module aliases. */
+function lexicalTypeParameterNames(node, visitorKeys) {
+	const names = /* @__PURE__ */ new Set();
+	let descendant = node;
+	let current = node;
+	while (current !== null && current.type !== "Program") {
+		if ("typeParameters" in current) for (const parameter of current.typeParameters?.params ?? []) names.add(parameter.name.name);
+		if (current.type === "TSMappedType" && (descendant === current.nameType || descendant === current.typeAnnotation)) names.add(current.key.name);
+		if (current.type === "TSConditionalType" && descendant === current.trueType) collectInferTypeParameterNames(current.extendsType, visitorKeys, names);
+		descendant = current;
+		current = current.parent;
+	}
+	return names;
+}
+//#endregion
+//#region src/rules/no-object-parameters.ts
+function parameterAnnotation(parameter) {
+	if (parameter.type === "TSParameterProperty") return parameterAnnotation(parameter.parameter);
+	if (parameter.type === "RestElement") return parameter.typeAnnotation ?? parameterAnnotation(parameter.argument);
+	if (parameter.type === "AssignmentPattern") return parameter.typeAnnotation ?? parameter.left.typeAnnotation;
+	return parameter.typeAnnotation;
+}
+function parameterName(parameter, sourceCode) {
+	return parameter.type === "Identifier" ? parameter.name : sourceCode.getText(parameter).replace(/\s*:\s*object\s*$/u, "");
+}
+/** Ban the broad object type on function inputs, including local aliases to object. */
+const noObjectParametersRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow object function parameters; inputs must use an owner-provided type and be parsed at their boundary." },
+		messages: { objectParameter: "Parameter `{{parameter}}` uses the broad `object` type. Accept a named owner type; parse external input at its boundary before calling this function." }
+	},
+	createOnce(context) {
+		const aliases = /* @__PURE__ */ new Map();
+		const resolvesToObject = (type, shadowedAliases, visited = /* @__PURE__ */ new Set()) => {
+			if (type.type === "TSObjectKeyword") return true;
+			if (type.type === "TSParenthesizedType") return resolvesToObject(type.typeAnnotation, shadowedAliases, visited);
+			if (type.type === "TSUnionType") return type.types.some((member) => resolvesToObject(member, shadowedAliases, visited));
+			if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier" || type.typeArguments !== null && type.typeArguments !== void 0 && type.typeArguments.params.length > 0 || visited.has(type.typeName.name) || shadowedAliases.has(type.typeName.name)) return false;
+			const alias = aliases.get(type.typeName.name);
+			if (alias === void 0) return false;
+			const nextVisited = new Set(visited);
+			nextVisited.add(type.typeName.name);
+			return resolvesToObject(alias, shadowedAliases, nextVisited);
+		};
+		const checkParameters = (node) => {
+			const shadowedAliases = lexicalTypeParameterNames(node, context.sourceCode.visitorKeys);
+			for (const parameter of node.params) {
+				const annotation = parameterAnnotation(parameter);
+				if (annotation === null || annotation === void 0) continue;
+				if (!resolvesToObject(annotation.typeAnnotation, shadowedAliases)) continue;
+				context.report({
+					node: annotation.typeAnnotation,
+					messageId: "objectParameter",
+					data: { parameter: parameterName(parameter, context.sourceCode) }
+				});
+			}
+		};
+		return {
+			Program(node) {
+				aliases.clear();
+				for (const statement of node.body) {
+					const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+					if (declaration?.type === "TSTypeAliasDeclaration" && (declaration.typeParameters === null || declaration.typeParameters === void 0)) aliases.set(declaration.id.name, declaration.typeAnnotation);
+				}
+			},
+			ArrowFunctionExpression: checkParameters,
+			FunctionDeclaration: checkParameters,
+			FunctionExpression: checkParameters,
+			TSCallSignatureDeclaration: checkParameters,
+			TSConstructSignatureDeclaration: checkParameters,
+			TSConstructorType: checkParameters,
+			TSDeclareFunction: checkParameters,
+			TSEmptyBodyFunctionExpression: checkParameters,
+			TSFunctionType: checkParameters,
+			TSMethodSignature: checkParameters
+		};
+	}
+});
+//#endregion
+//#region src/shared/reflect-method.ts
+function resolveVariable(sourceCode, identifier) {
+	let scope = sourceCode.getScope(identifier);
+	while (scope !== null) {
+		const variable = scope.set.get(identifier.name);
+		if (variable !== void 0) return variable;
+		scope = scope.upper;
+	}
+	return null;
+}
+function isGlobalReflect(sourceCode, expression) {
+	if (expression.type !== "Identifier" || expression.name !== "Reflect") return false;
+	if (sourceCode.isGlobalReference(expression)) return true;
+	const variable = resolveVariable(sourceCode, expression);
+	return variable === null || variable.defs.length === 0;
+}
+/** Reports whether a call target names one method on the global Reflect object. */
+function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
+	if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) return false;
+	if (!isGlobalReflect(sourceCode, callee.object)) return false;
+	const property = callee.property;
+	return callee.computed ? property.type === "Literal" && property.value === methodName : property.type === "Identifier" && property.name === methodName;
+}
+//#endregion
+//#region src/rules/no-reflect-apply.ts
+/** Ban Reflect.apply, which bypasses ordinary typed function calls. */
+const noReflectApplyRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow Reflect.apply; call typed functions directly or model dynamic dispatch behind an interface." },
+		messages: { reflectApply: "Replace `Reflect.apply` with a typed function call. Model dynamic dispatch behind a named interface." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+			if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "apply")) context.report({
+				node,
+				messageId: "reflectApply"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-reflect-get.ts
+/** Ban Reflect.get, which bypasses ordinary property access and useful type evidence. */
+const noReflectGetRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow Reflect.get; use typed property access or parse dynamic input into a domain type." },
+		messages: { reflectGet: "Replace `Reflect.get` with typed property access. Parse dynamic input into a named domain type before reading it." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
+			if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "get")) context.report({
+				node,
+				messageId: "reflectGet"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-runtime-typeof.ts
+function isRuntimeFunction(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+function isInsideTypeGuard(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (isRuntimeFunction(current)) return current.returnType?.typeAnnotation.type === "TSTypePredicate";
+		current = current.parent;
+	}
+	return false;
+}
+/** Disallow runtime typeof checks that narrow unparsed values instead of decoding them. */
+const noRuntimeTypeofRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow runtime typeof checks; external values must be decoded into meaningful types at their I/O boundary." },
+		messages: { runtimeTypeof: "A `typeof` check narrows a representation without establishing its contract. Parse input at its I/O boundary, then branch on the domain value." },
+		schema: [{
+			type: "object",
+			properties: { allowInTypeGuards: { type: "boolean" } },
+			additionalProperties: false
+		}],
+		defaultOptions: [{ allowInTypeGuards: false }]
+	},
+	createOnce(context) {
+		return { UnaryExpression(node) {
+			const option = context.options?.[0];
+			const allowInTypeGuards = typeof option === "object" && option !== null && !Array.isArray(option) && option.allowInTypeGuards === true;
+			if (node.operator === "typeof" && (!allowInTypeGuards || !isInsideTypeGuard(node))) context.report({
+				node,
+				messageId: "runtimeTypeof"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-test-imports.ts
+/** Keep test dependencies out of a package's production source tree. */
+const noTestImportsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow production source imports of tests, test helpers, and fixtures." },
+		schema: [],
+		messages: { testImport: "Production source cannot import test code or resources. Move shared production code into src/." }
+	},
+	create(context) {
+		const filename = physicalPath(context.filename);
+		const owner = packageOwner(filename);
+		if (!owner || !packagePath(owner, filename).startsWith("src/")) return {};
+		const resolution = importResolution();
+		return importSources(() => context.sourceCode, (node, specifier) => {
+			const target = resolution.target(filename, specifier);
+			if (!target) return;
+			const destination = packageOwner(target);
+			if (destination && isTestPath(packagePath(destination, target))) context.report({
+				node,
+				messageId: "testImport"
+			});
+		});
+	}
+});
+//#endregion
+//#region src/rules/no-type-assertions.ts
+function isConstAssertion(node) {
+	return node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const";
+}
+function isNestedAssertion(node) {
+	return node.parent.type === "TSAsExpression" || node.parent.type === "TSTypeAssertion";
+}
+/** Reject non-const type assertions instead of allowing a comment-based escape hatch. */
+const noTypeAssertionsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Reject non-const type assertions; decode unknown input or preserve the type inferred by a typed API." },
+		messages: { typeAssertion: "Type assertions are forbidden. Decode unknown input with Schema, or preserve the type inferred by Effect SQL, Drizzle, or another typed API." }
+	},
+	createOnce(context) {
+		const checkAssertion = (node) => {
+			if (isConstAssertion(node) || isNestedAssertion(node)) return;
+			context.report({
+				node,
+				messageId: "typeAssertion"
+			});
+		};
+		return {
+			TSAsExpression: checkAssertion,
+			TSTypeAssertion: checkAssertion
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-unknown-returns.ts
+function referencedAliasName$1(type) {
+	if (type.type === "TSParenthesizedType") return referencedAliasName$1(type.typeAnnotation);
+	if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier") return null;
+	return type.typeArguments === null || type.typeArguments === void 0 || type.typeArguments.params.length === 0 ? type.typeName.name : null;
+}
+function isConditionalTypeConstraint(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (current.type === "TSConditionalType") return current.extendsType === node;
+		current = current.parent;
+	}
+	return false;
+}
+/** Ban function contracts that return unknown instead of a parsed domain type. */
+const noUnknownReturnsRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow functions whose explicit return contract is unknown or Promise<unknown>." },
+		messages: { unknownReturn: "This function exposes `unknown` to its caller. Parse the value at its boundary and return a named domain type." }
+	},
+	createOnce(context) {
+		const aliases = /* @__PURE__ */ new Map();
+		const resolvesToUnknown = (type, shadowedAliases, visited = /* @__PURE__ */ new Set()) => {
+			if (type.type === "TSUnknownKeyword") return true;
+			if (type.type === "TSParenthesizedType") return resolvesToUnknown(type.typeAnnotation, shadowedAliases, visited);
+			if (type.type === "TSUnionType") return type.types.some((member) => resolvesToUnknown(member, shadowedAliases, visited));
+			if (type.type === "TSTypeReference" && type.typeName.type === "Identifier" && (type.typeName.name === "Promise" || type.typeName.name === "PromiseLike")) {
+				const value = type.typeArguments?.params[0];
+				return value !== void 0 && resolvesToUnknown(value, shadowedAliases, visited);
+			}
+			const name = referencedAliasName$1(type);
+			if (name === null || visited.has(name) || shadowedAliases.has(name)) return false;
+			const alias = aliases.get(name);
+			if (alias === void 0 || alias.typeParameters !== null && alias.typeParameters !== void 0) return false;
+			const nextVisited = new Set(visited);
+			nextVisited.add(name);
+			return resolvesToUnknown(alias.typeAnnotation, shadowedAliases, nextVisited);
+		};
+		const checkReturnType = (node) => {
+			if (isConditionalTypeConstraint(node)) return;
+			const annotation = node.returnType;
+			if (annotation === null || annotation === void 0) return;
+			if (!resolvesToUnknown(annotation.typeAnnotation, lexicalTypeParameterNames(node, context.sourceCode.visitorKeys))) return;
+			context.report({
+				node: annotation.typeAnnotation,
+				messageId: "unknownReturn"
+			});
+		};
+		return {
+			Program(node) {
+				aliases.clear();
+				for (const statement of node.body) {
+					const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+					if (declaration?.type === "TSTypeAliasDeclaration") aliases.set(declaration.id.name, declaration);
+				}
+			},
+			ArrowFunctionExpression: checkReturnType,
+			FunctionDeclaration: checkReturnType,
+			FunctionExpression: checkReturnType,
+			TSCallSignatureDeclaration: checkReturnType,
+			TSConstructSignatureDeclaration: checkReturnType,
+			TSConstructorType: checkReturnType,
+			TSDeclareFunction: checkReturnType,
+			TSEmptyBodyFunctionExpression: checkReturnType,
+			TSFunctionType: checkReturnType,
+			TSMethodSignature: checkReturnType
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-unknown-type-aliases.ts
+function referencedAliasName(type) {
+	if (type.type === "TSParenthesizedType") return referencedAliasName(type.typeAnnotation);
+	if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier") return null;
+	return type.typeArguments === null || type.typeArguments === void 0 || type.typeArguments.params.length === 0 ? type.typeName.name : null;
+}
+/** Ban named aliases that merely conceal TypeScript's unknown top type. */
+const noUnknownTypeAliasesRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow type aliases whose resolved type is unknown; unknown must remain visible at an allowed boundary." },
+		messages: { unknownAlias: "Type alias `{{alias}}` hides `unknown`. Keep `unknown` explicit at the parsing boundary or on an allowed `cause` field; otherwise use the parsed owner type." }
+	},
+	createOnce(context) {
+		const aliases = /* @__PURE__ */ new Map();
+		const resolvesToUnknown = (type, visited = /* @__PURE__ */ new Set()) => {
+			if (type.type === "TSUnknownKeyword") return true;
+			if (type.type === "TSParenthesizedType") return resolvesToUnknown(type.typeAnnotation, visited);
+			const name = referencedAliasName(type);
+			if (name === null || visited.has(name)) return false;
+			const alias = aliases.get(name);
+			if (alias === void 0 || alias.typeParameters !== null && alias.typeParameters !== void 0) return false;
+			const nextVisited = new Set(visited);
+			nextVisited.add(name);
+			return resolvesToUnknown(alias.typeAnnotation, nextVisited);
+		};
+		return { Program(node) {
+			aliases.clear();
+			for (const statement of node.body) {
+				const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+				if (declaration?.type === "TSTypeAliasDeclaration") aliases.set(declaration.id.name, declaration);
+			}
+			for (const alias of aliases.values()) {
+				if (!resolvesToUnknown(alias.typeAnnotation, /* @__PURE__ */ new Set([alias.id.name]))) continue;
+				context.report({
+					node: alias.id,
+					messageId: "unknownAlias",
+					data: { alias: alias.id.name }
+				});
+			}
+		} };
+	}
+});
+//#endregion
+//#region src/rules/no-unsafe-dictionary-type.ts
+const typeNodeKinds = /* @__PURE__ */ new Set([
+	"JSDocNonNullableType",
+	"JSDocNullableType",
+	"JSDocUnknownType",
+	"TSAnyKeyword",
+	"TSArrayType",
+	"TSBigIntKeyword",
+	"TSBooleanKeyword",
+	"TSConditionalType",
+	"TSConstructorType",
+	"TSFunctionType",
+	"TSImportType",
+	"TSIndexedAccessType",
+	"TSInferType",
+	"TSIntersectionType",
+	"TSIntrinsicKeyword",
+	"TSLiteralType",
+	"TSMappedType",
+	"TSNamedTupleMember",
+	"TSNeverKeyword",
+	"TSNullKeyword",
+	"TSNumberKeyword",
+	"TSObjectKeyword",
+	"TSParenthesizedType",
+	"TSStringKeyword",
+	"TSSymbolKeyword",
+	"TSTemplateLiteralType",
+	"TSThisType",
+	"TSTupleType",
+	"TSTypeLiteral",
+	"TSTypeOperator",
+	"TSTypePredicate",
+	"TSTypeQuery",
+	"TSTypeReference",
+	"TSUndefinedKeyword",
+	"TSUnionType",
+	"TSUnknownKeyword",
+	"TSVoidKeyword"
+]);
+function isTypeNode(node) {
+	return typeNodeKinds.has(node.type);
+}
+function typeReferenceName(type) {
+	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isInsideTypeAliasDeclaration(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (current.type === "TSTypeAliasDeclaration") return true;
+		current = current.parent;
+	}
+	return false;
+}
+function isGenericConstraint(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (current.type === "TSTypeParameter") return current.constraint === node;
+		current = current.parent;
+	}
+	return false;
+}
+function isPlainAliasConsumerUse(node, environment) {
+	if (node.type !== "TSTypeReference" || node.typeArguments?.params.length) return false;
+	const name = typeReferenceName(node);
+	return name !== null && environment.aliases.has(name) && !isInsideTypeAliasDeclaration(node);
+}
+function shouldReportType(node, environment) {
+	if (isGenericConstraint(node)) return false;
+	if (isPlainAliasConsumerUse(node, environment)) return false;
+	if (classifyUnsafeDictionary(node, environment) === null) return false;
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (isTypeNode(current) && classifyUnsafeDictionary(current, environment) !== null) return false;
+		current = current.parent;
+	}
+	return true;
+}
+/** Disallow object-dictionary contracts whose direct value type is an unsafe escape hatch. */
+const noUnsafeDictionaryTypeRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow object-dictionary contracts whose direct value type is unknown, any, object, {}, or a union/alias containing one of those escape hatches." },
+		messages: { unsafeDictionary: "This dictionary's {{value}} value type gives callers no concrete value contract. Use an owner/schema-derived value type; parse external payloads before insertion." }
+	},
+	createOnce(context) {
+		let environment = null;
+		const report = (node, value) => {
+			context.report({
+				node,
+				messageId: "unsafeDictionary",
+				data: { value }
+			});
+		};
+		const reportIfUnsafe = (node) => {
+			if (environment === null || !shouldReportType(node, environment)) return;
+			const unsafe = classifyUnsafeDictionary(node, environment);
+			if (unsafe === null) return;
+			report(node, unsafe.unsafeValue);
+		};
+		return {
+			Program(node) {
+				environment = createTypeEnvironment(node);
+			},
+			TSTypeReference: reportIfUnsafe,
+			TSTypeLiteral: reportIfUnsafe,
+			TSMappedType: reportIfUnsafe,
+			TSIndexSignature(node) {
+				if (environment === null || node.typeAnnotation === null || node.parent.type === "TSTypeLiteral") return;
+				const unsafe = classifyUnsafeDictionaryValue(node.typeAnnotation.typeAnnotation, environment);
+				if (unsafe !== null) report(node, unsafe.unsafeValue);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/require-public-jsdoc.ts
+const standardHeadings = [
+	"**When to use**",
+	"**Details**",
+	"**Gotchas**"
+];
+const whenToUsePrefixes = [
+	"Use to",
+	"Use when",
+	"Use as",
+	"Use with"
+];
+const stableSemver = /^\d+\.\d+\.\d+$/u;
+const tagOrder = /* @__PURE__ */ new Map([
+	["deprecated", 0],
+	["see", 1],
+	["category", 2],
+	["since", 3]
+]);
+function diagnostic(code, message) {
+	return {
+		code,
+		message
+	};
+}
+function normalizeJSDoc(comment) {
+	const lines = comment.value.slice(1).split(/\r\n|\r|\n/u).map((line) => line.replace(/^\s*\* ?/u, "").trimEnd());
+	let start = 0;
+	let end = lines.length;
+	if (lines[start]?.trim() === "") start++;
+	if (end > start && lines[end - 1]?.trim() === "") end--;
+	return lines.slice(start, end);
+}
+function parseTags(lines) {
+	const tags = [];
+	let current;
+	let inFence = false;
+	for (const [line, source] of lines.entries()) {
+		const trimmed = source.trim();
+		if (trimmed.startsWith("```")) {
+			inFence = !inFence;
+			current = void 0;
+			continue;
+		}
+		if (inFence) continue;
+		const match = /^@([A-Za-z][\w-]*)(?:\s+(.*))?$/u.exec(trimmed);
+		if (match !== null) {
+			current = {
+				line,
+				name: match[1] ?? "",
+				value: match[2]?.trim() ?? ""
+			};
+			tags.push(current);
+			continue;
+		}
+		if (current !== void 0 && trimmed !== "") current.value = current.value === "" ? trimmed : `${current.value}\n${trimmed}`;
+		else if (trimmed === "") current = void 0;
+	}
+	return tags;
+}
+function isForbiddenMarkdownHeading(line) {
+	return /^#{1,6}\s+/u.test(line.trim());
+}
+function isBoldOnlyLine(line) {
+	return /^\*\*[^*]+\*\*\s*$/u.test(line);
+}
+function isNearMissHeading(line) {
+	return /^\*\*(When to use|When To Use|Details|Gotchas).*\*\*/u.test(line) && !standardHeadings.includes(line);
+}
+function isHeadingLine(line) {
+	if (line === void 0) return false;
+	const trimmed = line.trim();
+	return standardHeadings.includes(trimmed) || trimmed.startsWith("**Example**") || isNearMissHeading(trimmed) || isBoldOnlyLine(trimmed) || isForbiddenMarkdownHeading(trimmed);
+}
+function joinBody(lines) {
+	let start = 0;
+	let end = lines.length;
+	while (start < end && lines[start]?.trim() === "") start++;
+	while (end > start && lines[end - 1]?.trim() === "") end--;
+	return lines.slice(start, end).join("\n");
+}
+function validateSection(lines, headingIndex) {
+	const diagnostics = [];
+	const heading = lines[headingIndex]?.trim() ?? "section";
+	if (lines[headingIndex + 1]?.trim() !== "") diagnostics.push(diagnostic("invalid-spacing", `${heading} must be followed by exactly one blank line`));
+	let index = headingIndex + 2;
+	const bodyStart = index;
+	let inFence = false;
+	while (index < lines.length) {
+		const trimmed = lines[index]?.trim() ?? "";
+		if (trimmed.startsWith("```")) {
+			if (/^```ts(?:\s.*)?$/u.test(trimmed)) diagnostics.push(diagnostic("loose-ts-fence", "TypeScript examples must use **Example** (Title) sections"));
+			inFence = !inFence;
+		}
+		if (!inFence && trimmed === "" && isHeadingLine(lines[index + 1])) break;
+		if (!inFence && isForbiddenMarkdownHeading(trimmed)) diagnostics.push(diagnostic("invalid-heading", "Markdown headings are not allowed in JSDoc descriptions"));
+		if (!inFence && isBoldOnlyLine(trimmed) && !standardHeadings.includes(trimmed) && !trimmed.startsWith("**Example**")) diagnostics.push(diagnostic("unknown-heading", `Unknown JSDoc section heading: ${trimmed}`));
+		index++;
+	}
+	const bodyLines = lines.slice(bodyStart, index);
+	if (joinBody(bodyLines).trim() === "") diagnostics.push(diagnostic("empty-section", `${heading} must have a non-empty body`));
+	if (bodyLines.at(-1)?.trim() === "") diagnostics.push(diagnostic("invalid-spacing", "Section bodies must not end with extra blank lines"));
+	return {
+		body: joinBody(bodyLines),
+		diagnostics,
+		nextIndex: index
+	};
+}
+function validateExample(lines, headingIndex) {
+	const diagnostics = [];
+	const heading = lines[headingIndex]?.trim() ?? "";
+	const match = /^\*\*Example\*\* \((.+)\)$/u.exec(heading);
+	if (match === null || match[1]?.trim() === "") diagnostics.push(diagnostic("malformed-example", "TypeScript examples must use **Example** (Title)"));
+	if (lines[headingIndex + 1]?.trim() !== "") diagnostics.push(diagnostic("invalid-spacing", "Example headings must be followed by exactly one blank line"));
+	let index = headingIndex + 2;
+	const bodyStart = index;
+	let fenceIndex = -1;
+	while (index < lines.length) {
+		const trimmed = lines[index]?.trim() ?? "";
+		if (/^```ts(?:\s.*)?$/u.test(trimmed)) {
+			fenceIndex = index;
+			break;
+		}
+		if (trimmed.startsWith("```")) diagnostics.push(diagnostic("malformed-example", "Examples may only contain one TypeScript code fence"));
+		if (trimmed === "" && isHeadingLine(lines[index + 1]) || trimmed.startsWith("@")) break;
+		index++;
+	}
+	if (fenceIndex === -1) {
+		diagnostics.push(diagnostic("malformed-example", "Examples must include a non-empty ```ts fence"));
+		return {
+			diagnostics,
+			nextIndex: index
+		};
+	}
+	const bodyLines = lines.slice(bodyStart, fenceIndex);
+	if (joinBody(bodyLines).trim() !== "" && bodyLines.at(-1)?.trim() !== "") diagnostics.push(diagnostic("invalid-spacing", "Example prose must be separated from code by exactly one blank line"));
+	index = fenceIndex + 1;
+	const codeStart = index;
+	while (index < lines.length && lines[index]?.trim() !== "```") {
+		if (/^```ts(?:\s.*)?$/u.test(lines[index]?.trim() ?? "")) diagnostics.push(diagnostic("malformed-example", "Examples must contain exactly one TypeScript code fence"));
+		index++;
+	}
+	const codeLines = lines.slice(codeStart, index);
+	if (index >= lines.length) diagnostics.push(diagnostic("malformed-example", "Examples must close the TypeScript code fence"));
+	if (joinBody(codeLines).trim() === "") diagnostics.push(diagnostic("malformed-example", "Examples must include non-empty TypeScript code"));
+	index++;
+	if (index < lines.length && lines[index]?.trim() !== "" && !lines[index]?.trim().startsWith("@")) diagnostics.push(diagnostic("invalid-spacing", "Examples must be separated from following content by exactly one blank line"));
+	return {
+		diagnostics,
+		nextIndex: index,
+		...match?.[1] === void 0 ? {} : { title: match[1].trim() }
+	};
+}
+function validateDescription(lines) {
+	const diagnostics = [];
+	const seenSections = /* @__PURE__ */ new Set();
+	const exampleTitles = /* @__PURE__ */ new Set();
+	let index = 0;
+	let currentSectionOrder = -1;
+	let examplesStarted = false;
+	while (index < lines.length && lines[index]?.trim() !== "" && !isHeadingLine(lines[index])) {
+		if (isForbiddenMarkdownHeading(lines[index] ?? "")) diagnostics.push(diagnostic("invalid-heading", "Markdown headings are not allowed in JSDoc descriptions"));
+		index++;
+	}
+	const shortLines = lines.slice(0, index);
+	if (shortLines.length === 0 || joinBody(shortLines).trim() === "") diagnostics.push(diagnostic("missing-description", "JSDoc must include a short description"));
+	if (index < lines.length && lines[index]?.trim() === "") {
+		const next = lines[index + 1];
+		if (next !== void 0 && !isHeadingLine(next)) diagnostics.push(diagnostic("multiple-description-paragraphs", "JSDoc short description must be one paragraph"));
+	}
+	while (index < lines.length) {
+		if (lines[index]?.trim() !== "") {
+			diagnostics.push(diagnostic("invalid-spacing", "JSDoc sections must be separated by exactly one blank line"));
+			break;
+		}
+		if (lines[index + 1]?.trim() === "") {
+			diagnostics.push(diagnostic("invalid-spacing", "JSDoc sections must be separated by exactly one blank line"));
+			while (lines[index + 1]?.trim() === "") index++;
+		}
+		index++;
+		if (index >= lines.length) break;
+		const line = lines[index]?.trim() ?? "";
+		if (line.startsWith("**Example**")) {
+			examplesStarted = true;
+			const result = validateExample(lines, index);
+			diagnostics.push(...result.diagnostics);
+			if (result.title !== void 0) {
+				const key = result.title.toLowerCase();
+				if (exampleTitles.has(key)) diagnostics.push(diagnostic("duplicate-example", `Duplicate example title: ${result.title}`));
+				exampleTitles.add(key);
+			}
+			index = result.nextIndex;
+			continue;
+		}
+		const sectionOrder = standardHeadings.indexOf(line);
+		if (sectionOrder >= 0) {
+			if (examplesStarted) diagnostics.push(diagnostic("section-after-example", `${line} must appear before examples`));
+			if (sectionOrder <= currentSectionOrder || seenSections.has(line)) diagnostics.push(diagnostic("section-out-of-order", `${line} is out of order or duplicated`));
+			currentSectionOrder = Math.max(currentSectionOrder, sectionOrder);
+			seenSections.add(line);
+			const result = validateSection(lines, index);
+			diagnostics.push(...result.diagnostics);
+			if (line === "**When to use**" && !whenToUsePrefixes.some((prefix) => result.body.trimStart() === prefix || result.body.trimStart().startsWith(`${prefix} `))) diagnostics.push(diagnostic("when-to-use-format", "**When to use** must start with `Use to`, `Use when`, `Use as`, or `Use with`"));
+			index = result.nextIndex;
+			continue;
+		}
+		if (isNearMissHeading(line) || isForbiddenMarkdownHeading(line)) diagnostics.push(diagnostic("invalid-heading", `Invalid JSDoc section heading: ${line}`));
+		else if (isBoldOnlyLine(line)) diagnostics.push(diagnostic("unknown-heading", `Unknown JSDoc section heading: ${line}`));
+		else diagnostics.push(diagnostic("invalid-description", "JSDoc description content must appear under a standard section heading"));
+		index++;
+	}
+	return diagnostics;
+}
+function validateTags(tags) {
+	const diagnostics = [];
+	const values = /* @__PURE__ */ new Map();
+	let previousOrder = -1;
+	for (const tag of tags) {
+		if (tag.name === "internal") continue;
+		if (tag.name === "example") {
+			diagnostics.push(diagnostic("forbidden-tag", "@example is not allowed; use a canonical **Example** (Title) section"));
+			continue;
+		}
+		const order = tagOrder.get(tag.name);
+		if (order === void 0) {
+			diagnostics.push(diagnostic("forbidden-tag", `@${tag.name} is not allowed in public declaration JSDoc`));
+			continue;
+		}
+		if (order < previousOrder) diagnostics.push(diagnostic("tag-out-of-order", `@${tag.name} is out of order in JSDoc`));
+		previousOrder = Math.max(previousOrder, order);
+		values.set(tag.name, [...values.get(tag.name) ?? [], tag.value.trim()]);
+	}
+	for (const tag of [
+		"deprecated",
+		"category",
+		"since"
+	]) if ((values.get(tag)?.length ?? 0) > 1) diagnostics.push(diagnostic("duplicate-tag", `JSDoc blocks may contain at most one @${tag} tag`));
+	for (const value of values.get("see") ?? []) if (value === "") diagnostics.push(diagnostic("empty-tag", "@see must include a value"));
+	if (values.get("deprecated")?.[0] === "") diagnostics.push(diagnostic("empty-tag", "@deprecated must include a message"));
+	const category = values.get("category")?.[0];
+	if (category === void 0) diagnostics.push(diagnostic("missing-tag", "Public JSDoc must include @category"));
+	else if (category === "") diagnostics.push(diagnostic("empty-tag", "@category must include a value"));
+	const since = values.get("since")?.[0];
+	if (since === void 0) diagnostics.push(diagnostic("missing-tag", "Public JSDoc must include @since"));
+	else if (!stableSemver.test(since)) diagnostics.push(diagnostic("invalid-since", "@since must be a stable semver version like 1.2.3"));
+	return diagnostics;
+}
+function validateJSDoc(comment) {
+	const lines = normalizeJSDoc(comment);
+	const tags = parseTags(lines);
+	if (tags.some((tag) => tag.name === "internal")) return [];
+	const diagnostics = [];
+	const firstTagLine = tags[0]?.line ?? lines.length;
+	const content = lines.slice(0, firstTagLine);
+	if (lines.length === 0) diagnostics.push(diagnostic("missing-description", "JSDoc must include a short description"));
+	if (tags.length > 0) {
+		if (content.at(-1)?.trim() !== "" || content.length < 2 || content[content.length - 2]?.trim() === "") diagnostics.push(diagnostic("invalid-spacing", "JSDoc tags must be separated from description content by exactly one blank line"));
+	}
+	if (content[0]?.trim() === "") diagnostics.push(diagnostic("leading-blank", "JSDoc must not start with a blank line"));
+	const description = tags.length > 0 && content.at(-1)?.trim() === "" ? content.slice(0, -1) : content;
+	if (description.at(-1)?.trim() === "") diagnostics.push(diagnostic("trailing-blank", "JSDoc description must not end with a blank line"));
+	diagnostics.push(...validateDescription(description), ...validateTags(tags));
+	const seen = /* @__PURE__ */ new Set();
+	return diagnostics.filter((item) => {
+		const key = `${item.code}:${item.message}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function getJSDoc(sourceCode, node) {
+	const comment = sourceCode.getCommentsBefore(node).at(-1);
+	return comment?.type === "Block" && comment.value.startsWith("*") ? comment : void 0;
+}
+/** Require exported declarations to use the public JSDoc format enforced by Effect. */
+const requirePublicJSDocRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require exported declarations to use Effect-style public API JSDoc with canonical sections and tags." },
+		messages: {
+			invalidJSDoc: "{{message}}",
+			missingJSDoc: "Public declarations require Effect-style JSDoc with a description, @category, and @since."
+		}
+	},
+	createOnce(context) {
+		const checkedFunctionOverloads = /* @__PURE__ */ new Set();
+		const check = (node) => {
+			const comment = getJSDoc(context.sourceCode, node);
+			if (comment === void 0) {
+				context.report({
+					node,
+					messageId: "missingJSDoc"
+				});
+				return;
+			}
+			for (const item of validateJSDoc(comment)) context.report({
+				node,
+				messageId: "invalidJSDoc",
+				data: { message: item.message }
+			});
+		};
+		return { ExportNamedDeclaration(node) {
+			const declaration = node.declaration;
+			if (declaration !== null && "params" in declaration && declaration.id?.type === "Identifier") {
+				if (checkedFunctionOverloads.has(declaration.id.name)) return;
+				checkedFunctionOverloads.add(declaration.id.name);
+			}
+			if (node.declaration !== null) {
+				check(node);
+				return;
+			}
+			for (const specifier of node.specifiers) check(specifier);
+		} };
+	}
+});
+//#endregion
+//#region src/rules/require-test-location.ts
+/** Place named test files under the owning package's sibling test directory. */
+const requireTestLocationRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require .test filenames under the nearest package's test/ directory." },
+		schema: [],
+		messages: { location: "Place this test under its package's test/ directory, alongside src/, using a .test filename." }
+	},
+	createOnce(context) {
+		return { Program(node) {
+			if (!isTestFile(context.filename)) return;
+			const owner = packageOwner(context.filename);
+			if (!owner) return;
+			const path = packagePath(owner, context.filename);
+			if (!path.startsWith("test/") || /\.spec\.(?:[cm]?[jt]s|[jt]sx)$/u.test(path)) context.report({
+				node,
+				messageId: "location"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/index.ts
+/** Strict Oxlint rules for preserving type evidence and explicit Effect architecture. */
+const nopeusPlugin = eslintCompatPlugin({
+	meta: { name: "nopeus" },
+	rules: {
+		"no-export-assignment": noExportAssignmentRule,
+		"no-cross-package-internals": noCrossPackageInternalsRule,
+		"no-test-imports": noTestImportsRule,
+		"require-test-location": requireTestLocationRule,
+		"no-effect-runners-in-library": noEffectRunnersInLibraryRule,
+		"no-fallible-effect-promise": noFallibleEffectPromiseRule,
+		"no-inline-live-layer": noInlineLiveLayerRule,
+		"no-module-level-mutable-state": noModuleLevelMutableStateRule,
+		"require-fetch-abort-signal": requireFetchAbortSignalRule,
+		"no-unscoped-fork": noUnscopedForkRule,
+		"no-untyped-effect-errors": noUntypedEffectErrorsRule,
+		"no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
+		"no-known-value-widening": noKnownValueWideningRule,
+		"no-module-mocking": noModuleMockingRule,
+		"no-object-parameters": noObjectParametersRule,
+		"no-reflect-apply": noReflectApplyRule,
+		"no-reflect-get": noReflectGetRule,
+		"no-runtime-typeof": noRuntimeTypeofRule,
+		"no-type-assertions": noTypeAssertionsRule,
+		"no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+		"no-unknown-returns": noUnknownReturnsRule,
+		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
+		"prefer-effect-platform-services": preferEffectPlatformServicesRule,
+		"prefer-effect-void": preferEffectVoidRule,
+		"require-public-jsdoc": requirePublicJSDocRule,
+		"require-effect-fn-name": requireEffectFnNameRule,
+		"require-effect-namespace": requireEffectNamespaceRule,
+		"require-service-key-prefix": requireServiceKeyPrefixRule,
+		"require-service-constructor-names": requireServiceConstructorNamesRule
+	}
+});
+//#endregion
+export { nopeusPlugin as default };
+
+//# sourceMappingURL=index.mjs.map