@deslop/coding-standards 0.1.1081 → 0.1.1083

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 { A as dedupeWith, At as flatMap, B as flatMap$1, Bt as match, C as TaggedError, D as contains$1, Dt as exists, E as appendAll, Er as isNotNullish, Et as contains, F as filter$1, Fr as isString, Ft as getOrUndefined, G as getSomes, Gt as zipWith, H as forEach, Hr as constVoid, Ht as orElse, I as filterMap, It as isNone, J as isArrayNonEmpty, Jr as pipe, K as head, L as findFirst, Lt as isSome, M as empty, Mt as fromNullishOr, N as ensure, Nr as isReadonlyObject, Nt as fromUndefinedOr, O as containsWith, Or as isNullish$1, Ot as filter, P as every, Pr as isRegExp, Pt as getOrElse, Q as last, R as findFirstIndex, T as append, Tr as isNotNull, Tt as all, Ut as some, V as flatten, Vt as none, W as get$1, Wr as dual, Wt as toArray$1, X as isReadonlyArrayNonEmpty, Xn as NodeInspectSymbol, Z as join, Zr as pipeArguments, _ as startsWith, _t as fromOption, b as parse, c as make$3, cr as equals, ct as take, d as Order, dr as combine, et as map$1, f as includes, fr as hash, g as split, h as replaceAll, hr as string, in as strictEqual, it as prepend, j as dropRight, jt as flatten$1, k as dedupe, kr as isNumber, kt as firstSomeOf, l as update, lr as symbol, lt as fromEntries, m as replace, mr as optimize, mt as values, nt as matchRight, o as toArray, ot as some$1, p as match$1, pr as number, pt as remove, q as isArrayEmpty, r as make$2, rt as of, s as get$3, sr as byReferenceUnsafe, st as sort, t as append$1, u as match$2, ut as get$2, v as trim, vr as symbol$1, xr as isBoolean, yr as hasProperty, zr as constFalse, zt as map } from "./MutableList-Cpkiw3Cl.mjs";
 //#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/internal/graph.js
 /** @internal */
 const TypeId = "~effect/Graph";
@@ -890,6 +890,68 @@ 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(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/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$1("starting")) && exists(amount(token, /^scale-(\d+)$/u), (value) => value < 90)) return some("Enter from 0.9 scale or more: starting:scale-90 or starting:scale-95.");
+	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();
@@ -937,6 +999,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;
@@ -1186,6 +1305,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(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);
@@ -1256,6 +1449,26 @@ const noFakeRefState = defineRule({
 	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;
@@ -1308,7 +1521,7 @@ 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;
@@ -1348,19 +1561,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
 			});
@@ -1422,15 +1635,25 @@ const primitives = {
 	textarea: "Textarea"
 };
 const controlStyle = /(?:^|:)(?: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))));
+			const styled = pipe(node.attributes, findFirst((attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "className"), map((attribute) => {
+				if (attribute.type !== "JSXAttribute" || attribute.value === null) return empty();
+				return classStrings(attribute.value);
+			}), exists((values) => some$1(values, (value) => some$1(split(value, /\s+/u), matches(controlStyle)))));
 			if (name !== "select" && !styled) return;
 			context.report({
 				message: `Use the ${primitive} UI primitive instead of a styled native control.`,
@@ -1532,13 +1755,49 @@ function freshRegExpFlags(input) {
 	if (flags.type !== "Literal" || !isString(flags.value)) return some(none());
 	return some(some(flags.value));
 }
+const nativeGlobals = [
+	"Object",
+	"Promise",
+	"RegExp"
+];
+function memberRoot(node) {
+	if (node.type === "MemberExpression") return memberRoot(node.object);
+	return node;
+}
+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$1(nativeGlobals, 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,
@@ -1555,12 +1814,10 @@ const noNativeMethodCall = defineRule({
 			"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" }
 });
@@ -1751,7 +2008,7 @@ 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) => {
@@ -1810,7 +2067,7 @@ const noPropertyAlias = defineRule({
 					scope: context.sourceCode.getScope(candidate.node)
 				}), match({
 					onNone: constVoid,
-					onSome: (variable) => report$1({
+					onSome: (variable) => report$2({
 						...candidate,
 						context,
 						variable,
@@ -2324,7 +2581,7 @@ function inlined(input) {
 	if (input.read.range[0] === input.next.range[0]) return `;${value}`;
 	return value;
 }
-function report(input) {
+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;
@@ -2375,7 +2632,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
@@ -2741,6 +2998,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(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(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);
@@ -2808,6 +3103,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$1(input.exports.values, input.name) || input.typeOnly && contains$1(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({
@@ -2843,6 +3163,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 +3198,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
@@ -2969,6 +3305,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 +3321,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 +3350,27 @@ const oxlint = defineConfig({
 		"typescript",
 		"oxc",
 		"import",
+		"jsx-a11y",
 		"react",
 		"unicorn"
 	],
 	rules: {
+		"@deslop/coding-standards/explicit-effect-concurrency": "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-gradient": "error",
 		"@deslop/coding-standards/no-hand-written-guard": "error",
 		"@deslop/coding-standards/no-in-operator": "error",
 		"@deslop/coding-standards/no-let": "error",
@@ -3046,6 +3396,7 @@ const oxlint = defineConfig({
 		"@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 +3529,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 +3561,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
 		}],
@@ -3303,6 +3655,7 @@ const oxlint = defineConfig({
 				}
 			]
 		}],
+		"array-callback-return": "error",
 		"max-depth": ["error", 3],
 		"max-nested-callbacks": ["error", 6],
 		"no-cond-assign": "error",
@@ -3576,6 +3929,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 +3942,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 +3981,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 +4014,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",
@@ -3689,6 +4055,8 @@ const oxlint = defineConfig({
 		"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 +4070,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 +4083,22 @@ const oxlint = defineConfig({
 var oxlint_default = definePlugin({
 	meta: { name: "@deslop/coding-standards" },
 	rules: {
+		"explicit-effect-concurrency": explicitEffectConcurrency,
+		"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-gradient": noGradient,
 		"no-hand-written-guard": noHandWrittenGuard,
 		"no-in-operator": noInOperator,
 		"no-let": noLet,
@@ -3743,6 +4124,7 @@ var oxlint_default = definePlugin({
 		"no-undestructured-use-state": noUndestructuredUseState,
 		"no-unexplained-disable": noUnexplainedDisable,
 		"no-unvalidated-json-decode": noUnvalidatedJsonDecode,
+		"preserve-error-cause": preserveErrorCause,
 		"schema-type-pair": schemaTypePair
 	}
 });