@deslop/coding-standards 0.1.1083 → 0.1.1085

package/dist/oxlint.js

@@ -1,4 +1,4 @@
-import { A as dedupeWith, At as flatMap, B as flatMap$1, Bt as match, C as TaggedError, D as contains$1, Dt as exists, E as appendAll, Er as isNotNullish, Et as contains, F as filter$1, Fr as isString, Ft as getOrUndefined, G as getSomes, Gt as zipWith, H as forEach, Hr as constVoid, Ht as orElse, I as filterMap, It as isNone, J as isArrayNonEmpty, Jr as pipe, K as head, L as findFirst, Lt as isSome, M as empty, Mt as fromNullishOr, N as ensure, Nr as isReadonlyObject, Nt as fromUndefinedOr, O as containsWith, Or as isNullish$1, Ot as filter, P as every, Pr as isRegExp, Pt as getOrElse, Q as last, R as findFirstIndex, T as append, Tr as isNotNull, Tt as all, Ut as some, V as flatten, Vt as none, W as get$1, Wr as dual, Wt as toArray$1, X as isReadonlyArrayNonEmpty, Xn as NodeInspectSymbol, Z as join, Zr as pipeArguments, _ as startsWith, _t as fromOption, b as parse, c as make$3, cr as equals, ct as take, d as Order, dr as combine, et as map$1, f as includes, fr as hash, g as split, h as replaceAll, hr as string, in as strictEqual, it as prepend, j as dropRight, jt as flatten$1, k as dedupe, kr as isNumber, kt as firstSomeOf, l as update, lr as symbol, lt as fromEntries, m as replace, mr as optimize, mt as values, nt as matchRight, o as toArray, ot as some$1, p as match$1, pr as number, pt as remove, q as isArrayEmpty, r as make$2, rt as of, s as get$3, sr as byReferenceUnsafe, st as sort, t as append$1, u as match$2, ut as get$2, v as trim, vr as symbol$1, xr as isBoolean, yr as hasProperty, zr as constFalse, zt as map } from "./MutableList-Cpkiw3Cl.mjs";
+import { $ as last, $r as pipeArguments, A as dedupe, Ar as isNullish$1, At as filter, Cr as isBoolean, D as appendAll, Dr as isNotNull, Dt as all, E as append, F as every, Fr as isReadonlyObject, Ft as fromUndefinedOr, G as get$1, Gt as some, H as flatten, Ht as match, I as filter$1, Ir as isRegExp, It as getOrElse, J as isArrayEmpty, K as getSomes, Kr as dual, Kt as toArray$1, L as filterMap, Lr as isString, Lt as getOrUndefined, M as dropRight, Mt as flatMap, N as empty, Nt as flatten$1, O as contains, Or as isNotNullish, Ot as contains$1, P as ensure, Pt as fromNullishOr, Q as join, Qn as NodeInspectSymbol, R as findFirst, Rt as isNone, U as forEach, Ut as none, V as flatMap$1, Vr as constFalse, Vt as map, Wr as constVoid, Wt as orElse, Xr as pipe, Y as isArrayNonEmpty, Z as isReadonlyArrayNonEmpty, _ as startsWith, _r as string, at as prepend, br as symbol$1, c as make$3, ct as sort, d as Order, dr as symbol, dt as fromEntries, f as includes, ft as get$2, g as split, gr as optimize, gt as values, h as replaceAll, hr as number, ht as remove, it as of, j as dedupeWith, jr as isNumber, jt as firstSomeOf, k as containsWith, kt as exists, l as update, lr as byReferenceUnsafe, lt as take, m as replace, mr as hash, o as toArray, on as strictEqual, p as match$1, pr as combine, q as head, qt as zipWith, r as make$2, rt as matchRight, s as get$3, st as some$1, t as append$1, tt as map$1, u as match$2, ur as equals, ut as takeWhile, v as toUpperCase, w as TaggedError, x as parse, xr as hasProperty, y as trim, yt as fromOption, z as findFirstIndex, zt as isSome } from "./MutableList-NTBI6AHW.mjs";
 //#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/graph.js
 /** @internal */
 const TypeId = "~effect/Graph";
@@ -633,6 +633,28 @@ function defineConfig(config) {
 }
 //#endregion
 //#region src/rules/shared.ts
+function inert(token) {
+	if (contains([
+		"Boolean",
+		"Identifier",
+		"Null",
+		"Numeric",
+		"String"
+	], token.type)) return true;
+	if (token.type === "Keyword") return contains([
+		"const",
+		"new",
+		"return"
+	], token.value);
+	return token.type === "Punctuator" && contains([
+		"(",
+		",",
+		":",
+		"=",
+		"[",
+		"{"
+	], token.value);
+}
 function variableFromScope(input) {
 	if (input.scope === null) return none();
 	const scope = input.scope;
@@ -690,7 +712,7 @@ function importedMember(input) {
 		importedName: input.importedName,
 		node: input.node.object,
 		source: "effect"
-	}) && (input.propertyName === void 0 || contains(memberName(input.node), input.propertyName));
+	}) && (input.propertyName === void 0 || contains$1(memberName(input.node), input.propertyName));
 }
 function matches(regExp) {
 	return (text) => isSome(pipe(text, match$1(regExp)));
@@ -711,7 +733,7 @@ function isReactUseState(input) {
 		node: input.node.callee,
 		source: "react"
 	});
-	return input.node.callee.type === "MemberExpression" && contains(memberName(input.node.callee), "useState") && input.node.callee.object.type === "Identifier" && isNamespaceImport({
+	return input.node.callee.type === "MemberExpression" && contains$1(memberName(input.node.callee), "useState") && input.node.callee.object.type === "Identifier" && isNamespaceImport({
 		context: input.context,
 		node: input.node.callee.object,
 		source: "react"
@@ -868,7 +890,7 @@ function schemaCycleNames(input) {
 		const indices = fromEntries(map$1(names, (name) => [name, addNode(mutable, name)]));
 		for (const edge of edges) for (const target of edge.targets) zipWith(get$2(indices, edge.name), get$2(indices, target), (source, sink) => addEdge(mutable, source, sink, "reads"));
 	});
-	return pipe(stronglyConnectedComponents(graph), map$1((component) => getSomes(map$1(component, (index) => getNode(graph, index)))), filter$1((component) => (component.length > 1 || some$1(edges, (edge) => contains$1(component, edge.name) && contains$1(edge.targets, edge.name))) && some$1(component, (name) => contains$1(seeds, name))), flatten);
+	return pipe(stronglyConnectedComponents(graph), map$1((component) => getSomes(map$1(component, (index) => getNode(graph, index)))), filter$1((component) => (component.length > 1 || some$1(edges, (edge) => contains(component, edge.name) && contains(edge.targets, edge.name))) && some$1(component, (name) => contains(seeds, name))), flatten);
 }
 function hasSingleStatementExpression(node) {
 	if (node.body === null) return false;
@@ -908,7 +930,7 @@ const explicitEffectConcurrency = defineRule({
 		})) return;
 		const name = memberName(node.callee);
 		if (!exists(name, (method) => method === "all" || method === "forEach")) return;
-		const index = match$2(contains(name, "all") || isFunction(node.arguments[0]) || node.arguments[1]?.type === "ObjectExpression", {
+		const index = match$2(contains$1(name, "all") || isFunction(node.arguments[0]) || node.arguments[1]?.type === "ObjectExpression", {
 			onFalse: () => 2,
 			onTrue: () => 1
 		});
@@ -921,6 +943,94 @@ const explicitEffectConcurrency = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/module-constant.ts
+const isConstantName = matches(/^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/u);
+function literal(node) {
+	if (node.type === "Literal") return node.value !== null;
+	if (node.type === "TemplateLiteral") return isArrayEmpty(node.expressions);
+	if (node.type === "UnaryExpression") return node.operator === "-" && literal(node.argument);
+	if (node.type === "BinaryExpression") return literal(node.left) && literal(node.right);
+	if (node.type === "ArrayExpression") return every(node.elements, (element) => element !== null && element.type !== "SpreadElement" && literal(element));
+	if (node.type === "ObjectExpression") return every(node.properties, (property) => property.type === "Property" && !property.computed && property.kind === "init" && literal(property.value));
+	return pipe(typeWrapped(node), exists(literal));
+}
+function literalConstant(statement) {
+	if (statement.type !== "VariableDeclaration" || statement.kind !== "const" || statement.declarations.length !== 1) return none();
+	const [node] = statement.declarations;
+	if (node?.id.type !== "Identifier" || node.init === null || !literal(node.init)) return none();
+	return some({
+		id: node.id,
+		node
+	});
+}
+function renamed(input) {
+	if (input.reference.identifier.parent.type === "Property" && input.reference.identifier.parent.shorthand) return input.fixer.replaceText(input.reference.identifier, `${input.reference.identifier.name}: ${input.name}`);
+	return input.fixer.replaceText(input.reference.identifier, input.name);
+}
+function primitive(node) {
+	if (node.type === "Literal") return !hasProperty(node, "regex");
+	return contains([
+		"BinaryExpression",
+		"TemplateLiteral",
+		"UnaryExpression"
+	], node.type) || pipe(typeWrapped(node), exists(primitive));
+}
+function check$2(input) {
+	if (input.found.id.typeAnnotation === null && input.found.node.init !== null && primitive(input.found.node.init) && filter$1(input.variable.references, (reference) => reference.isRead()).length === 1 && !pipe(input.context.sourceCode.getText(input.found.node), includes("\n"))) {
+		input.context.report({
+			message: "Inline this value at its only use.",
+			node: input.found.node
+		});
+		return;
+	}
+	if (!isConstantName(input.found.id.name)) {
+		const name = pipe(input.found.id.name, replaceAll(/(?<=[a-z0-9])(?=[A-Z])/gu, "_"), toUpperCase);
+		const taken = some$1([input.found.id, ...map$1(input.variable.references, (reference) => reference.identifier)], (node) => isSome(variableFromScope({
+			name,
+			scope: input.context.sourceCode.getScope(node)
+		})));
+		input.context.report({
+			fix: (fixer) => {
+				if (taken) return [];
+				return [fixer.replaceTextRange([input.found.id.range[0], input.found.id.range[0] + input.found.id.name.length], name), ...pipe(input.variable.references, filter$1((reference) => reference.identifier !== input.found.id), map$1((reference) => renamed({
+					fixer,
+					name,
+					reference
+				})))];
+			},
+			message: `Name this module constant ${name}.`,
+			node: input.found.node
+		});
+	}
+	if (!input.leading) input.context.report({
+		message: "Declare this module constant directly under the imports.",
+		node: input.found.node
+	});
+}
+const moduleConstant = defineRule({
+	create: (context) => ({ Program: (program) => {
+		const leading = takeWhile(program.body, (statement) => statement.type === "ImportDeclaration" || isSome(literalConstant(statement)));
+		for (const statement of program.body) pipe(literalConstant(statement), flatMap((found) => pipe(variableFromScope({
+			name: found.id.name,
+			scope: context.sourceCode.getScope(found.node)
+		}), filter((variable) => !some$1(variable.references, (reference) => reference.identifier.parent.type === "ExportSpecifier")), map((variable) => ({
+			found,
+			variable
+		})))), match({
+			onNone: constVoid,
+			onSome: (match) => check$2({
+				...match,
+				context,
+				leading: contains(leading, statement)
+			})
+		}));
+	} }),
+	meta: {
+		fixable: "code",
+		type: "suggestion"
+	}
+});
+//#endregion
 //#region src/rules/motion-limits.ts
 function utility(token) {
 	return pipe(token, split(":"), last, getOrElse(() => token), replace(/^!|!$/gu, ""));
@@ -931,7 +1041,7 @@ function amount(token, pattern) {
 function violation(token) {
 	if (exists(amount(token, /^duration-(\d+)$/u), (value) => value > 300)) return some("Keep a transition under 300 ms: duration-300 or less.");
 	if (matches(/^zoom-(?:in|out)$/u)(utility(token)) || exists(amount(token, /^zoom-(?:in|out)-(\d+)$/u), (value) => value < 90)) return some("Enter from 0.9 scale or more: zoom-in-90 or zoom-in-95.");
-	if (pipe(token, split(":"), dropRight(1), contains$1("starting")) && exists(amount(token, /^scale-(\d+)$/u), (value) => value < 90)) return some("Enter from 0.9 scale or more: starting:scale-90 or starting:scale-95.");
+	if (pipe(token, split(":"), dropRight(1), contains("starting")) && exists(amount(token, /^scale-(\d+)$/u), (value) => value < 90)) return some("Enter from 0.9 scale or more: starting:scale-90 or starting:scale-95.");
 	return none();
 }
 function check$1(context, node, text) {
@@ -954,7 +1064,7 @@ const motionLimits = defineRule({
 //#endregion
 //#region src/rules/no-array-wrap-ternary.ts
 function testedValue(node) {
-	if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression" || node.callee.object.type !== "Identifier" || node.callee.object.name !== "Array" || !contains(memberName(node.callee), "isArray") || node.arguments.length !== 1) return none();
+	if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression" || node.callee.object.type !== "Identifier" || node.callee.object.name !== "Array" || !contains$1(memberName(node.callee), "isArray") || node.arguments.length !== 1) return none();
 	const argument = node.arguments[0];
 	if (argument?.type !== "Identifier" && argument?.type !== "MemberExpression") return none();
 	return some(argument);
@@ -1105,7 +1215,7 @@ function isPipeCall(context, node) {
 	});
 }
 function enclosingPipes(context, node) {
-	if (node.type === "Program" || contains$1([
+	if (node.type === "Program" || contains([
 		"ArrowFunctionExpression",
 		"FunctionDeclaration",
 		"FunctionExpression"
@@ -1126,7 +1236,7 @@ const noDeepPipe = defineRule({
 //#endregion
 //#region src/rules/no-destructured-parameter.ts
 function namedTuple(input) {
-	if (contains$1(input.seen, input.node)) return false;
+	if (contains(input.seen, input.node)) return false;
 	if (input.node.type === "TSTupleType") return isArrayNonEmpty(input.node.elementTypes) && every(input.node.elementTypes, (element) => element.type === "TSNamedTupleMember");
 	if (input.node.type === "TSParenthesizedType" || input.node.type === "TSTypeOperator" && input.node.operator === "readonly") return namedTuple({
 		...input,
@@ -1200,6 +1310,9 @@ const noDestructuredParameter = defineRule({
 });
 //#endregion
 //#region src/rules/no-discarded-failure.ts
+function logged(node) {
+	return node.parent.type === "CallExpression" && node.parent.callee === node && some$1(node.parent.arguments, (argument) => argument.type === "ObjectExpression" && every(argument.properties, (property) => property.type === "Property") && some$1(argument.properties, (property) => !property.computed && (property.key.type === "Identifier" && property.key.name === "log" || property.key.type === "Literal" && property.key.value === "log") && property.value.type === "Literal" && (property.value.value === true || isString(property.value.value))));
+}
 const noDiscardedFailure = defineRule({
 	create: (context) => ({ MemberExpression: (node) => {
 		if (!importedMember({
@@ -1207,13 +1320,14 @@ const noDiscardedFailure = defineRule({
 			importedName: "Effect",
 			node
 		})) return;
-		if (!exists(memberName(node), (name) => contains$1([
+		if (!exists(memberName(node), (name) => contains([
 			"ignore",
 			"orDie",
 			"orDieWith"
 		], name))) return;
+		if (contains$1(memberName(node), "ignore") && logged(node)) return;
 		context.report({
-			message: "Map the failure to the service's error; an expected failure is never ignored or turned into a defect.",
+			message: "Map the failure to the service's error, or log best-effort work with Effect.ignore({log: 'Warn', message}); an expected failure is never dropped silently or turned into a defect.",
 			node
 		});
 	} }),
@@ -1221,12 +1335,7 @@ const noDiscardedFailure = defineRule({
 });
 //#endregion
 //#region src/rules/no-double-nullish-check.ts
-function nullishOperand(node) {
-	if (node.type === "Literal" && node.value === null) return some("null");
-	if (node.type === "Identifier" && node.name === "undefined") return some("undefined");
-	return none();
-}
-const variants = {
+const VARIANTS = {
 	"&&": {
 		comparison: "!==",
 		message: "Use Predicate.isNotNullish."
@@ -1236,6 +1345,11 @@ const variants = {
 		message: "Use Predicate.isNullish."
 	}
 };
+function nullishOperand(node) {
+	if (node.type === "Literal" && node.value === null) return some("null");
+	if (node.type === "Identifier" && node.name === "undefined") return some("undefined");
+	return none();
+}
 function operands(input) {
 	if (input.node.type !== "LogicalExpression" || input.node.operator !== input.operator) return [input.node];
 	return appendAll(operands({
@@ -1258,7 +1372,7 @@ const noDoubleNullishCheck = defineRule({
 	create: (context) => ({ LogicalExpression: (node) => {
 		if (node.operator === "??") return;
 		if (node.parent.type === "LogicalExpression" && node.parent.operator === node.operator) return;
-		const variant = variants[node.operator];
+		const variant = VARIANTS[node.operator];
 		const checks = pipe(operands({
 			node,
 			operator: node.operator
@@ -1312,7 +1426,7 @@ function calleeOf(node) {
 }
 function isEffectEmpty(input) {
 	const member = calleeOf(input.node);
-	return member.type === "MemberExpression" && member.object.type === "Identifier" && contains(memberName(member), "empty") && isImportBinding({
+	return member.type === "MemberExpression" && member.object.type === "Identifier" && contains$1(memberName(member), "empty") && isImportBinding({
 		context: input.context,
 		node: member.object,
 		source: "effect"
@@ -1386,13 +1500,13 @@ function receiverName(node) {
 	return memberName(node);
 }
 function isErrorMessage(node) {
-	return node?.type === "MemberExpression" && contains(memberName(node), "message") && exists(receiverName(node.object), matches(/^(?:e|err|error|failure|cause|exception)$|Error$/iu));
+	return node?.type === "MemberExpression" && contains$1(memberName(node), "message") && exists(receiverName(node.object), matches(/^(?:e|err|error|failure|cause|exception)$|Error$/iu));
 }
 function expectsErrorMessage(node) {
 	return node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "expect" && isErrorMessage(node.arguments[0]);
 }
 function expectsMessage(node) {
-	if (node.object.type === "MemberExpression" && contains(memberName(node.object), "not")) return expectsErrorMessage(node.object.object);
+	if (node.object.type === "MemberExpression" && contains$1(memberName(node.object), "not")) return expectsErrorMessage(node.object.object);
 	return expectsErrorMessage(node.object);
 }
 function assertsMessage(node) {
@@ -1408,7 +1522,7 @@ const noErrorMessageAssertion = defineRule({
 			});
 			return;
 		}
-		if (node.callee.type === "MemberExpression" && (node.arguments[0]?.type === "Literal" || node.arguments[0]?.type === "TemplateLiteral") && (exists(memberName(node.callee), (name) => contains$1(["toThrow", "toThrowError"], name)) || expectsMessage(node.callee))) context.report({
+		if (node.callee.type === "MemberExpression" && (node.arguments[0]?.type === "Literal" || node.arguments[0]?.type === "TemplateLiteral") && (exists(memberName(node.callee), (name) => contains(["toThrow", "toThrowError"], name)) || expectsMessage(node.callee))) context.report({
 			message: "Assert the failure, never its message wording.",
 			node
 		});
@@ -1434,7 +1548,7 @@ function hasUnusedSetter(input) {
 }
 function isFakeRefState(input) {
 	if (!isReactUseState(input) || input.node.arguments[0]?.type !== "ArrowFunctionExpression" || input.node.arguments[0].body.type !== "ObjectExpression" || input.node.arguments[0].body.properties.length !== 1 || !hasUnusedSetter(input)) return false;
-	return some$1(input.node.arguments[0].body.properties, (property) => property.type === "Property" && contains(propertyName(property), "current") && property.value.type === "Literal" && property.value.value === null);
+	return some$1(input.node.arguments[0].body.properties, (property) => property.type === "Property" && contains$1(propertyName(property), "current") && property.value.type === "Literal" && property.value.value === null);
 }
 const noFakeRefState = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
@@ -1449,8 +1563,31 @@ const noFakeRefState = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-floating-derived-type.ts
+function derived(node) {
+	if (node.type === "TSIndexedAccessType") return derived(node.objectType);
+	return node.type === "TSTypeReference" && node.typeName.type === "Identifier" && contains([
+		"Awaited",
+		"ConstructorParameters",
+		"InstanceType",
+		"Parameters",
+		"ReturnType"
+	], node.typeName.name);
+}
+const noFloatingDerivedType = defineRule({
+	create: (context) => ({ TSTypeAliasDeclaration: (node) => {
+		const listed = some$1(context.sourceCode.ast.body, (statement) => statement.type === "ExportNamedDeclaration" && some$1(statement.specifiers, (specifier) => specifier.local.type === "Identifier" && specifier.local.name === node.id.name));
+		if (node.parent.type === "ExportNamedDeclaration" || listed || !derived(node.typeAnnotation)) return;
+		context.report({
+			message: "Import the library's own type, or pass the value straight to the call that types it.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/no-gradient.ts
-const gradient = /(?:^|[\s:])bg-(?:linear|radial|conic|gradient)(?:-|$|\s)|gradient\(/u;
+const GRADIENT = /(?:^|[\s:])bg-(?:linear|radial|conic|gradient)(?:-|$|\s)|gradient\(/u;
 function report$4(context, node) {
 	context.report({
 		message: "Use a flat theme color; gradients are never part of the design.",
@@ -1460,10 +1597,10 @@ function report$4(context, node) {
 const noGradient = defineRule({
 	create: (context) => ({
 		Literal: (node) => {
-			if (isString(node.value) && gradient.test(node.value)) report$4(context, node);
+			if (isString(node.value) && GRADIENT.test(node.value)) report$4(context, node);
 		},
 		TemplateElement: (node) => {
-			if (gradient.test(node.value.raw)) report$4(context, node);
+			if (GRADIENT.test(node.value.raw)) report$4(context, node);
 		}
 	}),
 	meta: { type: "problem" }
@@ -1497,7 +1634,7 @@ function check(input) {
 	if (input.node.type === "UnaryExpression" && input.node.operator === "!" && input.node.argument.type === "CallExpression" && input.node.argument.callee.type === "MemberExpression" && isSubject({
 		name: "Array",
 		node: input.node.argument.callee.object
-	}) && contains(memberName(input.node.argument.callee), "isArray") && input.node.argument.arguments.length === 1 && every(input.node.argument.arguments, (argument) => isSubject({
+	}) && contains$1(memberName(input.node.argument.callee), "isArray") && input.node.argument.arguments.length === 1 && every(input.node.argument.arguments, (argument) => isSubject({
 		name: input.name,
 		node: argument
 	}))) return some(["!Array.isArray"]);
@@ -1525,7 +1662,7 @@ function report$3(input) {
 	const predicate = input.node.returnType?.typeAnnotation;
 	const returned = returnedExpression(input.node);
 	if (predicate?.type !== "TSTypePredicate" || predicate.asserts || predicate.parameterName.type !== "Identifier" || isNullish$1(returned)) return;
-	const name = pipe(check({
+	map(pipe(check({
 		name: predicate.parameterName.name,
 		node: returned
 	}), map((checks) => pipe(checks, sort(Order), join(" && "))), flatMap((key) => get$2({
@@ -1550,8 +1687,7 @@ function report$3(input) {
 		"typeof === string": "isString",
 		"typeof === symbol": "isSymbol",
 		"typeof === undefined": "isUndefined"
-	}, key)));
-	map(name, (guard) => {
+	}, key))), (guard) => {
 		input.context.report({
 			message: `Use Predicate.${guard} instead of this hand-written type guard.`,
 			node: input.node
@@ -1606,13 +1742,12 @@ const noLet = defineRule({
 });
 //#endregion
 //#region src/rules/no-multiline-comment.ts
-const directive = /^\s*(?:eslint|oxlint|@effect-diagnostics|@ts-|\/\s*<reference|#region|#endregion)/u;
 function adjacentLines(pair) {
 	return pair.first?.type === "Line" && pair.second?.type === "Line" && pair.second.loc.start.line === pair.first.loc.end.line + 1;
 }
 const noMultilineComment = defineRule({
 	create: (context) => ({ Program: () => {
-		const comments = pipe(context.sourceCode.getAllComments(), filter$1((comment) => !directive.test(comment.value)));
+		const comments = pipe(context.sourceCode.getAllComments(), filter$1((comment) => !matches(/^\s*(?:eslint|oxlint|@effect-diagnostics|@ts-|\/\s*<reference|#region|#endregion)/u)(comment.value)));
 		pipe(comments, filter$1((comment, index) => adjacentLines({
 			first: comment,
 			second: comments[index + 1]
@@ -1628,13 +1763,13 @@ const noMultilineComment = defineRule({
 });
 //#endregion
 //#region src/rules/no-native-control.ts
-const primitives = {
+const PRIMITIVES = {
 	button: "Button",
 	input: "Input",
 	select: "Select",
 	textarea: "Textarea"
 };
-const controlStyle = /(?:^|:)(?:hover|focus|focus-visible|active):|(?:^|:)(?:rounded|shadow|ring)(?:-|$)|(?:^|:)p[blrtxy]?-(?!0$)|(?:^|:)bg-(?!transparent$)|(?:^|:)border(?:-[blrtxy])?$|(?:^|:)border-(?!0$|[blrtxy]-0$)/u;
+const CONTROL_STYLE = /(?:^|:)(?:hover|focus|focus-visible|active):|(?:^|:)(?:rounded|shadow|ring)(?:-|$)|(?:^|:)p[blrtxy]?-(?!0$)|(?:^|:)bg-(?!transparent$)|(?:^|:)border(?:-[blrtxy])?$|(?:^|:)border-(?!0$|[blrtxy]-0$)/u;
 function classStrings(node) {
 	if (node.type === "Literal") return filter$1([node.value], isString);
 	if (node.type === "TemplateLiteral") return map$1(node.quasis, (quasi) => quasi.value.raw);
@@ -1649,11 +1784,11 @@ const noNativeControl = defineRule({
 	create: (context) => ({ JSXOpeningElement: (node) => {
 		if (node.name.type !== "JSXIdentifier") return;
 		const name = node.name.name;
-		map(get$2(primitives, name), (primitive) => {
+		map(get$2(PRIMITIVES, name), (primitive) => {
 			const styled = pipe(node.attributes, findFirst((attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "className"), map((attribute) => {
 				if (attribute.type !== "JSXAttribute" || attribute.value === null) return empty();
 				return classStrings(attribute.value);
-			}), exists((values) => some$1(values, (value) => some$1(split(value, /\s+/u), matches(controlStyle)))));
+			}), exists((values) => some$1(values, (value) => some$1(split(value, /\s+/u), matches(CONTROL_STYLE)))));
 			if (name !== "select" && !styled) return;
 			context.report({
 				message: `Use the ${primitive} UI primitive instead of a styled native control.`,
@@ -1666,7 +1801,7 @@ const noNativeControl = defineRule({
 //#endregion
 //#region src/rules/no-native-emptiness-check.ts
 function emptinessPredicate(node) {
-	const comparesLength = node.left.type === "MemberExpression" && contains(memberName(node.left), "length") && node.right.type === "Literal" && node.right.value === 0;
+	const comparesLength = node.left.type === "MemberExpression" && contains$1(memberName(node.left), "length") && node.right.type === "Literal" && node.right.value === 0;
 	if (comparesLength && node.operator === "===") return some("Array.isArrayEmpty, Array.isReadonlyArrayEmpty, or String.isEmpty");
 	if (comparesLength && node.operator === ">") return some("Array.isArrayNonEmpty, Array.isReadonlyArrayNonEmpty, or String.isNonEmpty");
 	return none();
@@ -1684,7 +1819,7 @@ const noNativeEmptinessCheck = defineRule({
 });
 //#endregion
 //#region src/rules/no-native-method-call.ts
-const nativeMethods = [
+const NATIVE_METHODS = [
 	"at",
 	"catch",
 	"charAt",
@@ -1755,11 +1890,6 @@ function freshRegExpFlags(input) {
 	if (flags.type !== "Literal" || !isString(flags.value)) return some(none());
 	return some(some(flags.value));
 }
-const nativeGlobals = [
-	"Object",
-	"Promise",
-	"RegExp"
-];
 function memberRoot(node) {
 	if (node.type === "MemberExpression") return memberRoot(node.object);
 	return node;
@@ -1784,7 +1914,11 @@ function ownsMethod(input) {
 	if (root.type !== "Identifier") return false;
 	if (root.name === "path") return !throughCall;
 	return pipe(variableFor(input.context, root), filter((variable) => isReadonlyArrayNonEmpty(variable.defs)), match({
-		onNone: () => !throughCall && matches(/^[A-Z]/u)(root.name) && !contains$1(nativeGlobals, root.name),
+		onNone: () => !throughCall && matches(/^[A-Z]/u)(root.name) && !contains([
+			"Object",
+			"Promise",
+			"RegExp"
+		], root.name),
 		onSome: (variable) => some$1(variable.defs, (definition) => {
 			if (definition.node.type === "VariableDeclarator") return !throughCall && isYieldedService(definition.node.init);
 			if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") return false;
@@ -1810,7 +1944,7 @@ const noNativeMethodCall = defineRule({
 			});
 			return;
 		}
-		pipe(memberName(node.callee), filter((name) => contains$1(nativeMethods, name)), filter((name) => !contains$1([
+		pipe(memberName(node.callee), filter((name) => contains(NATIVE_METHODS, name)), filter((name) => !contains([
 			"entries",
 			"keys",
 			"values"
@@ -1823,14 +1957,6 @@ const noNativeMethodCall = defineRule({
 });
 //#endregion
 //#region src/rules/no-nullish-ternary.ts
-const nullishPredicates = [
-	"isNotNull",
-	"isNotNullish",
-	"isNotUndefined",
-	"isNull",
-	"isNullish",
-	"isUndefined"
-];
 function isNullish(input) {
 	if (input.node.type === "Literal") return input.node.value === null;
 	return input.node.type === "Identifier" && input.node.name === "undefined";
@@ -1851,7 +1977,14 @@ function testsNullish(input) {
 		context: input.context,
 		importedName: "Predicate",
 		node: input.node.callee
-	}) && exists(memberName(input.node.callee), (name) => contains$1(nullishPredicates, name));
+	}) && exists(memberName(input.node.callee), (name) => contains([
+		"isNotNull",
+		"isNotNullish",
+		"isNotUndefined",
+		"isNull",
+		"isNullish",
+		"isUndefined"
+	], name));
 }
 const noNullishTernary = defineRule({
 	create: (context) => ({ ConditionalExpression: (node) => {
@@ -1883,7 +2016,7 @@ function checks(input) {
 	}) && input.test.arguments[0] !== void 0 && input.context.sourceCode.getText(input.test.arguments[0]) === input.subject;
 }
 function exits(node) {
-	return contains$1([
+	return contains([
 		"ContinueStatement",
 		"ReturnStatement",
 		"ThrowStatement"
@@ -1920,7 +2053,7 @@ function guarded(input) {
 }
 const noOptionValueAccess = defineRule({
 	create: (context) => ({ MemberExpression: (node) => {
-		if (!contains(memberName(node), "value")) return;
+		if (!contains$1(memberName(node), "value")) return;
 		if (guarded({
 			context,
 			node,
@@ -1934,26 +2067,14 @@ const noOptionValueAccess = defineRule({
 });
 //#endregion
 //#region src/rules/no-property-alias.ts
-const functions = [
+const FUNCTIONS = [
 	"ArrowFunctionExpression",
 	"FunctionDeclaration",
 	"FunctionExpression"
 ];
-const deferred = [
-	"ChainExpression",
-	"ConditionalExpression",
-	"DoWhileStatement",
-	"ForInStatement",
-	"ForOfStatement",
-	"ForStatement",
-	"IfStatement",
-	"LogicalExpression",
-	"SwitchStatement",
-	"WhileStatement"
-];
 function insideFunction(node) {
 	if (isNullish$1(node.parent) || node.parent.type === "Program") return false;
-	if (contains$1(functions, node.parent.type)) return true;
+	if (contains(FUNCTIONS, node.parent.type)) return true;
 	return insideFunction(node.parent);
 }
 function sameRoot(input) {
@@ -1965,9 +2086,58 @@ function sameRoot(input) {
 		scope: input.context.sourceCode.getScope(input.read)
 	}));
 }
+function pathTop(node) {
+	if (node.parent?.type === "MemberExpression" && node.parent.object === node && !node.parent.computed) return pathTop(node.parent);
+	return node;
+}
+function tested(node) {
+	if (isNullish$1(node.parent)) return false;
+	if (node.parent.type === "LogicalExpression") return node.parent.left === node || tested(node.parent);
+	if (contains([
+		"ChainExpression",
+		"TSAsExpression",
+		"TSNonNullExpression"
+	], node.parent.type)) return tested(node.parent);
+	return node.parent.type === "BinaryExpression" && contains([
+		"!=",
+		"!==",
+		"==",
+		"===",
+		"in",
+		"instanceof"
+	], node.parent.operator) || node.parent.type === "UnaryExpression" && contains(["!", "typeof"], node.parent.operator) || node.parent.type === "ConditionalExpression" && node.parent.test === node || node.parent.type === "IfStatement" && node.parent.test === node || node.parent.type === "SwitchStatement" && node.parent.discriminant === node || node.parent.type === "CallExpression" && node.parent.callee !== node && !(node.parent.parent.type === "CallExpression" && node.parent.parent.callee === node.parent) && (predicate(node.parent.callee) || tested(node.parent));
+}
+function predicate(callee) {
+	if (callee.type === "CallExpression") return predicate(callee.callee);
+	if (callee.type === "Identifier") return matches(/^(?:has|is)(?:[A-Z]|$)/u)(callee.name);
+	return callee.type === "MemberExpression" && callee.property.type === "Identifier" && matches(/^(?:has|is)(?:[A-Z]|$)/u)(callee.property.name);
+}
+function deferred(input) {
+	if (isNullish$1(input.node.parent) || input.node.parent === input.block) return false;
+	const parent = input.node.parent;
+	if (contains(FUNCTIONS, parent.type) && !(parent.parent?.type === "CallExpression" && some$1(parent.parent.arguments, (argument) => argument === parent))) return true;
+	return deferred({
+		...input,
+		node: parent
+	});
+}
+function needsAlias(input) {
+	if (input.declaration.parent.type !== "BlockStatement" || !contains(FUNCTIONS, input.declaration.parent.parent.type) || !pipe(input.declaration.parent.body, takeWhile((statement) => statement !== input.declaration), every((statement) => statement.type === "VariableDeclaration"))) return true;
+	const block = input.declaration.parent;
+	const paths = map$1(input.reads, (read) => ({
+		callback: enclosed({
+			block,
+			node: read,
+			types: FUNCTIONS
+		}),
+		node: pathTop(read),
+		text: input.context.sourceCode.getText(pathTop(read))
+	}));
+	return some$1(paths, (checked) => tested(checked.node) && some$1(paths, (read) => read.callback && (read.text === checked.text || startsWith(`${checked.text}.`)(read.text))));
+}
 function enclosed(input) {
 	if (isNullish$1(input.node.parent) || input.node.parent === input.block) return false;
-	if (contains$1(input.types, input.node.parent.type)) return true;
+	if (contains(input.types, input.node.parent.type)) return true;
 	return enclosed({
 		...input,
 		node: input.node.parent
@@ -1986,24 +2156,6 @@ function written(node) {
 	if (node.type === "UpdateExpression" || node.type === "UnaryExpression" && node.operator === "delete") return objectRoot(node.argument);
 	return none();
 }
-function inert(token) {
-	if (contains$1([
-		"Boolean",
-		"Identifier",
-		"Null",
-		"Numeric",
-		"String"
-	], token.type)) return true;
-	if (token.type === "Keyword") return contains$1(["const", "return"], token.value);
-	return token.type === "Punctuator" && contains$1([
-		"(",
-		",",
-		":",
-		"=",
-		"[",
-		"{"
-	], token.value);
-}
 function replacement(input) {
 	if (input.read.parent?.type === "Property" && input.read.parent.shorthand) return `${input.name}: ${input.text}`;
 	return input.text;
@@ -2013,15 +2165,22 @@ function report$2(input) {
 	const text = input.context.sourceCode.getText(input.init);
 	pipe(rootName(input.init), filter((root) => isArrayNonEmpty(reads) && every(reads, (read) => {
 		const used = outermost(read);
-		return read.parent.type !== "ExportSpecifier" && !enclosed({
+		return read.parent.type !== "ExportSpecifier" && (!needsAlias({
+			context: input.context,
+			declaration: input.declaration,
+			reads
+		}) || !enclosed({
 			block: input.declaration.parent,
 			node: read,
-			types: functions
+			types: FUNCTIONS
+		})) && !deferred({
+			block: input.declaration.parent,
+			node: read
 		}) && !(used.parent?.type === "CallExpression" && used.parent.callee === used) && !(used.parent?.type === "TaggedTemplateExpression" && used.parent.tag === used) && !some$1(input.writes, (write) => between({
 			declaration: input.declaration,
 			node: write,
 			read
-		}) && contains(written(write), root)) && sameRoot({
+		}) && contains$1(written(write), root)) && sameRoot({
 			context: input.context,
 			declarator: input.node,
 			name: root,
@@ -2034,7 +2193,19 @@ function report$2(input) {
 				if (reads.length !== 1 || some$1(reads, (read) => startsWith("JSX")(read.parent.type) || enclosed({
 					block: input.declaration.parent,
 					node: read,
-					types: deferred
+					types: [
+						...FUNCTIONS,
+						"ChainExpression",
+						"ConditionalExpression",
+						"DoWhileStatement",
+						"ForInStatement",
+						"ForOfStatement",
+						"ForStatement",
+						"IfStatement",
+						"LogicalExpression",
+						"SwitchStatement",
+						"WhileStatement"
+					]
 				}) || some$1(input.statements, (node) => between({
 					declaration: input.declaration,
 					node,
@@ -2080,6 +2251,19 @@ const noPropertyAlias = defineRule({
 			},
 			UpdateExpression: write,
 			VariableDeclarator: (node) => {
+				if (node.parent.type === "VariableDeclaration" && node.parent.parent.type === "ExportNamedDeclaration" && node.id.type === "Identifier" && node.init?.type === "MemberExpression") {
+					const init = node.init;
+					pipe(rootName(init), flatMap((root) => variableFromScope({
+						name: root,
+						scope: context.sourceCode.getScope(node)
+					})), filter((variable) => every(variable.defs, (definition) => definition.type === "Variable")), match({
+						onNone: constVoid,
+						onSome: (variable) => context.report({
+							message: `Export ${variable.name} and read ${context.sourceCode.getText(init)} where it is used.`,
+							node
+						})
+					}));
+				}
 				if (node.parent.type === "VariableDeclaration" && node.parent.kind === "const" && node.parent.declarations.length === 1 && (node.parent.parent.type === "BlockStatement" || node.parent.parent.type === "StaticBlock") && node.id.type === "Identifier" && node.id.typeAnnotation === null && node.init?.type === "MemberExpression" && insideFunction(node.parent)) append$1(candidates, {
 					declaration: node.parent,
 					init: node.init,
@@ -2103,7 +2287,7 @@ function isTopLevelStatement(node) {
 }
 function insideCycleType(input) {
 	if (input.node.type === "Program") return false;
-	if (input.node.type === "TSTypeAliasDeclaration" && isTopLevelStatement(input.node)) return contains$1(input.cycleNames, input.node.id.name);
+	if (input.node.type === "TSTypeAliasDeclaration" && isTopLevelStatement(input.node)) return contains(input.cycleNames, input.node.id.name);
 	return insideCycleType({
 		cycleNames: input.cycleNames,
 		node: input.node.parent
@@ -2144,7 +2328,7 @@ function shapeLiterals(input) {
 	return pipe(typeDeclarations({
 		context: input.context,
 		name: input.type.typeName
-	}), filter$1((declaration) => declaration.type === "TSTypeAliasDeclaration"), filter$1((alias) => !contains$1(input.seen, alias)), flatMap$1((alias) => shapeLiterals({
+	}), filter$1((declaration) => declaration.type === "TSTypeAliasDeclaration"), filter$1((alias) => !contains(input.seen, alias)), flatMap$1((alias) => shapeLiterals({
 		...input,
 		seen: append(input.seen, alias),
 		type: alias.typeAnnotation
@@ -2292,7 +2476,7 @@ function isReactUseRef(input) {
 		node: input.node.callee,
 		source: "react"
 	});
-	return input.node.callee.type === "MemberExpression" && contains(memberName(input.node.callee), "useRef") && input.node.callee.object.type === "Identifier" && isNamespaceImport({
+	return input.node.callee.type === "MemberExpression" && contains$1(memberName(input.node.callee), "useRef") && input.node.callee.object.type === "Identifier" && isNamespaceImport({
 		context: input.context,
 		node: input.node.callee.object,
 		source: "react"
@@ -2367,7 +2551,7 @@ const shipped = [
 		schema: "Natural"
 	}
 ];
-function schemaMember(input) {
+function schemaMember$1(input) {
 	if (input.node.type !== "MemberExpression" || !importedMember({
 		context: input.context,
 		importedName: "Schema",
@@ -2377,16 +2561,16 @@ function schemaMember(input) {
 }
 function shippedSchema(input) {
 	if (input.filter.type !== "CallExpression") return none();
-	const base = schemaMember({
+	const base = schemaMember$1({
 		context: input.context,
 		node: input.base
 	});
-	const check = schemaMember({
+	const check = schemaMember$1({
 		context: input.context,
 		node: input.filter.callee
 	});
 	const [value, ...rest] = input.filter.arguments;
-	return pipe(shipped, findFirst((entry) => contains(base, entry.base) && contains(check, entry.check) && isArrayEmpty(rest) && match(fromUndefinedOr(entry.only), {
+	return pipe(shipped, findFirst((entry) => contains$1(base, entry.base) && contains$1(check, entry.check) && isArrayEmpty(rest) && match(fromUndefinedOr(entry.only), {
 		onNone: () => value === void 0,
 		onSome: (only) => value?.type === "Literal" && value.value === only
 	})), map((entry) => entry.schema));
@@ -2397,14 +2581,14 @@ function pipedBase(node) {
 		if (node.parent.arguments[1] !== node) return none();
 		return fromNullishOr(node.parent.arguments[0]);
 	}
-	if (node.parent.callee.type !== "MemberExpression" || !contains(memberName(node.parent.callee), "pipe") || node.parent.arguments.length !== 1) return none();
+	if (node.parent.callee.type !== "MemberExpression" || !contains$1(memberName(node.parent.callee), "pipe") || node.parent.arguments.length !== 1) return none();
 	return some(node.parent.callee.object);
 }
 function reinventedSchema(input) {
-	if (input.node.callee.type !== "MemberExpression" || !contains(memberName(input.node.callee), "check")) return none();
+	if (input.node.callee.type !== "MemberExpression" || !contains$1(memberName(input.node.callee), "check")) return none();
 	const callee = input.node.callee;
 	const [filter] = input.node.arguments;
-	if (isSome(schemaMember({
+	if (isSome(schemaMember$1({
 		context: input.context,
 		node: callee
 	}))) {
@@ -2524,7 +2708,7 @@ const noReturnType = defineRule({
 });
 //#endregion
 //#region src/rules/no-single-use-value.ts
-const repeating = [
+const REPEATING = [
 	"ArrowFunctionExpression",
 	"DoWhileStatement",
 	"ForInStatement",
@@ -2539,7 +2723,7 @@ function runsOnce(input) {
 		...input,
 		node: input.node
 	});
-	if (contains$1(repeating, input.node.type) || input.node.type === "IfStatement" || input.node.type === "ConditionalExpression" || input.node.type === "LogicalExpression" || input.node.type === "ChainExpression" || input.node.type === "SwitchStatement" || input.node.type === "TryStatement") return false;
+	if (contains(REPEATING, input.node.type) || input.node.type === "IfStatement" || input.node.type === "ConditionalExpression" || input.node.type === "LogicalExpression" || input.node.type === "ChainExpression" || input.node.type === "SwitchStatement" || input.node.type === "TryStatement") return false;
 	return climb({
 		...input,
 		node: input.node
@@ -2563,7 +2747,7 @@ function insideConditional(input) {
 	});
 }
 function candidate(node) {
-	return node.parent.type === "VariableDeclaration" && node.parent.kind === "const" && node.parent.declarations.length === 1 && node.parent.parent.type === "BlockStatement" && node.id.type === "Identifier" && node.id.typeAnnotation === null && node.init !== null && !contains$1(["ArrowFunctionExpression", "FunctionExpression"], node.init.type) && !(node.init.type === "MemberExpression" && isSome(rootName(node.init))) && !(node.init.type === "Literal" && !hasProperty(node.init, "regex")) && !(node.init.type === "TemplateLiteral" && isArrayEmpty(node.init.expressions));
+	return node.parent.type === "VariableDeclaration" && node.parent.kind === "const" && node.parent.declarations.length === 1 && node.parent.parent.type === "BlockStatement" && node.id.type === "Identifier" && node.id.typeAnnotation === null && node.init !== null && !contains(["ArrowFunctionExpression", "FunctionExpression"], node.init.type) && !(node.init.type === "MemberExpression" && isSome(rootName(node.init))) && !(node.init.type === "Literal" && !hasProperty(node.init, "regex")) && !(node.init.type === "TemplateLiteral" && isArrayEmpty(node.init.expressions));
 }
 function unwrapped(node) {
 	return pipe(typeWrapped(node), match({
@@ -2581,10 +2765,61 @@ function inlined(input) {
 	if (input.read.range[0] === input.next.range[0]) return `;${value}`;
 	return value;
 }
+function executes(node) {
+	if (contains([
+		"AwaitExpression",
+		"CallExpression",
+		"MemberExpression",
+		"NewExpression",
+		"SpreadElement",
+		"TaggedTemplateExpression",
+		"YieldExpression"
+	], node.type)) return true;
+	if (contains([
+		"ArrowFunctionExpression",
+		"FunctionDeclaration",
+		"FunctionExpression"
+	], node.type)) return false;
+	return some$1(childNodes(node), executes);
+}
+function suspends(node) {
+	if (node.type === "YieldExpression" || node.type === "AwaitExpression") return true;
+	if (contains([
+		"ArrowFunctionExpression",
+		"FunctionDeclaration",
+		"FunctionExpression"
+	], node.type)) return false;
+	return some$1(childNodes(node), suspends);
+}
+function surface(node) {
+	if (contains([
+		"ExpressionStatement",
+		"ReturnStatement",
+		"VariableDeclaration"
+	], node.type) || node.type === "ArrowFunctionExpression" && node.expression) return true;
+	if (isNullish$1(node.parent) || !contains([
+		"AwaitExpression",
+		"JSXAttribute",
+		"JSXElement",
+		"JSXExpressionContainer",
+		"JSXFragment",
+		"JSXOpeningElement",
+		"VariableDeclarator",
+		"YieldExpression"
+	], node.type)) return false;
+	return surface(node.parent);
+}
+function readable(input) {
+	if (!pipe(input.context.sourceCode.getText(input.init), includes("\n"))) return true;
+	const slot = outermost(input.read);
+	if (isNullish$1(slot.parent) || suspends(input.init)) return false;
+	if (slot.parent.type === "JSXExpressionContainer" || slot.parent.type === "ReturnStatement") return true;
+	return isNotNullish(slot.parent.parent) && (slot.parent.type === "CallExpression" && slot.parent.callee !== slot || slot.parent.type === "ArrayExpression") && surface(slot.parent.parent);
+}
 function report$1(input) {
 	const declaration = input.node.parent;
 	const init = input.node.init;
-	if (declaration.type !== "VariableDeclaration" || declaration.parent.type !== "BlockStatement" || input.node.id.type !== "Identifier" || init === null || pipe(input.context.sourceCode.getText(init), includes("\n"))) return;
+	if (declaration.type !== "VariableDeclaration" || declaration.parent.type !== "BlockStatement" || input.node.id.type !== "Identifier" || init === null) return;
 	const statements = declaration.parent.body;
 	const name = input.node.id.name;
 	pipe(findFirstIndex(statements, (statement) => statement === declaration), flatMap((index) => get$1(statements, index + 1)), flatMap((next) => pipe(variableFromScope({
@@ -2593,6 +2828,10 @@ function report$1(input) {
 	}), map((variable) => filter$1(variable.references, (reference) => reference.isRead())), filter((reads) => reads.length === 1), flatMap(head), map((reference) => reference.identifier), filter((read) => read.range[0] >= next.range[0] && read.range[1] <= next.range[1] && climb({
 		node: read,
 		statement: next
+	}) && readable({
+		context: input.context,
+		init,
+		read
 	}) && !(init.type === "ConditionalExpression" && insideConditional({
 		node: read,
 		statement: next
@@ -2606,7 +2845,7 @@ function report$1(input) {
 				if (!fixable({
 					init,
 					read: found.read
-				})) return [];
+				}) || executes(init) && !every(input.context.sourceCode.getTokensBetween(declaration, found.read), inert)) return [];
 				return [fixer.remove(declaration), fixer.replaceText(found.read, inlined({
 					context: input.context,
 					init,
@@ -2652,6 +2891,22 @@ const noSingleUseValue = defineRule({
 	}
 });
 //#endregion
+//#region src/rules/no-stored-jsx.ts
+function element(node) {
+	if (node.type === "JSXElement" || node.type === "JSXFragment") return true;
+	return pipe(typeWrapped(node), exists(element));
+}
+const noStoredJsx = defineRule({
+	create: (context) => ({ VariableDeclarator: (node) => {
+		if (node.init === null || !element(node.init)) return;
+		context.report({
+			message: "Write the element where it renders, or make it a component when several places render it.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/no-stored-schema-operation.ts
 function storedSchemaOperation(node) {
 	return node.parent.type === "VariableDeclarator" && node.parent.init === node || node.parent.type === "Property" && node.parent.value === node || node.parent.type === "PropertyDefinition" && node.parent.value === node || node.parent.type === "ArrayExpression" || node.parent.type === "AssignmentExpression" && node.parent.right === node;
@@ -2715,7 +2970,7 @@ function detachable(input) {
 function forwardedChain(input) {
 	const chain = callGroups(input.returned);
 	function fixed(node) {
-		return node.type === "Literal" || exists(rootName(node), (root) => !contains$1(input.names, root));
+		return node.type === "Literal" || exists(rootName(node), (root) => !contains(input.names, root));
 	}
 	return matchRight(chain.groups, {
 		onEmpty: constFalse,
@@ -2789,7 +3044,7 @@ function exportedAlias(input) {
 	return input.node.parent.type === "VariableDeclaration" && input.node.parent.kind === "const" && input.node.parent.parent.type === "ExportNamedDeclaration" && input.node.id.type === "Identifier" && input.node.init?.type === "Identifier" && pipe(variableFor(input.context, input.node.init), exists((variable) => some$1(variable.defs, (definition) => definition.type === "ImportBinding" || definition.type === "FunctionName" || definition.type === "ClassName" || definition.node.type === "VariableDeclarator" && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const")));
 }
 function singleUseLiteral(input) {
-	if (input.node.parent.type !== "VariableDeclaration" || input.node.parent.kind !== "const" || isExport(input.node.parent.parent) || input.node.id.type !== "Identifier" || input.node.id.typeAnnotation !== null || !(input.node.init?.type === "Literal" && !hasProperty(input.node.init, "regex") || input.node.init?.type === "TemplateLiteral" && isArrayEmpty(input.node.init.expressions))) return false;
+	if (input.node.parent.type !== "VariableDeclaration" || input.node.parent.kind !== "const" || isExport(input.node.parent.parent) || input.node.parent.parent.type === "Program" || input.node.id.type !== "Identifier" || input.node.id.typeAnnotation !== null || !(input.node.init?.type === "Literal" && !hasProperty(input.node.init, "regex") || input.node.init?.type === "TemplateLiteral" && isArrayEmpty(input.node.init.expressions))) return false;
 	return pipe(variableFromScope({
 		name: input.node.id.name,
 		scope: input.context.sourceCode.getScope(input.node)
@@ -2804,7 +3059,7 @@ function singleUseLayerPart(input) {
 	}), map((variable) => filter$1(variable.references, (reference) => reference.isRead())), exists((reads) => {
 		const consumer = reads[0]?.identifier.parent;
 		if (reads.length !== 1 || consumer?.type !== "CallExpression") return false;
-		if (init.type === "MemberExpression") return contains(memberName(init), "layer") && (importedMember({
+		if (init.type === "MemberExpression") return contains$1(memberName(init), "layer") && (importedMember({
 			context: input.context,
 			importedName: "Layer",
 			node: consumer.callee
@@ -2917,6 +3172,45 @@ const noTrivialIndirection = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-type-from-value.ts
+function schemaMember(name) {
+	return name.type === "TSQualifiedName" && contains([
+		"Encoded",
+		"Type",
+		"cases",
+		"fields",
+		"literals",
+		"members"
+	], name.right.name);
+}
+function valueQuery(node) {
+	if (node.type === "TSParenthesizedType") return valueQuery(node.typeAnnotation);
+	if (node.type === "TSIndexedAccessType") return valueQuery(node.objectType);
+	return node.type === "TSTypeQuery" && (node.exprName.type === "Identifier" || node.exprName.type === "TSQualifiedName" && !schemaMember(node.exprName));
+}
+function nestedObject(node) {
+	return node.parent?.type === "TSIndexedAccessType" && node.parent.objectType === node;
+}
+const noTypeFromValue = defineRule({
+	create: (context) => {
+		function report(node) {
+			context.report({
+				message: "Declare the closed set as a schema, such as Schema.Literals, and read its type with typeof X.Type.",
+				node
+			});
+		}
+		return {
+			TSIndexedAccessType: (node) => {
+				if (!nestedObject(node) && valueQuery(node.objectType)) report(node);
+			},
+			TSTypeOperator: (node) => {
+				if (node.operator === "keyof" && !nestedObject(node) && valueQuery(node.typeAnnotation)) report(node);
+			}
+		};
+	},
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/no-typeof.ts
 const noTypeof = defineRule({
 	create: (context) => ({ UnaryExpression: (node) => {
@@ -3001,7 +3295,7 @@ const noUnvalidatedJsonDecode = defineRule({
 //#region src/rules/preserve-error-cause.ts
 function constructedFields(node) {
 	if (node?.type !== "CallExpression" && node?.type !== "NewExpression") return none();
-	const constructs = node.type === "NewExpression" || node.callee.type === "MemberExpression" && contains(memberName(node.callee), "make");
+	const constructs = node.type === "NewExpression" || node.callee.type === "MemberExpression" && contains$1(memberName(node.callee), "make");
 	const fields = node.arguments[0];
 	if (!constructs || fields?.type !== "ObjectExpression") return none();
 	return some(fields);
@@ -3024,7 +3318,7 @@ const preserveErrorCause = defineRule({
 			node: node.callee
 		})) return;
 		const name = memberName(node.callee);
-		if (contains(name, "mapError")) {
+		if (contains$1(name, "mapError")) {
 			forEach(filter$1(node.arguments, dropsCause), (callback) => report(context, callback));
 			return;
 		}
@@ -3085,7 +3379,7 @@ function isSchemaDefinition(input) {
 		context: input.context,
 		importedName: "Schema",
 		node: input.node.callee
-	}) && contains(memberName(input.node.callee), "make")) return false;
+	}) && contains$1(memberName(input.node.callee), "make")) return false;
 	if (!expressionUsesImport({
 		context: input.context,
 		importedName: "Schema",
@@ -3126,7 +3420,7 @@ function exportLists(program) {
 	};
 }
 function isExported(input) {
-	return input.statement.type === "ExportNamedDeclaration" || contains$1(input.exports.values, input.name) || input.typeOnly && contains$1(input.exports.types, input.name);
+	return input.statement.type === "ExportNamedDeclaration" || contains(input.exports.values, input.name) || input.typeOnly && contains(input.exports.types, input.name);
 }
 function reportSchemaVariable(input) {
 	if (input.variable.id.type !== "Identifier" || !matches(/^[A-Z]/u)(input.variable.id.name)) return;
@@ -3136,7 +3430,7 @@ function reportSchemaVariable(input) {
 	})) return;
 	const name = input.variable.id.name;
 	const typeStatement = pipe(input.program.body, findFirstIndex((statement) => statement === input.statement), filter((index) => index > 0), flatMap((index) => get$1(input.program.body, index - 1)));
-	if (contains$1(input.cycleNames, name)) {
+	if (contains(input.cycleNames, name)) {
 		if (!pipe(namedTypeAlias({
 			name,
 			typeStatement
@@ -3215,7 +3509,7 @@ const schemaTypePair = defineRule({
 });
 //#endregion
 //#region src/oxlint.ts
-const reactLegacyApis = [
+const REACT_LEGACY_APIS = [
 	"Component",
 	"PureComponent",
 	"createRef",
@@ -3224,9 +3518,9 @@ const reactLegacyApis = [
 	"useCallback",
 	"useMemo"
 ];
-const reactLegacyMessage = "Use React 19 function components with refs as props; React Compiler owns memoization.";
-const mapMessage = "Use HashMap, or MutableHashMap for local mutation; for identity keys, wrap objects the code owns in Equal.byReferenceUnsafe, which marks them reference-compared globally.";
-const reactHooks = [
+const REACT_LEGACY_MESSAGE = "Use React 19 function components with refs as props; React Compiler owns memoization.";
+const MAP_MESSAGE = "Use HashMap, or MutableHashMap for local mutation; for identity keys, wrap objects the code owns in Equal.byReferenceUnsafe, which marks them reference-compared globally.";
+const REACT_HOOKS = [
 	"use",
 	"useActionState",
 	"useContext",
@@ -3245,8 +3539,8 @@ const reactHooks = [
 	"useSyncExternalStore",
 	"useTransition"
 ];
-const runMessage = "Run the entry point with NodeRuntime.runMain, and Effects in React through atoms. A Promise that an external contract demands takes Effect.runPromise once, with an inline disable that names the contract.";
-const runners = [
+const RUN_MESSAGE = "Run the entry point with NodeRuntime.runMain, and Effects in React through atoms. A Promise that an external contract demands takes Effect.runPromise once, with an inline disable that names the contract.";
+const RUNNERS = [
 	"runCallback",
 	"runCallbackWith",
 	"runFork",
@@ -3260,7 +3554,7 @@ const runners = [
 	"runSyncExitWith",
 	"runSyncWith"
 ];
-const setMessage = "Use HashSet, or MutableHashSet for local mutation; for identity keys, wrap objects the code owns in Equal.byReferenceUnsafe, which marks them reference-compared globally.";
+const SET_MESSAGE = "Use HashSet, or MutableHashSet for local mutation; for identity keys, wrap objects the code owns in Equal.byReferenceUnsafe, which marks them reference-compared globally.";
 const oxlint = defineConfig({
 	categories: {
 		correctness: "off",
@@ -3356,6 +3650,7 @@ const oxlint = defineConfig({
 	],
 	rules: {
 		"@deslop/coding-standards/explicit-effect-concurrency": "error",
+		"@deslop/coding-standards/module-constant": "error",
 		"@deslop/coding-standards/motion-limits": "error",
 		"@deslop/coding-standards/no-array-wrap-ternary": "error",
 		"@deslop/coding-standards/no-barrel-module": "error",
@@ -3370,6 +3665,7 @@ const oxlint = defineConfig({
 		"@deslop/coding-standards/no-empty-recovery": "error",
 		"@deslop/coding-standards/no-error-message-assertion": "error",
 		"@deslop/coding-standards/no-fake-ref-state": "error",
+		"@deslop/coding-standards/no-floating-derived-type": "error",
 		"@deslop/coding-standards/no-gradient": "error",
 		"@deslop/coding-standards/no-hand-written-guard": "error",
 		"@deslop/coding-standards/no-in-operator": "error",
@@ -3389,9 +3685,11 @@ const oxlint = defineConfig({
 		"@deslop/coding-standards/no-renamed-import": "error",
 		"@deslop/coding-standards/no-return-type": "error",
 		"@deslop/coding-standards/no-single-use-value": "error",
+		"@deslop/coding-standards/no-stored-jsx": "error",
 		"@deslop/coding-standards/no-stored-schema-operation": "error",
 		"@deslop/coding-standards/no-switch-statement": "error",
 		"@deslop/coding-standards/no-trivial-indirection": "error",
+		"@deslop/coding-standards/no-type-from-value": "error",
 		"@deslop/coding-standards/no-typeof": "error",
 		"@deslop/coding-standards/no-undestructured-use-state": "error",
 		"@deslop/coding-standards/no-unexplained-disable": "error",
@@ -3591,8 +3889,8 @@ const oxlint = defineConfig({
 		"no-restricted-imports": ["error", {
 			paths: [
 				{
-					importNames: reactLegacyApis,
-					message: reactLegacyMessage,
+					importNames: REACT_LEGACY_APIS,
+					message: REACT_LEGACY_MESSAGE,
 					name: "react"
 				},
 				{
@@ -3701,7 +3999,7 @@ const oxlint = defineConfig({
 				name: "Error"
 			},
 			{
-				message: mapMessage,
+				message: MAP_MESSAGE,
 				name: "Map"
 			},
 			{
@@ -3729,7 +4027,7 @@ const oxlint = defineConfig({
 				name: "Reflect"
 			},
 			{
-				message: setMessage,
+				message: SET_MESSAGE,
 				name: "Set"
 			},
 			{
@@ -3756,13 +4054,13 @@ const oxlint = defineConfig({
 				message: "Use Predicate.hasProperty.",
 				property: "hasOwnProperty"
 			},
-			...map$1(runners, (property) => ({
-				message: runMessage,
+			...map$1(RUNNERS, (property) => ({
+				message: RUN_MESSAGE,
 				object: "Effect",
 				property
 			})),
 			{
-				message: runMessage,
+				message: RUN_MESSAGE,
 				object: "ManagedRuntime",
 				property: "make"
 			},
@@ -3786,12 +4084,12 @@ const oxlint = defineConfig({
 				object: "Math",
 				property: "round"
 			},
-			...map$1(reactLegacyApis, (property) => ({
-				message: reactLegacyMessage,
+			...map$1(REACT_LEGACY_APIS, (property) => ({
+				message: REACT_LEGACY_MESSAGE,
 				object: "React",
 				property
 			})),
-			...map$1(reactHooks, (property) => ({
+			...map$1(REACT_HOOKS, (property) => ({
 				message: `Import ${property} by name from react.`,
 				object: "React",
 				property
@@ -3908,6 +4206,12 @@ const oxlint = defineConfig({
 			ignoreRestSiblings: true,
 			reportUsedIgnorePattern: true
 		}],
+		"no-use-before-define": ["error", {
+			classes: false,
+			functions: false,
+			typedefs: false,
+			variables: true
+		}],
 		"no-useless-assignment": "error",
 		"no-useless-backreference": "error",
 		"no-useless-call": "error",
@@ -4044,12 +4348,12 @@ const oxlint = defineConfig({
 			Date: "Use DateTime.",
 			Error: "Use Schema.TaggedError.",
 			Iterable: "Use T[].",
-			Map: mapMessage,
+			Map: MAP_MESSAGE,
 			Promise: "Use Effect.",
 			ReadonlyArray: "Use T[].",
-			ReadonlyMap: mapMessage,
-			ReadonlySet: setMessage,
-			Set: setMessage,
+			ReadonlyMap: MAP_MESSAGE,
+			ReadonlySet: SET_MESSAGE,
+			Set: SET_MESSAGE,
 			undefined: "Use an optional property or parameter, or let inference supply undefined."
 		} }],
 		"typescript/no-unnecessary-type-assertion": "error",
@@ -4084,6 +4388,7 @@ var oxlint_default = definePlugin({
 	meta: { name: "@deslop/coding-standards" },
 	rules: {
 		"explicit-effect-concurrency": explicitEffectConcurrency,
+		"module-constant": moduleConstant,
 		"motion-limits": motionLimits,
 		"no-array-wrap-ternary": noArrayWrapTernary,
 		"no-barrel-module": noBarrelModule,
@@ -4098,6 +4403,7 @@ var oxlint_default = definePlugin({
 		"no-empty-recovery": noEmptyRecovery,
 		"no-error-message-assertion": noErrorMessageAssertion,
 		"no-fake-ref-state": noFakeRefState,
+		"no-floating-derived-type": noFloatingDerivedType,
 		"no-gradient": noGradient,
 		"no-hand-written-guard": noHandWrittenGuard,
 		"no-in-operator": noInOperator,
@@ -4117,9 +4423,11 @@ var oxlint_default = definePlugin({
 		"no-renamed-import": noRenamedImport,
 		"no-return-type": noReturnType,
 		"no-single-use-value": noSingleUseValue,
+		"no-stored-jsx": noStoredJsx,
 		"no-stored-schema-operation": noStoredSchemaOperation,
 		"no-switch-statement": noSwitchStatement,
 		"no-trivial-indirection": noTrivialIndirection,
+		"no-type-from-value": noTypeFromValue,
 		"no-typeof": noTypeof,
 		"no-undestructured-use-state": noUndestructuredUseState,
 		"no-unexplained-disable": noUnexplainedDisable,