@deslop/coding-standards 0.1.1082 → 0.1.1085

package/dist/oxlint.js

@@ -1,4 +1,4 @@
-import { $ as prepend, $t as strictEqual, A as filter$1, Ar as isString, At as getOrUndefined, B as getSomes, Bt as zipWith, C as contains$1, Cr as isNullish$1, Ct as filter, D as empty, Dt as fromNullishOr, E as dedupeWith, Et as flatten$1, F as flatMap$1, Ft as match, Gn as NodeInspectSymbol, H as isArrayEmpty, I as flatten, It as none, K as join, Kr as pipeArguments, L as forEach, Lr as constVoid, Lt as orElse, M as findFirst, Mt as isSome, N as findFirstIndex, O as ensure, Or as isReadonlyObject, Ot as fromUndefinedOr, Pr as constFalse, Pt as map, Q as of, Rt as some, S as appendAll, St as exists, T as dedupe, Tt as flatMap, U as isArrayNonEmpty, Ur as pipe, V as head, Y as map$1, Z as matchRight, at as get$2, bt as all, c as make$3, cr as number, ct as remove, d as includes, f as match$1, ft as fromOption, g as trim, gr as isBoolean, h as startsWith, ir as symbol, it as fromEntries, j as filterMap, k as every, kr as isRegExp, kt as getOrElse, l as update, lr as optimize, lt as values, m as split, mr as hasProperty, nr as byReferenceUnsafe, nt as sort, o as toArray, or as combine, p as replaceAll, pr as symbol$1, q as last, r as make$2, rr as equals, rt as take, s as get$3, sr as hash, t as append$1, tt as some$1, u as Order, ur as string, w as containsWith, wr as isNumber, wt as firstSomeOf, x as append, xr as isNotNullish, xt as contains, y as TaggedError, z as get$1, zr as dual, zt as toArray$1 } from "./MutableList-BCF17jPH.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;
@@ -890,9 +912,159 @@ function singleUseThunk(input) {
 	})), exists((variable) => filter$1(variable.references, (reference) => reference.isRead()).length === 1));
 }
 //#endregion
+//#region src/rules/explicit-effect-concurrency.ts
+function statesConcurrency(node) {
+	if (node === void 0) return false;
+	if (node.type !== "ObjectExpression") return true;
+	return some$1(node.properties, (property) => property.type === "SpreadElement" || property.key.type === "Identifier" && property.key.name === "concurrency" || property.key.type === "Literal" && property.key.value === "concurrency");
+}
+function isFunction(node) {
+	return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+}
+const explicitEffectConcurrency = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (node.callee.type !== "MemberExpression" || !importedMember({
+			context,
+			importedName: "Effect",
+			node: node.callee
+		})) return;
+		const name = memberName(node.callee);
+		if (!exists(name, (method) => method === "all" || method === "forEach")) return;
+		const index = match$2(contains$1(name, "all") || isFunction(node.arguments[0]) || node.arguments[1]?.type === "ObjectExpression", {
+			onFalse: () => 2,
+			onTrue: () => 1
+		});
+		if (statesConcurrency(node.arguments[index])) return;
+		context.report({
+			message: "Choose the concurrency: {concurrency: 'unbounded'} for independent effects, {concurrency: 1} when order or a shared resource matters.",
+			node: node.callee
+		});
+	} }),
+	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, ""));
+}
+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 (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("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) {
+	pipe(split(text, /\s+/u), map$1(violation), getSomes, head, map((message) => context.report({
+		message,
+		node
+	})));
+}
+const motionLimits = defineRule({
+	create: (context) => ({
+		Literal: (node) => {
+			if (isString(node.value)) check$1(context, node, node.value);
+		},
+		TemplateElement: (node) => {
+			check$1(context, node, node.value.raw);
+		}
+	}),
+	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();
+	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);
@@ -937,6 +1109,63 @@ const noArrayWrapTernary = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-barrel-module.ts
+const noBarrelModule = defineRule({
+	create: (context) => ({
+		ExportAllDeclaration: (node) => {
+			context.report({
+				message: "Import from the module that defines each name; never re-export a whole module.",
+				node
+			});
+		},
+		Program: (node) => {
+			const statements = filter$1(node.body, (statement) => statement.type !== "ImportDeclaration");
+			if (isArrayEmpty(statements) || !every(statements, (statement) => statement.type === "ExportNamedDeclaration" && statement.source !== null)) return;
+			context.report({
+				message: "Import from the defining modules instead of a file that only re-exports them.",
+				node
+			});
+		}
+	}),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-compiler-opt-out.ts
+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.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-component-atom-allocation.ts
+const componentOrHook = matches(/^(?:[A-Z]|use[A-Z])/u);
+const readsOrWrites = matches(/^(?:is[A-Z]|get|set$|update$|modify$|refresh$|mount$|batch$|toStream)/u);
+function renderingFunction(node) {
+	return pipe(fromNullishOr(node.parent), flatMap((parent) => {
+		if ((parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") && exists(bindingName(parent), componentOrHook)) return some(parent);
+		return renderingFunction(parent);
+	}));
+}
+const noComponentAtomAllocation = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (node.callee.type !== "MemberExpression" || node.callee.object.type !== "Identifier" || node.callee.object.name !== "Atom" || !isImportBinding({
+			context,
+			node: node.callee.object,
+			source: /reactivity|atom/u
+		}) || exists(memberName(node.callee), readsOrWrites) || isNone(renderingFunction(node))) return;
+		context.report({
+			message: "Declare the atom at module level, or in Atom.family keyed by the prop; an atom made during render is a new atom on every render.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/no-constant-function.ts
 function isConstantFunction(input) {
 	if (input.node.async || input.node.generator || isArrayNonEmpty(input.node.params) || isNotNullish(input.node.typeParameters)) return false;
@@ -986,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"
@@ -1007,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,
@@ -1081,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({
@@ -1088,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
 		});
 	} }),
@@ -1102,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."
@@ -1117,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({
@@ -1139,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
@@ -1186,6 +1419,80 @@ const noEffectPropertyArrow = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-empty-recovery.ts
+function calleeOf(node) {
+	if (node.type === "CallExpression" && node.callee.type !== "Super") return node.callee;
+	return node;
+}
+function isEffectEmpty(input) {
+	const member = calleeOf(input.node);
+	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 (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);
+	if (input.node.type === "ObjectExpression") return isArrayEmpty(input.node.properties);
+	if (input.node.type === "TemplateLiteral") return isArrayEmpty(input.node.expressions) && every(input.node.quasis, (quasi) => quasi.value.raw === "");
+	return isEffectEmpty({
+		context: input.context,
+		node: input.node
+	});
+}
+function isEmptySuccess(input) {
+	if (isNullish$1(input.node)) return false;
+	if (importedMember({
+		context: input.context,
+		importedName: "Effect",
+		node: input.node,
+		propertyName: "void"
+	})) return true;
+	return input.node.type === "CallExpression" && input.node.callee.type !== "Super" && importedMember({
+		context: input.context,
+		importedName: "Effect",
+		node: input.node.callee,
+		propertyName: "succeed"
+	}) && every(input.node.arguments, (argument) => argument.type !== "SpreadElement" && isEmptyValue({
+		context: input.context,
+		node: argument
+	}));
+}
+function recoversEmpty(input) {
+	if (input.name === "orElseSucceed") return isEmptyValue({
+		context: input.context,
+		node: input.node
+	});
+	return isEmptySuccess({
+		context: input.context,
+		node: input.node
+	});
+}
+const noEmptyRecovery = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (node.callee.type !== "MemberExpression" || !importedMember({
+			context,
+			importedName: "Effect",
+			node: node.callee
+		})) return;
+		const name = pipe(memberName(node.callee), getOrElse(() => ""));
+		if (!pipe(name, startsWith("catch")) && !pipe(name, startsWith("orElse"))) return;
+		for (const argument of node.arguments) if ((argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression") && recoversEmpty({
+			context,
+			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.",
+			node: argument
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/no-error-message-assertion.ts
 function receiverName(node) {
 	if (node.type === "Identifier") return some(node.name);
@@ -1193,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) {
@@ -1215,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
 		});
@@ -1241,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) => {
@@ -1256,6 +1563,49 @@ 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;
+function report$4(context, node) {
+	context.report({
+		message: "Use a flat theme color; 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);
+		},
+		TemplateElement: (node) => {
+			if (GRADIENT.test(node.value.raw)) report$4(context, node);
+		}
+	}),
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/no-hand-written-guard.ts
 function isSubject(input) {
 	return input.node.type === "Identifier" && input.node.name === input.name;
@@ -1284,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"]);
@@ -1308,11 +1658,11 @@ function check(input) {
 		subject: input.node.right
 	})]), map(of));
 }
-function report$2(input) {
+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({
@@ -1337,8 +1687,7 @@ function report$2(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
@@ -1348,19 +1697,19 @@ function report$2(input) {
 const noHandWrittenGuard = defineRule({
 	create: (context) => ({
 		ArrowFunctionExpression: (node) => {
-			report$2({
+			report$3({
 				context,
 				node
 			});
 		},
 		FunctionDeclaration: (node) => {
-			report$2({
+			report$3({
 				context,
 				node
 			});
 		},
 		FunctionExpression: (node) => {
-			report$2({
+			report$3({
 				context,
 				node
 			});
@@ -1393,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]
@@ -1415,22 +1763,32 @@ 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);
+	if (node.type === "JSXExpressionContainer") return classStrings(node.expression);
+	if (node.type === "CallExpression") return flatMap$1(node.arguments, classStrings);
+	if (node.type === "ConditionalExpression") return flatMap$1([node.consequent, node.alternate], classStrings);
+	if (node.type === "LogicalExpression") return classStrings(node.right);
+	if (node.type === "ArrayExpression") return flatMap$1(filter$1(node.elements, isNotNull), classStrings);
+	return empty();
+}
 const noNativeControl = defineRule({
 	create: (context) => ({ JSXOpeningElement: (node) => {
 		if (node.name.type !== "JSXIdentifier") return;
 		const name = node.name.name;
-		map(get$2(primitives, name), (primitive) => {
-			const styled = pipe(node.attributes, findFirst((attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "className"), flatMap((attribute) => {
-				if (attribute.type !== "JSXAttribute" || attribute.value?.type !== "Literal") return none();
-				return fromNullishOr(attribute.value.value);
-			}), exists((value) => some$1(split(value, /\s+/u), matches(controlStyle))));
+		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(CONTROL_STYLE)))));
 			if (name !== "select" && !styled) return;
 			context.report({
 				message: `Use the ${primitive} UI primitive instead of a styled native control.`,
@@ -1443,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();
@@ -1461,7 +1819,7 @@ const noNativeEmptinessCheck = defineRule({
 });
 //#endregion
 //#region src/rules/no-native-method-call.ts
-const nativeMethods = [
+const NATIVE_METHODS = [
 	"at",
 	"catch",
 	"charAt",
@@ -1532,13 +1890,48 @@ function freshRegExpFlags(input) {
 	if (flags.type !== "Literal" || !isString(flags.value)) return some(none());
 	return some(some(flags.value));
 }
+function memberRoot(node) {
+	if (node.type === "MemberExpression") return memberRoot(node.object);
+	return node;
+}
+function chainRoot(node) {
+	if (node.type === "MemberExpression") return chainRoot(node.object);
+	if (node.type === "CallExpression" && node.callee.type !== "Super") return chainRoot(node.callee);
+	if (node.type === "ParenthesizedExpression") return chainRoot(node.expression);
+	return node;
+}
+function isYieldedService(node) {
+	if (node?.type !== "YieldExpression" || !node.delegate || isNullish$1(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));
+}
+const effectPackage = matches(/^(?:effect(?:\/|$)|@effect\/)/u);
+const localPath = matches(/^[.#~/]|^@\//u);
+function ownsMethod(input) {
+	const root = chainRoot(input.receiver);
+	const throughCall = root !== memberRoot(input.receiver);
+	if (isYieldedService(root)) return true;
+	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([
+			"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;
+			return !localPath(definition.parent.source.value) && !(throughCall && effectPackage(definition.parent.source.value));
+		})
+	}));
+}
 const noNativeMethodCall = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		if (node.callee.type !== "MemberExpression" || node.callee.object.type === "Identifier" && (node.callee.object.name === "path" || isImportBinding({
+		if (node.callee.type !== "MemberExpression" || ownsMethod({
 			context,
-			node: node.callee.object,
-			source: /^(?:effect(?:\/|$)|@effect\/)/u
-		}))) return;
+			receiver: node.callee.object
+		})) return;
 		const receiver = node.callee.object;
 		const regExpFlags = freshRegExpFlags({
 			context,
@@ -1551,29 +1944,19 @@ 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"
-		], 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.`,
-				node: node.callee
-			});
-		}));
+		], 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.`,
+			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";
@@ -1594,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) => {
@@ -1626,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"
@@ -1663,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,
@@ -1677,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) {
@@ -1708,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
@@ -1729,42 +2156,31 @@ 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;
 }
-function report$1(input) {
+function report$2(input) {
 	const reads = pipe(input.variable.references, filter$1((reference) => reference.isRead()), map$1((reference) => reference.identifier));
 	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,
@@ -1777,7 +2193,19 @@ function report$1(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,
@@ -1810,7 +2238,7 @@ const noPropertyAlias = defineRule({
 					scope: context.sourceCode.getScope(candidate.node)
 				}), match({
 					onNone: constVoid,
-					onSome: (variable) => report$1({
+					onSome: (variable) => report$2({
 						...candidate,
 						context,
 						variable,
@@ -1823,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,
@@ -1846,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
@@ -1887,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
@@ -2035,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"
@@ -2110,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",
@@ -2120,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));
@@ -2140,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
 	}))) {
@@ -2267,7 +2708,7 @@ const noReturnType = defineRule({
 });
 //#endregion
 //#region src/rules/no-single-use-value.ts
-const repeating = [
+const REPEATING = [
 	"ArrowFunctionExpression",
 	"DoWhileStatement",
 	"ForInStatement",
@@ -2282,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
@@ -2306,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({
@@ -2324,10 +2765,61 @@ function inlined(input) {
 	if (input.read.range[0] === input.next.range[0]) return `;${value}`;
 	return value;
 }
-function report(input) {
+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({
@@ -2336,6 +2828,10 @@ function report(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
@@ -2349,7 +2845,7 @@ function report(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,
@@ -2375,7 +2871,7 @@ const noSingleUseValue = defineRule({
 			CallExpression: effect,
 			NewExpression: effect,
 			"Program:exit": () => {
-				for (const node of get$3(candidates)) report({
+				for (const node of get$3(candidates)) report$1({
 					context,
 					effects: get$3(effects),
 					node
@@ -2395,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;
@@ -2458,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,
@@ -2532,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)
@@ -2547,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
@@ -2660,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) => {
@@ -2741,6 +3292,44 @@ const noUnvalidatedJsonDecode = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#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$1(memberName(node.callee), "make");
+	const fields = node.arguments[0];
+	if (!constructs || fields?.type !== "ObjectExpression") return none();
+	return some(fields);
+}
+function dropsCause(node) {
+	if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression" || isArrayEmpty(node.params)) return false;
+	return exists(constructedFields(returnedExpression(node)), (fields) => every(fields.properties, (property) => property.type === "SpreadElement" || !(property.key.type === "Identifier" && property.key.name === "cause")));
+}
+function report(context, node) {
+	context.report({
+		message: "Keep the original failure as the new error’s cause: X.make({cause, message}).",
+		node
+	});
+}
+const preserveErrorCause = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (node.callee.type !== "MemberExpression" || !importedMember({
+			context,
+			importedName: "Effect",
+			node: node.callee
+		})) return;
+		const name = memberName(node.callee);
+		if (contains$1(name, "mapError")) {
+			forEach(filter$1(node.arguments, dropsCause), (callback) => report(context, callback));
+			return;
+		}
+		if (!exists(name, (method) => method === "try" || method === "tryPromise")) return;
+		const options = node.arguments[0];
+		if (options?.type !== "ObjectExpression") return;
+		for (const property of options.properties) if (property.type === "Property" && property.key.type === "Identifier" && property.key.name === "catch" && dropsCause(property.value)) report(context, property.value);
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/schema-type-pair.ts
 function expressionRoot(node) {
 	if (node.type === "MemberExpression") return expressionRoot(node.object);
@@ -2790,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",
@@ -2808,6 +3397,31 @@ function isSchemaDefinition(input) {
 function namedTypeAlias(input) {
 	return pipe(input.typeStatement, flatMap(typeAlias), filter((declaration) => declaration.id.name === input.name));
 }
+function exportedNames(input) {
+	return flatMap$1(input.program.body, (statement) => {
+		if (statement.type !== "ExportNamedDeclaration" || statement.declaration !== null || statement.source !== null) return empty();
+		return flatMap$1(statement.specifiers, (specifier) => {
+			const typeOnly = statement.exportKind === "type" || specifier.exportKind === "type";
+			if (specifier.local.type !== "Identifier" || typeOnly !== input.typeOnly) return empty();
+			return [specifier.local.name];
+		});
+	});
+}
+function exportLists(program) {
+	return {
+		types: exportedNames({
+			program,
+			typeOnly: true
+		}),
+		values: exportedNames({
+			program,
+			typeOnly: false
+		})
+	};
+}
+function isExported(input) {
+	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;
 	if (input.variable.init === null || !isSchemaDefinition({
@@ -2816,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
@@ -2843,6 +3457,20 @@ function reportSchemaVariable(input) {
 		message: `Place \`type ${name} = typeof ${name}.Type\` immediately before this Schema.`,
 		node: input.variable
 	});
+	else if (isExported({
+		exports: input.exports,
+		name,
+		statement: input.statement,
+		typeOnly: false
+	}) !== exists(typeStatement, (statement) => isExported({
+		exports: input.exports,
+		name,
+		statement,
+		typeOnly: true
+	}))) input.context.report({
+		message: `Export both \`type ${name}\` and the \`${name}\` Schema, or neither.`,
+		node: input.variable
+	});
 	if (input.variable.init.type === "TSSatisfiesExpression" && schemaSchemaType({
 		context: input.context,
 		node: input.variable.init.typeAnnotation
@@ -2864,11 +3492,13 @@ const schemaTypePair = defineRule({
 			context,
 			program
 		});
+		const exports = exportLists(program);
 		for (const statement of program.body) {
 			const declaration = statementDeclaration(statement);
 			if (declaration?.type === "VariableDeclaration") for (const variable of declaration.declarations) reportSchemaVariable({
 				context,
 				cycleNames,
+				exports,
 				program,
 				statement,
 				variable
@@ -2879,7 +3509,7 @@ const schemaTypePair = defineRule({
 });
 //#endregion
 //#region src/oxlint.ts
-const reactLegacyApis = [
+const REACT_LEGACY_APIS = [
 	"Component",
 	"PureComponent",
 	"createRef",
@@ -2888,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",
@@ -2909,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",
@@ -2924,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",
@@ -2969,6 +3599,10 @@ const oxlint = defineConfig({
 			],
 			rules: { "import/no-default-export": "off" }
 		},
+		{
+			files: ["**/app.plugin.js"],
+			rules: { "@deslop/coding-standards/no-barrel-module": "off" }
+		},
 		{
 			files: ["**/components/ui/**"],
 			rules: {
@@ -2981,7 +3615,9 @@ const oxlint = defineConfig({
 			rules: {
 				"@deslop/coding-standards/no-destructured-parameter": "off",
 				"@deslop/coding-standards/no-native-control": "off",
-				"@deslop/coding-standards/no-renamed-import": "off"
+				"@deslop/coding-standards/no-renamed-import": "off",
+				"jsx-a11y/click-events-have-key-events": "off",
+				"jsx-a11y/label-has-associated-control": "off"
 			}
 		},
 		{
@@ -3008,19 +3644,29 @@ const oxlint = defineConfig({
 		"typescript",
 		"oxc",
 		"import",
+		"jsx-a11y",
 		"react",
 		"unicorn"
 	],
 	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",
 		"@deslop/coding-standards/no-constant-function": "error",
 		"@deslop/coding-standards/no-deep-pipe": "error",
 		"@deslop/coding-standards/no-destructured-parameter": "error",
 		"@deslop/coding-standards/no-discarded-failure": "error",
 		"@deslop/coding-standards/no-double-nullish-check": "error",
 		"@deslop/coding-standards/no-effect-property-arrow": "error",
+		"@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",
 		"@deslop/coding-standards/no-let": "error",
@@ -3039,13 +3685,16 @@ 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",
 		"@deslop/coding-standards/no-unvalidated-json-decode": "error",
+		"@deslop/coding-standards/preserve-error-cause": "error",
 		"@deslop/coding-standards/schema-type-pair": "error",
 		"effecttsgo/abort-controller-in-effect": "error",
 		"effecttsgo/crypto-random-uuid": "error",
@@ -3178,7 +3827,7 @@ const oxlint = defineConfig({
 		"typescript/no-import-type-side-effects": "error",
 		"typescript/no-inferrable-types": "error",
 		"typescript/no-invalid-void-type": "error",
-		"typescript/no-misused-promises": ["error", { checksVoidReturn: false }],
+		"typescript/no-misused-promises": ["error", { checksVoidReturn: { attributes: false } }],
 		"typescript/no-misused-spread": "error",
 		"typescript/no-namespace": ["error", { allowDeclarations: true }],
 		"typescript/no-non-null-assertion": "error",
@@ -3210,6 +3859,7 @@ const oxlint = defineConfig({
 		"typescript/restrict-plus-operands": "error",
 		"typescript/restrict-template-expressions": "error",
 		"typescript/strict-boolean-expressions": ["error", {
+			allowNullableObject: false,
 			allowNumber: false,
 			allowString: false
 		}],
@@ -3239,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"
 				},
 				{
@@ -3303,6 +3953,7 @@ const oxlint = defineConfig({
 				}
 			]
 		}],
+		"array-callback-return": "error",
 		"max-depth": ["error", 3],
 		"max-nested-callbacks": ["error", 6],
 		"no-cond-assign": "error",
@@ -3348,7 +3999,7 @@ const oxlint = defineConfig({
 				name: "Error"
 			},
 			{
-				message: mapMessage,
+				message: MAP_MESSAGE,
 				name: "Map"
 			},
 			{
@@ -3376,7 +4027,7 @@ const oxlint = defineConfig({
 				name: "Reflect"
 			},
 			{
-				message: setMessage,
+				message: SET_MESSAGE,
 				name: "Set"
 			},
 			{
@@ -3403,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"
 			},
@@ -3433,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
@@ -3555,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",
@@ -3576,6 +4233,12 @@ const oxlint = defineConfig({
 		"prefer-const": ["error", { destructuring: "all" }],
 		"prefer-template": "error",
 		"require-unicode-regexp": "error",
+		"jsx-a11y/autocomplete-valid": "error",
+		"jsx-a11y/click-events-have-key-events": "error",
+		"jsx-a11y/control-has-associated-label": "error",
+		"jsx-a11y/interactive-supports-focus": "error",
+		"jsx-a11y/label-has-associated-control": "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",
 		"react-doctor/no-create-context-in-render": "error",
@@ -3583,12 +4246,18 @@ const oxlint = defineConfig({
 		"react-doctor/no-inline-exhaustive-style": "error",
 		"react-doctor/no-jsx-element-type": "error",
 		"react-doctor/no-many-boolean-props": "error",
+		"react-doctor/no-nested-card-surface": "error",
+		"react-doctor/no-placeholder-only-field": "error",
 		"react-doctor/no-prop-types": "error",
 		"react-doctor/no-uncontrolled-input": "error",
+		"react-doctor/shadcn-dialog-content-requires-title": "error",
 		"react-doctor/shadcn-icon-button-requires-label": "error",
 		"react-doctor/effect-listener-cleanup-mismatch": "error",
+		"react-doctor/effect-needs-cleanup": "error",
+		"react-doctor/no-adjust-state-on-prop-change": "error",
 		"react-doctor/no-async-effect-callback": "error",
 		"react-doctor/no-create-object-url-without-revoke": "error",
+		"react-doctor/no-derived-state": "error",
 		"react-doctor/no-derived-useState": "error",
 		"react-doctor/no-effect-event-in-deps": "error",
 		"react-doctor/no-effect-with-fresh-deps": "error",
@@ -3616,10 +4285,10 @@ const oxlint = defineConfig({
 		"react-doctor/no-large-animated-blur": "error",
 		"react-doctor/no-layout-property-animation": "error",
 		"react-doctor/no-layout-transition-inline": "error",
-		"react-doctor/no-long-transition-duration": "error",
 		"react-doctor/no-outline-none": "error",
-		"react-doctor/no-scale-from-zero": "error",
+		"react-doctor/no-reduced-motion-content-removal": "error",
 		"react-doctor/no-transition-all": "error",
+		"react-doctor/no-ungated-tailwind-animation": "error",
 		"react/button-has-type": "error",
 		"react/checked-requires-onchange-or-readonly": "error",
 		"react/exhaustive-deps": "error",
@@ -3649,6 +4318,7 @@ const oxlint = defineConfig({
 		"react/preserve-manual-memoization": "error",
 		"react/purity": "error",
 		"react/refs": "error",
+		"react/rule-suppression": "error",
 		"react/rules-of-hooks": "error",
 		"react/self-closing-comp": "error",
 		"react/set-state-in-effect": "error",
@@ -3678,17 +4348,19 @@ 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",
 		"typescript/no-useless-default-assignment": "error",
 		"unicorn/filename-case": "error",
+		"unicorn/no-abusive-eslint-disable": "error",
+		"unicorn/no-empty-file": "error",
 		"unicorn/no-immediate-mutation": "error",
 		"unicorn/no-null": "error",
 		"unicorn/no-object-as-default-parameter": "error",
@@ -3702,6 +4374,12 @@ const oxlint = defineConfig({
 		"use-isnan": "error"
 	},
 	settings: {
+		"jsx-a11y": { components: {
+			Button: "button",
+			Input: "input",
+			Label: "label",
+			Textarea: "textarea"
+		} },
 		react: { version: "19.0" },
 		shadcn: { ui: ["@deslop/components-web/ui", "@dual/ui/components"] }
 	}
@@ -3709,15 +4387,24 @@ const oxlint = defineConfig({
 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,
 		"no-constant-function": noConstantFunction,
 		"no-deep-pipe": noDeepPipe,
 		"no-destructured-parameter": noDestructuredParameter,
 		"no-discarded-failure": noDiscardedFailure,
 		"no-double-nullish-check": noDoubleNullishCheck,
 		"no-effect-property-arrow": noEffectPropertyArrow,
+		"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,
 		"no-let": noLet,
@@ -3736,13 +4423,16 @@ 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,
 		"no-unvalidated-json-decode": noUnvalidatedJsonDecode,
+		"preserve-error-cause": preserveErrorCause,
 		"schema-type-pair": schemaTypePair
 	}
 });