@deslop/coding-standards 0.1.1085 → 0.1.1087

package/dist/oxlint.js

@@ -1,4 +1,4 @@
-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";
+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.
 *
@@ -1033,13 +1033,13 @@ const moduleConstant = defineRule({
 //#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("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();
@@ -1062,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$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);
-}
-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) => ({
@@ -1135,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
 		});
 	} }),
@@ -1227,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
 		});
 	} }),
@@ -1322,10 +1275,11 @@ const noDiscardedFailure = defineRule({
 		})) return;
 		if (!exists(memberName(node), (name) => contains([
 			"ignore",
+			"ignoreCause",
 			"orDie",
 			"orDieWith"
 		], name))) return;
-		if (contains$1(memberName(node), "ignore") && logged(node)) return;
+		if (exists(memberName(node), (name) => name !== "orDie" && name !== "orDieWith") && logged(node)) return;
 		context.report({
 			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
@@ -1433,7 +1387,7 @@ function isEffectEmpty(input) {
 	});
 }
 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);
@@ -1445,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",
@@ -1486,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
 		});
 	} }),
@@ -1494,6 +1448,7 @@ 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();
@@ -1517,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(["toThrow", "toThrowError"], name)) || expectsMessage(node.callee))) context.report({
-			message: "Assert the failure, never its message wording.",
+			message: ASSERT_IDENTITY,
 			node
 		});
 	} }),
@@ -1539,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,
@@ -1579,7 +1534,7 @@ const noFloatingDerivedType = defineRule({
 		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.",
+			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
 		});
 	} }),
@@ -1590,7 +1545,7 @@ const noFloatingDerivedType = defineRule({
 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
 	});
 }
@@ -1658,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;
-	map(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({
@@ -1687,12 +1642,13 @@ function report$3(input) {
 		"typeof === string": "isString",
 		"typeof === symbol": "isSymbol",
 		"typeof === undefined": "isUndefined"
-	}, key))), (guard) => {
-		input.context.report({
-			message: `Use Predicate.${guard} instead of this hand-written type guard.`,
-			node: input.node
-		});
-	});
+	}, key)));
+}
+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) => ({
@@ -1819,69 +1775,54 @@ const noNativeEmptinessCheck = defineRule({
 });
 //#endregion
 //#region src/rules/no-native-method-call.ts
-const NATIVE_METHODS = [
-	"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();
@@ -1901,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));
 }
@@ -1932,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({
@@ -1944,61 +1884,21 @@ const noNativeMethodCall = defineRule({
 			});
 			return;
 		}
-		pipe(memberName(node.callee), filter((name) => contains(NATIVE_METHODS, name)), filter((name) => !contains([
+		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
-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([
-		"isNotNull",
-		"isNotNullish",
-		"isNotUndefined",
-		"isNull",
-		"isNullish",
-		"isUndefined"
-	], 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({
@@ -2073,7 +1973,7 @@ const FUNCTIONS = [
 	"FunctionExpression"
 ];
 function insideFunction(node) {
-	if (isNullish$1(node.parent) || node.parent.type === "Program") return false;
+	if (isNullish(node.parent) || node.parent.type === "Program") return false;
 	if (contains(FUNCTIONS, node.parent.type)) return true;
 	return insideFunction(node.parent);
 }
@@ -2091,7 +1991,7 @@ function pathTop(node) {
 	return node;
 }
 function tested(node) {
-	if (isNullish$1(node.parent)) return false;
+	if (isNullish(node.parent)) return false;
 	if (node.parent.type === "LogicalExpression") return node.parent.left === node || tested(node.parent);
 	if (contains([
 		"ChainExpression",
@@ -2113,7 +2013,7 @@ function predicate(callee) {
 	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;
+	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({
@@ -2136,7 +2036,7 @@ function needsAlias(input) {
 	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 (isNullish(input.node.parent) || input.node.parent === input.block) return false;
 	if (contains(input.types, input.node.parent.type)) return true;
 	return enclosed({
 		...input,
@@ -2502,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
 		});
 	} }),
@@ -2684,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,
@@ -2731,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,
@@ -2746,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(["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({
@@ -2797,7 +2699,7 @@ function surface(node) {
 		"ReturnStatement",
 		"VariableDeclaration"
 	], node.type) || node.type === "ArrowFunctionExpression" && node.expression) return true;
-	if (isNullish$1(node.parent) || !contains([
+	if (isNullish(node.parent) || !contains([
 		"AwaitExpression",
 		"JSXAttribute",
 		"JSXElement",
@@ -2812,7 +2714,7 @@ function surface(node) {
 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 (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);
 }
@@ -2880,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
 		};
@@ -2928,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
 		});
 	} }),
@@ -2986,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,
@@ -3082,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({
@@ -3103,7 +3012,7 @@ const noTrivialIndirection = defineRule({
 			});
 		},
 		FunctionDeclaration: (node) => {
-			if (exactForwardingFunction({
+			if (!isComponent(node) && (exactForwardingFunction({
 				context,
 				node
 			}) || singleUseThunk({
@@ -3112,7 +3021,7 @@ const noTrivialIndirection = defineRule({
 			}) || singleCallerWrapper({
 				context,
 				node
-			})) context.report({
+			}))) context.report({
 				message: indirectionMessage({
 					context,
 					node
@@ -3121,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({
@@ -3150,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({
@@ -3212,12 +3121,17 @@ const noTypeFromValue = defineRule({
 });
 //#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
 		});
 	} }),
@@ -3592,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" }
 		},
 		{
@@ -3625,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" }
 		},
 		{
@@ -3652,7 +3562,6 @@ const oxlint = defineConfig({
 		"@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",
@@ -3674,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",
@@ -3710,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",
@@ -3728,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",
@@ -3768,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",
@@ -3781,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",
@@ -3797,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",
@@ -3854,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",
@@ -3919,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)(?:/|$)"
@@ -3953,7 +3867,6 @@ const oxlint = defineConfig({
 				}
 			]
 		}],
-		"array-callback-return": "error",
 		"max-depth": ["error", 3],
 		"max-nested-callbacks": ["error", 6],
 		"no-cond-assign": "error",
@@ -4006,10 +3919,6 @@ const oxlint = defineConfig({
 				message: "Import Number from 'effect'.",
 				name: "Number"
 			},
-			{
-				message: "Use Record or Struct from 'effect'.",
-				name: "Object"
-			},
 			{
 				message: "Use Number.parse.",
 				name: "parseFloat"
@@ -4050,9 +3959,15 @@ 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: RUN_MESSAGE,
@@ -4196,12 +4111,12 @@ 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
@@ -4226,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",
@@ -4306,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",
@@ -4314,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",
@@ -4324,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",
@@ -4367,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: {
@@ -4390,7 +4304,6 @@ var oxlint_default = definePlugin({
 		"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,
@@ -4412,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,