@deslop/coding-standards 0.1.1083 → 0.1.1086

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 { A as dedupeWith, Ar as isNumber, At as firstSomeOf, B as flatMap$1, Br as constFalse, Bt as map, C as TaggedError, D as contains, Dr as isNotNullish, Dt as contains$1, E as appendAll, Er as isNotNull, Et as all, F as filter$1, Fr as isRegExp, Ft as getOrElse, G as getSomes, Gr as dual, Gt as toArray$1, H as forEach, Ht as none, I as filterMap, Ir as isString, It as getOrUndefined, J as isArrayNonEmpty, K as head, Kt as zipWith, L as findFirst, Lt as isNone, M as empty, Mt as flatten$1, N as ensure, Nt as fromNullishOr, O as containsWith, Ot as exists, P as every, Pr as isReadonlyObject, Pt as fromUndefinedOr, Q as last, Qr as pipeArguments, R as findFirstIndex, Rt as isSome, Sr as isBoolean, T as append, Ur as constVoid, Ut as orElse, V as flatten, Vt as match, W as get$1, Wt as some, X as isReadonlyArrayNonEmpty, Yr as pipe, Z as join, Zn as NodeInspectSymbol, _ as toUpperCase, an as strictEqual, b as parse, br as hasProperty, c as make$3, cr as byReferenceUnsafe, ct as take, d as Order, dt as get$2, et as map$1, f as includes, fr as combine, g as startsWith, gr as string, h as split, hr as optimize, ht as values, it as prepend, j as dropRight, jt as flatMap, k as dedupe, kr as isNullish, kt as filter, l as update, lr as equals, lt as takeWhile, m as replaceAll, mr as number, mt as remove, nt as matchRight, o as toArray, ot as some$1, p as match$1, pr as hash, q as isArrayEmpty, r as make$2, rt as of, s as get$3, st as sort, t as append$1, u as match$2, ur as symbol, ut as fromEntries, v as trim, vt as fromOption, yr as symbol$1 } from "./MutableList-CnvD7fcZ.mjs";
 //#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/graph.js
 /** @internal */
 const TypeId = "~effect/Graph";
@@ -621,7 +621,7 @@ Object.freeze({
 	}
 });
 //#endregion
-//#region ../../node_modules/.pnpm/oxlint@1.88.0_oxlint-tsgolint@7.0.2004_vite-plus@1.2.0_@opentelemetry+api@1.9.1_@types+_d0d0d8af4627f12721655e70fc027515/node_modules/oxlint/dist/index.js
+//#region ../../node_modules/.pnpm/oxlint@1.88.0_oxlint-tsgolint@7.0.2004_vite-plus@1.3.0_@opentelemetry+api@1.9.1_@types+_73e40377152d496dbecb939f0b8a3193/node_modules/oxlint/dist/index.js
 /**
 * Define an Oxlint configuration with type inference.
 *
@@ -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,17 +943,105 @@ 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, ""));
+	return pipe(token, split(":"), last, getOrElse(() => token), replaceAll(/^!|!$/gu, ""));
 }
 function amount(token, pattern) {
 	return pipe(utility(token), match$1(pattern), flatMap((match) => fromNullishOr(match[1])), map((value) => pipe(parse(value), getOrElse(() => 0))));
 }
 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 (exists(amount(token, /^duration-(\d+)$/u), (value) => value >= 300)) return some("Keep a tween under 300 ms, such as duration-200.");
 	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) {
@@ -952,53 +1062,6 @@ const motionLimits = defineRule({
 	meta: { type: "problem" }
 });
 //#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();
-	const argument = node.arguments[0];
-	if (argument?.type !== "Identifier" && argument?.type !== "MemberExpression") return none();
-	return some(argument);
-}
-function isSingletonArray(input) {
-	if (input.node.type !== "ArrayExpression" || input.node.elements.length !== 1) return false;
-	const element = input.node.elements[0];
-	if (isNullish$1(element) || element.type === "SpreadElement") return false;
-	return input.context.sourceCode.getText(element) === input.context.sourceCode.getText(input.value);
-}
-function wrapsTestedValue(input) {
-	return exists(testedValue(input.test), (value) => input.context.sourceCode.getText(input.kept) === input.context.sourceCode.getText(value) && isSingletonArray({
-		context: input.context,
-		node: input.wrapped,
-		value
-	}));
-}
-function restatesArrayEnsure(input) {
-	if (input.node.test.type === "UnaryExpression" && input.node.test.operator === "!") return wrapsTestedValue({
-		context: input.context,
-		kept: input.node.alternate,
-		test: input.node.test.argument,
-		wrapped: input.node.consequent
-	});
-	return wrapsTestedValue({
-		context: input.context,
-		kept: input.node.consequent,
-		test: input.node.test,
-		wrapped: input.node.alternate
-	});
-}
-const noArrayWrapTernary = defineRule({
-	create: (context) => ({ ConditionalExpression: (node) => {
-		if (restatesArrayEnsure({
-			context,
-			node
-		})) context.report({
-			message: "Use Array.ensure; the ternary restates it.",
-			node
-		});
-	} }),
-	meta: { type: "problem" }
-});
-//#endregion
 //#region src/rules/no-barrel-module.ts
 const noBarrelModule = defineRule({
 	create: (context) => ({
@@ -1025,7 +1088,7 @@ const noCompilerOptOut = defineRule({
 	create: (context) => ({ ExpressionStatement: (node) => {
 		if (node.directive !== "use no memo" && node.directive !== "use no forget") return;
 		context.report({
-			message: "Fix the code React Compiler rejects instead of opting the function out of compilation.",
+			message: "Remove this directive, rerun lint and fix the React Compiler diagnostic it hid.",
 			node
 		});
 	} }),
@@ -1105,7 +1168,7 @@ function isPipeCall(context, node) {
 	});
 }
 function enclosingPipes(context, node) {
-	if (node.type === "Program" || contains$1([
+	if (node.type === "Program" || contains([
 		"ArrowFunctionExpression",
 		"FunctionDeclaration",
 		"FunctionExpression"
@@ -1117,7 +1180,7 @@ function enclosingPipes(context, node) {
 const noDeepPipe = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
 		if (isPipeCall(context, node) && enclosingPipes(context, node) >= 3) context.report({
-			message: "Flatten this pipeline; pipe calls nest at most three deep.",
+			message: "Merge this pipe into its parent, or move it into a named function declaration; pipe calls nest at most three deep.",
 			node
 		});
 	} }),
@@ -1126,7 +1189,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 +1263,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 +1273,15 @@ const noDiscardedFailure = defineRule({
 			importedName: "Effect",
 			node
 		})) return;
-		if (!exists(memberName(node), (name) => contains$1([
+		if (!exists(memberName(node), (name) => contains([
 			"ignore",
+			"ignoreCause",
 			"orDie",
 			"orDieWith"
 		], name))) return;
+		if (exists(memberName(node), (name) => name !== "orDie" && name !== "orDieWith") && 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 +1289,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 +1299,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 +1326,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,14 +1380,14 @@ 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"
 	});
 }
 function isEmptyValue(input) {
-	if (isNullish$1(input.node)) return false;
+	if (isNullish(input.node)) return false;
 	if (input.node.type === "Identifier") return input.node.name === "undefined";
 	if (input.node.type === "Literal") return input.node.value === null || input.node.value === "";
 	if (input.node.type === "ArrayExpression") return isArrayEmpty(input.node.elements);
@@ -1331,7 +1399,7 @@ function isEmptyValue(input) {
 	});
 }
 function isEmptySuccess(input) {
-	if (isNullish$1(input.node)) return false;
+	if (isNullish(input.node)) return false;
 	if (importedMember({
 		context: input.context,
 		importedName: "Effect",
@@ -1372,7 +1440,7 @@ const noEmptyRecovery = defineRule({
 			name,
 			node: returnedExpression(argument)
 		})) context.report({
-			message: "Let the failure flow, or map it to the service’s error; an empty value hides that the work failed.",
+			message: "Let the failure flow, map it with Effect.mapError(cause => ServiceError.make({cause, message})), or use Effect.option when absence is a valid result; an empty value hides the failure.",
 			node: argument
 		});
 	} }),
@@ -1380,19 +1448,20 @@ const noEmptyRecovery = defineRule({
 });
 //#endregion
 //#region src/rules/no-error-message-assertion.ts
+const ASSERT_IDENTITY = "Assert the failure's identity, such as assert.containsSubset(error, {_tag: 'NotFound'}) on Effect.flip's result, never its message.";
 function receiverName(node) {
 	if (node.type === "Identifier") return some(node.name);
 	if (node.type !== "MemberExpression") return none();
 	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) {
@@ -1403,13 +1472,13 @@ const noErrorMessageAssertion = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
 		if (assertsMessage(node)) {
 			context.report({
-				message: "Assert the failure, never its message wording.",
+				message: ASSERT_IDENTITY,
 				node
 			});
 			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({
-			message: "Assert the failure, never its message wording.",
+		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_IDENTITY,
 			node
 		});
 	} }),
@@ -1425,7 +1494,7 @@ function propertyName(node) {
 function hasUnusedSetter(input) {
 	if (input.node.parent.type !== "VariableDeclarator" || input.node.parent.id.type !== "ArrayPattern") return false;
 	const setter = input.node.parent.id.elements[1];
-	if (isNullish$1(setter)) return true;
+	if (isNullish(setter)) return true;
 	if (setter.type !== "Identifier") return false;
 	return pipe(variableFromScope({
 		name: setter.name,
@@ -1434,7 +1503,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,21 +1518,44 @@ 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 exported type, else write ReturnType<typeof f> in the signature that needs it, 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.",
+		message: "Use a flat theme token such as bg-card or bg-muted; gradients are never part of the design.",
 		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 +1589,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"]);
@@ -1521,11 +1613,11 @@ function check(input) {
 		subject: input.node.right
 	})]), map(of));
 }
-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({
+function replaceableGuard(node) {
+	const predicate = node.returnType?.typeAnnotation;
+	const returned = returnedExpression(node);
+	if (predicate?.type !== "TSTypePredicate" || predicate.asserts || predicate.parameterName.type !== "Identifier" || isNullish(returned)) return none();
+	return pipe(check({
 		name: predicate.parameterName.name,
 		node: returned
 	}), map((checks) => pipe(checks, sort(Order), join(" && "))), flatMap((key) => get$2({
@@ -1551,12 +1643,12 @@ function report$3(input) {
 		"typeof === symbol": "isSymbol",
 		"typeof === undefined": "isUndefined"
 	}, key)));
-	map(name, (guard) => {
-		input.context.report({
-			message: `Use Predicate.${guard} instead of this hand-written type guard.`,
-			node: input.node
-		});
-	});
+}
+function report$3(input) {
+	map(replaceableGuard(input.node), (guard) => input.context.report({
+		message: `Use Predicate.${guard} instead of this hand-written type guard.`,
+		node: input.node
+	}));
 }
 const noHandWrittenGuard = defineRule({
 	create: (context) => ({
@@ -1606,13 +1698,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 +1719,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 +1740,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 +1757,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,69 +1775,54 @@ const noNativeEmptinessCheck = defineRule({
 });
 //#endregion
 //#region src/rules/no-native-method-call.ts
-const nativeMethods = [
-	"at",
-	"catch",
-	"charAt",
-	"charCodeAt",
-	"codePointAt",
-	"concat",
-	"endsWith",
-	"entries",
-	"every",
-	"fill",
-	"filter",
-	"finally",
-	"find",
-	"findIndex",
-	"findLast",
-	"findLastIndex",
-	"flat",
-	"flatMap",
-	"forEach",
-	"includes",
-	"indexOf",
-	"join",
-	"keys",
-	"lastIndexOf",
-	"localeCompare",
-	"map",
-	"match",
-	"matchAll",
-	"normalize",
-	"padEnd",
-	"padStart",
-	"pop",
-	"push",
-	"reduce",
-	"reduceRight",
-	"repeat",
-	"replace",
-	"replaceAll",
-	"reverse",
-	"shift",
-	"slice",
-	"some",
-	"sort",
-	"splice",
-	"split",
-	"startsWith",
-	"substring",
-	"then",
-	"toLocaleLowerCase",
-	"toLocaleUpperCase",
-	"toLowerCase",
-	"toReversed",
-	"toSorted",
-	"toSpliced",
-	"toUpperCase",
-	"trim",
-	"trimEnd",
-	"trimStart",
-	"unshift",
-	"values",
-	"with"
-];
+const REPLACEMENTS = {
+	at: "Array.get or String.at",
+	catch: "Effect.tryPromise and Effect.catchTag",
+	charAt: "String.charAt",
+	charCodeAt: "String.charCodeAt",
+	codePointAt: "String.codePointAt",
+	concat: "Array.appendAll or String.concat",
+	endsWith: "String.endsWith",
+	entries: "Array.map(items, (item, index) => [index, item]), Record.toEntries or HashMap.entries",
+	fill: "Array.replicate or Array.makeBy",
+	finally: "Effect.ensuring",
+	flat: "Array.flatten",
+	includes: "Array.contains or String.includes",
+	indexOf: "Array.findFirstIndex or String.indexOf",
+	keys: "Record.keys or HashMap.keys",
+	lastIndexOf: "Array.findLastIndex or String.lastIndexOf",
+	localeCompare: "String.localeCompare",
+	match: "String.match",
+	matchAll: "String.matchAll",
+	normalize: "String.normalize",
+	padEnd: "String.padEnd",
+	padStart: "String.padStart",
+	pop: "Array.last and Array.dropRight",
+	push: "Array.append",
+	repeat: "String.repeat",
+	replace: "String.replace",
+	replaceAll: "String.replaceAll",
+	reverse: "Array.reverse",
+	shift: "Array.head and Array.drop",
+	slice: "Array.take, Array.drop or String.slice",
+	sort: "Array.sort(items, Order.mapInput(...))",
+	splice: "Array.remove or Array.insertAt",
+	split: "String.split",
+	startsWith: "String.startsWith",
+	substring: "String.substring",
+	then: "Effect.tryPromise and Effect.map",
+	toLocaleLowerCase: "String.toLowerCase",
+	toLocaleUpperCase: "String.toUpperCase",
+	toLowerCase: "String.toLowerCase",
+	toSpliced: "Array.remove",
+	toUpperCase: "String.toUpperCase",
+	trim: "String.trim",
+	trimEnd: "String.trimEnd",
+	trimStart: "String.trimStart",
+	unshift: "Array.prepend",
+	values: "Record.values or HashMap.values",
+	with: "Array.replace"
+};
 function freshRegExpFlags(input) {
 	if (input.node.type === "Literal" && hasProperty(input.node, "regex")) return some(pipe(input.context.sourceCode.getText(input.node), split("/"), last));
 	if (input.node.type !== "NewExpression" && input.node.type !== "CallExpression" || input.node.callee.type !== "Identifier" || input.node.callee.name !== "RegExp") return none();
@@ -1755,11 +1831,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;
@@ -1771,7 +1842,7 @@ function chainRoot(node) {
 	return node;
 }
 function isYieldedService(node) {
-	if (node?.type !== "YieldExpression" || !node.delegate || isNullish$1(node.argument)) return false;
+	if (node?.type !== "YieldExpression" || !node.delegate || isNullish(node.argument)) return false;
 	if (node.argument.type === "Identifier") return matches(/^[A-Z]/u)(node.argument.name);
 	return node.argument.type === "MemberExpression" && exists(memberName(node.argument), (name) => matches(/^[A-Z]/u)(name));
 }
@@ -1784,7 +1855,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;
@@ -1798,10 +1873,9 @@ const noNativeMethodCall = defineRule({
 			context,
 			receiver: node.callee.object
 		})) return;
-		const receiver = node.callee.object;
 		const regExpFlags = freshRegExpFlags({
 			context,
-			node: receiver
+			node: node.callee.object
 		});
 		if (isSome(regExpFlags) && exists(memberName(node.callee), (name) => name === "test" || name === "exec" && exists(flatten$1(regExpFlags), (flags) => !pipe(flags, includes("g"))))) {
 			context.report({
@@ -1810,62 +1884,21 @@ 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([
 			"entries",
 			"keys",
 			"values"
-		], name) || isArrayEmpty(node.arguments) || receiver.type === "Identifier" && receiver.name === "Object"), map((name) => context.report({
-			message: `Replace .${name}() on a native array, string, record, or Promise with its Effect Array, String, Record, or Effect function; a third-party API's own method stays, with an inline disable and its reason.`,
+		], name) || isArrayEmpty(node.arguments)), flatMap((name) => pipe(get$2(REPLACEMENTS, name), map((replacement) => ({
+			name,
+			replacement
+		})))), map((method) => context.report({
+			message: `Use ${method.replacement} instead of the native .${method.name}(); a third-party object's own method stays, with an inline disable naming it.`,
 			node: node.callee
 		})));
 	} }),
 	meta: { type: "problem" }
 });
 //#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";
-}
-function testsNullish(input) {
-	if (input.node.type === "UnaryExpression" && input.node.operator === "!") return testsNullish({
-		context: input.context,
-		node: input.node.argument
-	});
-	if (input.node.type === "BinaryExpression" && (input.node.operator === "===" || input.node.operator === "!==")) return isNullish({
-		context: input.context,
-		node: input.node.left
-	}) || isNullish({
-		context: input.context,
-		node: input.node.right
-	});
-	return input.node.type === "CallExpression" && input.node.callee.type === "MemberExpression" && importedMember({
-		context: input.context,
-		importedName: "Predicate",
-		node: input.node.callee
-	}) && exists(memberName(input.node.callee), (name) => contains$1(nullishPredicates, name));
-}
-const noNullishTernary = defineRule({
-	create: (context) => ({ ConditionalExpression: (node) => {
-		if (testsNullish({
-			context,
-			node: node.test
-		})) context.report({
-			message: "Use ?? for a default, or Option for a value that may be absent, instead of a nullish ternary.",
-			node
-		});
-	} }),
-	meta: { type: "problem" }
-});
-//#endregion
 //#region src/rules/no-option-value-access.ts
 function checks(input) {
 	if (input.test.type === "LogicalExpression" && input.test.operator === input.operator) return checks({
@@ -1883,7 +1916,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 +1953,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 +1967,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 (isNullish(node.parent) || node.parent.type === "Program") return false;
+	if (contains(FUNCTIONS, node.parent.type)) return true;
 	return insideFunction(node.parent);
 }
 function sameRoot(input) {
@@ -1965,9 +1986,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(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(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 (isNullish(input.node.parent) || input.node.parent === input.block) return false;
+	if (contains(input.types, input.node.parent.type)) return true;
 	return enclosed({
 		...input,
 		node: input.node.parent
@@ -1986,24 +2056,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 +2065,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 +2093,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 +2151,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 +2187,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 +2228,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 +2376,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"
@@ -2318,16 +2402,10 @@ const noRedundantUseRefNullType = defineRule({
 //#region src/rules/no-redundant-variable-annotation.ts
 const noRedundantVariableAnnotation = defineRule({
 	create: (context) => ({ VariableDeclarator: (node) => {
-		if (node.init === null || isNullish$1(node.id.typeAnnotation)) return;
-		if (node.init.type === "ArrayExpression" && isArrayEmpty(node.init.elements)) {
-			context.report({
-				message: "Write Array.empty<T>() instead of annotating an empty array.",
-				node: node.id.typeAnnotation
-			});
-			return;
-		}
-		if (node.init.type === "TSAsExpression" && context.sourceCode.getText(node.init.typeAnnotation) === context.sourceCode.getText(node.id.typeAnnotation.typeAnnotation)) context.report({
-			message: "Drop this annotation; inference gives the same type.",
+		if (node.init?.type !== "ArrayExpression" || isNullish(node.id.typeAnnotation)) return;
+		if (!isArrayEmpty(node.init.elements)) return;
+		context.report({
+			message: "Write Array.empty<T>() instead of annotating an empty array.",
 			node: node.id.typeAnnotation
 		});
 	} }),
@@ -2367,7 +2445,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 +2455,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 +2475,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
 	}))) {
@@ -2500,7 +2578,7 @@ function recursive(input) {
 const noReturnType = defineRule({
 	create: (context) => {
 		function check(node) {
-			if (isNullish$1(node.returnType) || node.body === null || node.returnType.typeAnnotation.type === "TSTypePredicate" || node.parent.type === "CallExpression" && importedMember({
+			if (isNullish(node.returnType) || node.body === null || node.returnType.typeAnnotation.type === "TSTypePredicate" || node.parent.type === "CallExpression" && importedMember({
 				context,
 				importedName: "Schema",
 				node: node.parent.callee,
@@ -2524,7 +2602,7 @@ const noReturnType = defineRule({
 });
 //#endregion
 //#region src/rules/no-single-use-value.ts
-const repeating = [
+const REPEATING = [
 	"ArrowFunctionExpression",
 	"DoWhileStatement",
 	"ForInStatement",
@@ -2539,7 +2617,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
@@ -2547,7 +2625,7 @@ function runsOnce(input) {
 }
 function climb(input) {
 	if (input.node === input.statement) return true;
-	if (isNullish$1(input.node.parent)) return false;
+	if (isNullish(input.node.parent)) return false;
 	return runsOnce({
 		child: input.node,
 		node: input.node.parent,
@@ -2562,8 +2640,16 @@ function insideConditional(input) {
 		node: input.node.parent
 	});
 }
-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));
+function candidate(context, 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([
+		"ArrowFunctionExpression",
+		"FunctionExpression",
+		"JSXElement",
+		"JSXFragment"
+	], unwrapped(node.init).type) && !(node.init.type === "CallExpression" && isSchemaOperationCall({
+		context,
+		node: node.init
+	})) && !(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 +2667,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(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(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 +2730,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 +2747,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,
@@ -2641,7 +2782,7 @@ const noSingleUseValue = defineRule({
 			TaggedTemplateExpression: effect,
 			UpdateExpression: effect,
 			VariableDeclarator: (node) => {
-				if (candidate(node)) update(candidates, append(node));
+				if (candidate(context, node)) update(candidates, append(node));
 			},
 			YieldExpression: effect
 		};
@@ -2652,6 +2793,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;
@@ -2673,7 +2830,7 @@ const noStoredSchemaOperation = defineRule({
 const noSwitchStatement = defineRule({
 	create: (context) => ({ SwitchStatement: (node) => {
 		context.report({
-			message: "Use Match instead of switch.",
+			message: "Use pipe(Match.value(x), Match.tag(...) or Match.when(...), Match.exhaustive) instead of switch.",
 			node
 		});
 	} }),
@@ -2715,7 +2872,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,
@@ -2731,7 +2888,7 @@ function forwardedChain(input) {
 function exactForwardingFunction(input) {
 	const names = pipe(input.node.params, map$1(parameterName), getSomes);
 	const returned = returnedExpression(input.node);
-	if (input.node.async || input.node.generator || isArrayEmpty(names) || names.length !== input.node.params.length || isNullish$1(returned)) return false;
+	if (input.node.async || input.node.generator || isArrayEmpty(names) || names.length !== input.node.params.length || isNullish(returned)) return false;
 	if (returned.type === "Identifier") return names.length === 1 && returned.name === names[0];
 	return returned.type === "NewExpression" && returned.callee.type === "Identifier" && forwarded({
 		args: returned.arguments,
@@ -2789,7 +2946,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 +2961,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
@@ -2827,10 +2984,17 @@ function singleUseLayerPart(input) {
 		});
 	}));
 }
+function isComponent(node) {
+	if (node.type === "FunctionDeclaration") return exists(fromNullishOr(node.id), (id) => matches(/^[A-Z]/u)(id.name));
+	return node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier" && matches(/^[A-Z]/u)(node.parent.id.name);
+}
+function isCatchHandler(node) {
+	return node.parent.type === "Property" && !node.parent.computed && node.parent.key.type === "Identifier" && node.parent.key.name === "catch";
+}
 const noTrivialIndirection = defineRule({
 	create: (context) => ({
 		ArrowFunctionExpression: (node) => {
-			if ((node.parent.type === "VariableDeclarator" || node.parent.type === "Property") && (exactForwardingFunction({
+			if ((node.parent.type === "VariableDeclarator" || node.parent.type === "Property") && !isComponent(node) && !isCatchHandler(node) && (exactForwardingFunction({
 				context,
 				node
 			}) || singleUseThunk({
@@ -2848,7 +3012,7 @@ const noTrivialIndirection = defineRule({
 			});
 		},
 		FunctionDeclaration: (node) => {
-			if (exactForwardingFunction({
+			if (!isComponent(node) && (exactForwardingFunction({
 				context,
 				node
 			}) || singleUseThunk({
@@ -2857,7 +3021,7 @@ const noTrivialIndirection = defineRule({
 			}) || singleCallerWrapper({
 				context,
 				node
-			})) context.report({
+			}))) context.report({
 				message: indirectionMessage({
 					context,
 					node
@@ -2866,7 +3030,7 @@ const noTrivialIndirection = defineRule({
 			});
 		},
 		FunctionExpression: (node) => {
-			if ((node.parent.type === "VariableDeclarator" || node.parent.type === "Property" || node.parent.type === "MethodDefinition" && node.parent.override !== true) && (exactForwardingFunction({
+			if ((node.parent.type === "VariableDeclarator" || node.parent.type === "Property" || node.parent.type === "MethodDefinition" && node.parent.override !== true) && !isComponent(node) && !isCatchHandler(node) && (exactForwardingFunction({
 				context,
 				node
 			}) || singleUseThunk({
@@ -2895,7 +3059,7 @@ const noTrivialIndirection = defineRule({
 				context,
 				node
 			})) context.report({
-				message: "Use the immutable source binding directly.",
+				message: `Use ${context.sourceCode.getText(node.init)} directly; this name is an alias.`,
 				node
 			});
 			if (singleUseLiteral({
@@ -2917,13 +3081,57 @@ 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
+function enclosingFunction(node) {
+	if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression") return some(node);
+	return flatMap(fromNullishOr(node.parent), enclosingFunction);
+}
 const noTypeof = defineRule({
 	create: (context) => ({ UnaryExpression: (node) => {
 		if (node.operator !== "typeof") return;
 		if (node.argument.type === "Identifier" && !exists(variableFor(context, node.argument), (variable) => isArrayNonEmpty(variable.defs))) return;
+		if (exists(enclosingFunction(node), (fn) => isSome(replaceableGuard(fn)))) return;
 		context.report({
-			message: "Replace typeof with a Predicate guard such as Predicate.isString.",
+			message: "Replace typeof with its Predicate guard: Predicate.isString, isNumber, isBoolean, isFunction, isObject or isUndefined.",
 			node
 		});
 	} }),
@@ -3001,7 +3209,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 +3232,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 +3293,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 +3334,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 +3344,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 +3423,7 @@ const schemaTypePair = defineRule({
 });
 //#endregion
 //#region src/oxlint.ts
-const reactLegacyApis = [
+const REACT_LEGACY_APIS = [
 	"Component",
 	"PureComponent",
 	"createRef",
@@ -3224,9 +3432,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 +3453,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 +3468,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",
@@ -3298,11 +3506,7 @@ const oxlint = defineConfig({
 	},
 	overrides: [
 		{
-			files: [
-				"**/*.config.ts",
-				"**/app.plugin.js",
-				"**/main.*"
-			],
+			files: ["**/*.config.ts", "**/app.plugin.js"],
 			rules: { "import/no-default-export": "off" }
 		},
 		{
@@ -3331,7 +3535,7 @@ const oxlint = defineConfig({
 			rules: { "react/rules-of-hooks": "off" }
 		},
 		{
-			files: ["**/*.test.ts", "**/*.test.tsx"],
+			files: ["**/*.test.ts"],
 			rules: { "@deslop/coding-standards/no-discarded-failure": "off" }
 		},
 		{
@@ -3356,8 +3560,8 @@ 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",
 		"@deslop/coding-standards/no-compiler-opt-out": "error",
 		"@deslop/coding-standards/no-component-atom-allocation": "error",
@@ -3370,6 +3574,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",
@@ -3378,7 +3583,6 @@ const oxlint = defineConfig({
 		"@deslop/coding-standards/no-native-control": "error",
 		"@deslop/coding-standards/no-native-emptiness-check": "error",
 		"@deslop/coding-standards/no-native-method-call": "error",
-		"@deslop/coding-standards/no-nullish-ternary": "error",
 		"@deslop/coding-standards/no-option-value-access": "error",
 		"@deslop/coding-standards/no-property-alias": "error",
 		"@deslop/coding-standards/no-readonly-type-syntax": "error",
@@ -3389,9 +3593,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",
@@ -3412,6 +3618,8 @@ const oxlint = defineConfig({
 		"effecttsgo/global-timers": "error",
 		"effecttsgo/global-timers-in-effect": "error",
 		"effecttsgo/node-builtin-import": "error",
+		"effecttsgo/prefer-effect-array": "error",
+		"effecttsgo/prefer-effect-record": "error",
 		"effecttsgo/prefer-schema-over-json": "error",
 		"effecttsgo/process-env": "error",
 		"effecttsgo/process-env-in-effect": "error",
@@ -3430,9 +3638,11 @@ const oxlint = defineConfig({
 		"effecttsgo/effect-in-void-success": "error",
 		"effecttsgo/effect-map-flatten": "error",
 		"effecttsgo/effect-map-void": "error",
+		"effecttsgo/effect-sleep-zero-to-yield-now": "error",
 		"effecttsgo/effect-succeed-with-void": "error",
 		"effecttsgo/flat-map-ignored-param-to-and-then": "error",
 		"effecttsgo/flat-map-to-map": "error",
+		"effecttsgo/flat-map-to-tap": "error",
 		"effecttsgo/floating-effect": "error",
 		"effecttsgo/floating-effect-in-vitest": "error",
 		"effecttsgo/layer-merge-all-with-dependencies": "error",
@@ -3470,11 +3680,10 @@ const oxlint = defineConfig({
 		"effecttsgo/catch-all-to-map-error": "error",
 		"effecttsgo/catch-chain-to-first-success-of": "error",
 		"effecttsgo/catch-conditional-refail-to-catch-if": "error",
-		"effecttsgo/catch-die-to-or-die": "error",
 		"effecttsgo/catch-tag-to-catch-reason": "error",
-		"effecttsgo/catch-to-ignore": "error",
 		"effecttsgo/catch-to-or-else-succeed": "error",
 		"effecttsgo/catch-unfailable-effect": "error",
+		"effecttsgo/error-payload-shadows-name": "error",
 		"effecttsgo/flat-map-conditional-to-filter-or-fail": "error",
 		"effecttsgo/global-error-in-effect-catch": "error",
 		"effecttsgo/global-error-in-effect-failure": "error",
@@ -3483,10 +3692,8 @@ const oxlint = defineConfig({
 		"effecttsgo/redundant-map-error": "error",
 		"effecttsgo/redundant-or-die": "error",
 		"effecttsgo/timeout-catch-tag-to-timeout-or-else": "error",
-		"effecttsgo/unknown-in-effect-catch": "error",
 		"effecttsgo/class-self-mismatch": "error",
 		"effecttsgo/deterministic-keys": "error",
-		"effecttsgo/generic-effect-services": "error",
 		"effecttsgo/instance-of-schema": "error",
 		"effecttsgo/new-schema-class": "error",
 		"effecttsgo/obsolete-match-import": "error",
@@ -3499,6 +3706,7 @@ const oxlint = defineConfig({
 		"effecttsgo/schema-number": "error",
 		"effecttsgo/schema-struct-with-tag": "error",
 		"effecttsgo/schema-sync-in-effect": "error",
+		"effecttsgo/schema-union-of-literals": "error",
 		"effecttsgo/service-not-as-class": "error",
 		"effecttsgo/unnecessary-typeof-type": "error",
 		"typescript/consistent-generic-constructors": "error",
@@ -3556,7 +3764,7 @@ const oxlint = defineConfig({
 		"typescript/unbound-method": "error",
 		"typescript/unified-signatures": "error",
 		"typescript/prefer-as-const": "error",
-		"typescript/prefer-nullish-coalescing": "error",
+		"typescript/prefer-nullish-coalescing": ["error", { ignoreTernaryTests: true }],
 		"typescript/prefer-optional-chain": "error",
 		"typescript/restrict-plus-operands": "error",
 		"typescript/restrict-template-expressions": "error",
@@ -3591,8 +3799,8 @@ const oxlint = defineConfig({
 		"no-restricted-imports": ["error", {
 			paths: [
 				{
-					importNames: reactLegacyApis,
-					message: reactLegacyMessage,
+					importNames: REACT_LEGACY_APIS,
+					message: REACT_LEGACY_MESSAGE,
 					name: "react"
 				},
 				{
@@ -3621,6 +3829,10 @@ const oxlint = defineConfig({
 				}
 			],
 			patterns: [
+				{
+					message: "Prove a screen in the browser; no UI tests.",
+					regex: "^(?:@testing-library/|jsdom$|happy-dom$)"
+				},
 				{
 					message: "Use public package exports.",
 					regex: "^@[^/]+/[^/]+/(?:src|lib)(?:/|$)"
@@ -3655,7 +3867,6 @@ const oxlint = defineConfig({
 				}
 			]
 		}],
-		"array-callback-return": "error",
 		"max-depth": ["error", 3],
 		"max-nested-callbacks": ["error", 6],
 		"no-cond-assign": "error",
@@ -3701,17 +3912,13 @@ const oxlint = defineConfig({
 				name: "Error"
 			},
 			{
-				message: mapMessage,
+				message: MAP_MESSAGE,
 				name: "Map"
 			},
 			{
 				message: "Import Number from 'effect'.",
 				name: "Number"
 			},
-			{
-				message: "Use Record or Struct from 'effect'.",
-				name: "Object"
-			},
 			{
 				message: "Use Number.parse.",
 				name: "parseFloat"
@@ -3729,7 +3936,7 @@ const oxlint = defineConfig({
 				name: "Reflect"
 			},
 			{
-				message: setMessage,
+				message: SET_MESSAGE,
 				name: "Set"
 			},
 			{
@@ -3752,17 +3959,23 @@ const oxlint = defineConfig({
 				property: "pipe"
 			},
 			{
-				allowObjects: ["Predicate"],
-				message: "Use Predicate.hasProperty.",
-				property: "hasOwnProperty"
+				allowProperties: [
+					"entries",
+					"fromEntries",
+					"hasOwn",
+					"keys",
+					"values"
+				],
+				message: "Use Record or Struct from 'effect'.",
+				object: "Object"
 			},
-			...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 +3999,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
@@ -3898,16 +4111,22 @@ const oxlint = defineConfig({
 		"no-ternary": "error",
 		"no-throw-literal": "error",
 		"no-unmodified-loop-condition": "error",
-		"no-unneeded-ternary": "error",
 		"no-unreachable-loop": "error",
 		"no-unsafe-finally": "error",
 		"no-unsafe-optional-chaining": ["error", { disallowArithmeticOperators: true }],
 		"no-unused-expressions": "error",
 		"no-unused-vars": ["error", {
+			args: "all",
 			argsIgnorePattern: "^_",
 			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",
@@ -3922,18 +4141,23 @@ const oxlint = defineConfig({
 		"no-void": "error",
 		"object-shorthand": "error",
 		"oxc/branches-sharing-code": "error",
-		"oxc/no-accumulating-spread": "error",
-		"oxc/no-map-spread": "error",
 		"oxc/only-used-in-recursion": "error",
 		"prefer-arrow-callback": "error",
 		"prefer-const": ["error", { destructuring: "all" }],
 		"prefer-template": "error",
 		"require-unicode-regexp": "error",
+		"jsx-a11y/alt-text": "error",
+		"jsx-a11y/aria-props": "error",
+		"jsx-a11y/aria-proptypes": "error",
 		"jsx-a11y/autocomplete-valid": "error",
 		"jsx-a11y/click-events-have-key-events": "error",
 		"jsx-a11y/control-has-associated-label": "error",
+		"jsx-a11y/heading-has-content": "error",
 		"jsx-a11y/interactive-supports-focus": "error",
 		"jsx-a11y/label-has-associated-control": "error",
+		"jsx-a11y/no-aria-hidden-on-focusable": "error",
+		"jsx-a11y/role-has-required-aria-props": "error",
+		"jsx-a11y/tabindex-no-positive": "error",
 		"react-doctor/no-aria-invalid-without-description": "error",
 		"react-doctor/no-call-component-as-function": "error",
 		"react-doctor/no-controlled-input-value-without-state-update": "error",
@@ -4002,7 +4226,6 @@ const oxlint = defineConfig({
 		"react/jsx-no-script-url": "error",
 		"react/jsx-no-target-blank": "error",
 		"react/jsx-no-useless-fragment": "error",
-		"react/memo-dependencies": "error",
 		"react/no-array-index-key": "error",
 		"react/no-children-prop": "error",
 		"react/no-clone-element": "error",
@@ -4010,8 +4233,6 @@ const oxlint = defineConfig({
 		"react/no-object-type-as-default-prop": "error",
 		"react/no-react-children": "error",
 		"react/no-unknown-property": "error",
-		"react/no-unstable-nested-components": ["error", { allowAsProps: true }],
-		"react/preserve-manual-memoization": "error",
 		"react/purity": "error",
 		"react/refs": "error",
 		"react/rule-suppression": "error",
@@ -4020,9 +4241,7 @@ const oxlint = defineConfig({
 		"react/set-state-in-effect": "error",
 		"react/set-state-in-render": "error",
 		"react/static-components": "error",
-		"react/use-memo": "error",
 		"react/void-dom-elements-no-children": "error",
-		"react/void-use-memo": "error",
 		"shadcn/no-arbitrary-values": "error",
 		"shadcn/no-inline-styles": "error",
 		"shadcn/no-raw-colors": "error",
@@ -4044,12 +4263,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",
@@ -4063,10 +4282,9 @@ const oxlint = defineConfig({
 		"unicorn/no-process-exit": "error",
 		"unicorn/no-static-only-class": "error",
 		"unicorn/no-useless-fallback-in-spread": "error",
-		"unicorn/no-useless-length-check": "error",
 		"unicorn/no-useless-spread": "error",
-		"unicorn/prefer-logical-operator-over-ternary": "error",
 		"unicorn/prefer-optional-catch-binding": "error",
+		"unicorn/prefer-string-replace-all": "error",
 		"use-isnan": "error"
 	},
 	settings: {
@@ -4084,8 +4302,8 @@ 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,
 		"no-compiler-opt-out": noCompilerOptOut,
 		"no-component-atom-allocation": noComponentAtomAllocation,
@@ -4098,6 +4316,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,
@@ -4106,7 +4325,6 @@ var oxlint_default = definePlugin({
 		"no-native-control": noNativeControl,
 		"no-native-emptiness-check": noNativeEmptinessCheck,
 		"no-native-method-call": noNativeMethodCall,
-		"no-nullish-ternary": noNullishTernary,
 		"no-option-value-access": noOptionValueAccess,
 		"no-property-alias": noPropertyAlias,
 		"no-readonly-type-syntax": noReadonlyTypeSyntax,
@@ -4117,9 +4335,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,