@deslop/coding-standards 0.1.1242 → 0.1.1244

package/README.md

@@ -1,6 +1,6 @@
 # @deslop/coding-standards
 
-A Vite+ lint preset, a strict TypeScript configuration with Effect diagnostics, and the `lint-companion`, `pull-requests` and `review` skills for Claude Code and Codex.
+A Vite+ lint preset that runs the Effect rules and TypeScript diagnostics in Oxlint on tsrs, a strict TypeScript configuration, and the `lint-companion`, `pull-requests` and `review` skills for Claude Code and Codex.
 
 ```bash
 vpx @deslop/coding-standards@latest                                  # installs the skills
@@ -20,13 +20,14 @@ export default defineConfig({lint: {extends: [lint]}})
 // package.json
 {
 	"scripts": {
-		"prepare": "effect-tsgo patch --no-typescript --tsrs",
-		"typecheck": "tsrs --noEmit --checkerAssignment go",
-		"check": "vp check && vp run typecheck"
+		"prepare": "effect-tsgo patch --no-typescript --tsrs --oxlint",
+		"check": "effect-tsgo --tsrs-lint vp lint --type-aware --type-check"
 	}
 }
 ```
 
+The preset leaves type-aware lint and type checking off, so a syntax-only pass stays possible; the two flags turn them on, and `--tsrs-lint` runs them on tsrs instead of Oxlint's tsgolint backend.
+
 ```jsonc
 // tsconfig.json
 {"extends": "@deslop/coding-standards/tsconfig.json"}

package/dist/install.js

@@ -27604,7 +27604,7 @@ const runWith = (command, config) => {
 	}, ({ error, userMessage }) => andThen(showUserError(error, userMessage), fail$3(error))), catchFilter((e) => isQuitError(e) ? succeed$6(e) : fail$8(e), (_) => interrupt$1));
 };
 // package.json
-var version = "0.1.1242";
+var version = "0.1.1244";
 // src/install.ts
 const cli = pipe(make("deslop-coding-standards", {}, fnUntraced(function* () {
 	const fs = yield* FileSystem;

package/dist/lint.js

@@ -1,4 +1,4 @@
-import { $ as join, A as dedupe, At as all, B as findFirstIndex, Br as isRegExp, Bt as getOrElse, C as TaggedError, D as contains, E as appendAll, Er as hasProperty, F as ensure, Fr as isNullish, Ft as firstSomeOf, Gr as constFalse, Gt as liftThrowable, H as flatMap, Ht as isNone, I as every, Ir as isNumber$1, It as flatMap$1, J as head, Jr as constVoid, Jt as none, K as get$3, Kt as map$1, L as filter$1, Lt as flatten$1, M as drop, Mr as isNotNull, Mt as contains$1, N as dropRight, Nr as isNotNullish, Nt as exists, O as containsWith, Or as isBoolean, P as empty$2, Pt as filter, Q as isReadonlyArrayNonEmpty, Qt as zipWith, R as filterMap, Rt as fromNullishOr, Sr as string, St as fromOption, T as append, Tr as symbol$1, U as flatten, Ut as isSome, Vr as isString, Vt as getOrUndefined, W as forEach, Wt as liftPredicate, X as isArrayNonEmpty, Xr as dual, Xt as some, Y as isArrayEmpty, Yt as orElse, Zt as toArray$1, _ as toUpperCase, ar as format, at as of, b as parse, br as number, c as Order, ct as some$1, d as match$1, dt as takeWhile, ei as pipe, et as last, f as matchAll, ft as zip, g as startsWith, gr as symbol, h as split, hr as equals, ht as has$2, i as make$2, it as matchRight, j as dedupeWith, jt as as, k as countBy, l as includes, lt as sort, m as slice, mr as byReferenceUnsafe, mt as get$2, n as append$1, nr as NodeInspectSymbol, nt as map, ot as prepend, p as replaceAll, pt as fromEntries, q as getSomes, qt as match, ri as pipeArguments, rr as toJson, s as toArray, t as match$2, u as isNonEmpty, un as strictEqual, ut as take, v as trim, vr as combine, vt as mapEntries, xr as optimize, yr as hash, z as findFirst, zt as fromUndefinedOr } from "./Boolean-C8Zb2yak.mjs";
+import { $ as join, A as dedupe, At as all, B as findFirstIndex, Br as isRegExp, Bt as getOrElse, C as TaggedError, D as contains, E as appendAll, Er as hasProperty, F as ensure, Fr as isNullish, Ft as firstSomeOf, Gr as constFalse, Gt as liftThrowable, H as flatMap, Ht as isNone, I as every, Ir as isNumber$1, It as flatMap$1, J as head, Jr as constVoid, Jt as none, K as get$3, Kt as map, L as filter$1, Lt as flatten$1, M as drop, Mr as isNotNull, Mt as contains$1, N as dropRight, Nr as isNotNullish, Nt as exists, O as containsWith, Or as isBoolean, P as empty$2, Pt as filter, Q as isReadonlyArrayNonEmpty, Qt as zipWith, R as filterMap, Rt as fromNullishOr, Sr as string, St as fromOption, T as append, Tr as symbol$1, U as flatten, Ut as isSome, Vr as isString, Vt as getOrUndefined, W as forEach, Wt as liftPredicate, X as isArrayNonEmpty, Xr as dual, Xt as some, Y as isArrayEmpty, Yt as orElse, Zt as toArray$1, _ as toUpperCase, ar as format, at as of, b as parse, br as number, c as Order, ct as some$1, d as match$1, dt as takeWhile, ei as pipe, et as last, f as matchAll, ft as zip, g as startsWith, gr as symbol, h as split, hr as equals, ht as has$2, i as make$2, it as matchRight, j as dedupeWith, jt as as, k as countBy, l as includes, lt as sort, m as slice, mr as byReferenceUnsafe, mt as get$2, n as append$1, nr as NodeInspectSymbol, nt as map$1, ot as prepend, p as replaceAll, pt as fromEntries, q as getSomes, qt as match, ri as pipeArguments, rr as toJson, s as toArray, t as match$2, u as isNonEmpty, un as strictEqual, ut as take, v as trim, vr as combine, vt as mapEntries, xr as optimize, yr as hash, z as findFirst, zt as fromUndefinedOr } from "./Boolean-C8Zb2yak.mjs";
 import { definePlugin, defineRule } from "vite-plus/lint/plugins";
 // ../../node_modules/.pnpm/effect@4.1.2/node_modules/effect/dist/MutableHashMap.js
 const TypeId$2 = "~effect/MutableHashMap";
@@ -962,6 +962,12 @@ function variableFromScope(input) {
 function boundVariable(input) {
 	return filter(variableFromScope(input), (variable) => isArrayNonEmpty(variable.defs) || isArrayNonEmpty(variable.references));
 }
+function readsOf(input) {
+	return pipe(variableFromScope({
+		name: input.name,
+		scope: input.context.sourceCode.getScope(input.node)
+	}), map((variable) => filter$1(variable.references, (reference) => reference.isRead())));
+}
 function variableFor(context, node) {
 	return variableFromScope({
 		name: node.name,
@@ -971,7 +977,7 @@ function variableFor(context, node) {
 const importedNames = /* @__PURE__ */ new WeakMap();
 function importNames(statements) {
 	return flatMap(statements, (statement) => {
-		if (statement.type === "ImportDeclaration") return map(statement.specifiers, (specifier) => specifier.local.name);
+		if (statement.type === "ImportDeclaration") return map$1(statement.specifiers, (specifier) => specifier.local.name);
 		if (statement.type === "TSModuleDeclaration" && statement.body?.type === "TSModuleBlock") return importNames(statement.body.body);
 		return [];
 	});
@@ -1004,8 +1010,8 @@ function effectImport(input) {
 	}), filter((variable) => isArrayNonEmpty(variable.defs)), match({
 		onNone: () => pipe(input.context.sourceCode.ast.body, findFirst((statement) => statement.type === "ImportDeclaration" && statement.source.value === "effect" && statement.importKind !== "type" && every(statement.specifiers, (specifier) => specifier.type === "ImportSpecifier")), flatMap$1((statement) => {
 			if (statement.type !== "ImportDeclaration") return none();
-			return pipe(findFirst(statement.specifiers, (specifier) => Order(importedName(specifier), input.name) > 0), map$1((specifier) => input.fixer.insertTextBefore(specifier, `${input.name}, `)), orElse(() => map$1(last(statement.specifiers), (specifier) => input.fixer.insertTextAfter(specifier, `, ${input.name}`))));
-		}), orElse(() => map$1(findFirst(input.context.sourceCode.ast.body, (statement) => statement.type !== "ExpressionStatement" || isNullish(statement.directive)), (statement) => input.fixer.insertTextBefore(statement, `import {${input.name}} from 'effect'\n`))), map$1(of)),
+			return pipe(findFirst(statement.specifiers, (specifier) => Order(importedName(specifier), input.name) > 0), map((specifier) => input.fixer.insertTextBefore(specifier, `${input.name}, `)), orElse(() => map(last(statement.specifiers), (specifier) => input.fixer.insertTextAfter(specifier, `, ${input.name}`))));
+		}), orElse(() => map(findFirst(input.context.sourceCode.ast.body, (statement) => statement.type !== "ExpressionStatement" || isNullish(statement.directive)), (statement) => input.fixer.insertTextBefore(statement, `import {${input.name}} from 'effect'\n`))), map(of)),
 		onSome: (variable) => liftPredicate(empty$2(), () => some$1(variable.defs, (definition) => definition.type === "ImportBinding" && definition.parent?.type === "ImportDeclaration" && definition.parent.source.value === "effect" && definition.parent.importKind !== "type" && definition.node.type === "ImportSpecifier" && definition.node.importKind !== "type" && definition.node.imported.type === "Identifier" && definition.node.imported.name === input.name))
 	}));
 }
@@ -1066,11 +1072,11 @@ function chainOf(node) {
 		members: [],
 		root: node
 	});
-	if (node.type === "MemberExpression") return flatMap$1(memberName(node), (name) => map$1(chainOf(node.object), (chain) => ({
+	if (node.type === "MemberExpression") return flatMap$1(memberName(node), (name) => map(chainOf(node.object), (chain) => ({
 		...chain,
 		members: append(chain.members, name)
 	})));
-	if (node.type === "CallExpression") return map$1(chainOf(node.callee), (chain) => ({
+	if (node.type === "CallExpression") return map(chainOf(node.callee), (chain) => ({
 		...chain,
 		calls: append(chain.calls, node)
 	}));
@@ -1133,7 +1139,7 @@ function propertyKey(property) {
 }
 function optionKeys(node) {
 	if (node.type !== "ObjectExpression") return empty$2();
-	return getSomes(map(node.properties, propertyKey));
+	return getSomes(map$1(node.properties, propertyKey));
 }
 function isTestClockMember(context, node, propertyName) {
 	return node.type === "MemberExpression" && node.object.type === "Identifier" && contains$1(memberName(node), propertyName) && isImportBinding({
@@ -1165,6 +1171,14 @@ function importedMember(input) {
 		source: "effect"
 	});
 }
+function effectMethod(input) {
+	if (input.node.callee.type !== "MemberExpression" || !importedMember({
+		context: input.context,
+		importedName: "Effect",
+		node: input.node.callee
+	})) return none();
+	return memberName(input.node.callee);
+}
 function isWriteTarget(node) {
 	if (node.parent === null) return false;
 	return (node.parent.type === "AssignmentExpression" || node.parent.type === "AssignmentPattern") && node.parent.left === node || node.parent.type === "ArrayPattern" || node.parent.type === "RestElement" || node.parent.type === "Property" && node.parent.value === node && node.parent.parent.type === "ObjectPattern" || (node.parent.type === "ForInStatement" || node.parent.type === "ForOfStatement") && node.parent.left === node || node.parent.type === "UpdateExpression" || node.parent.type === "UnaryExpression" && node.parent.operator === "delete";
@@ -1266,12 +1280,12 @@ function suspendedTypeName(input) {
 }
 function memberType(member) {
 	if (member.type === "TSIndexSignature") return some(member.typeAnnotation.typeAnnotation);
-	if (member.type === "TSPropertySignature") return map$1(fromNullishOr(member.typeAnnotation), (annotation) => annotation.typeAnnotation);
-	return map$1(fromNullishOr(member.returnType), (annotation) => annotation.typeAnnotation);
+	if (member.type === "TSPropertySignature") return map(fromNullishOr(member.typeAnnotation), (annotation) => annotation.typeAnnotation);
+	return map(fromNullishOr(member.returnType), (annotation) => annotation.typeAnnotation);
 }
 function referencedTypeNames(node) {
 	if (node.type === "TSTypeReference") {
-		const argumentNames = pipe(fromNullishOr(node.typeArguments), map$1((typeArguments) => pipe(typeArguments.params, flatMap(referencedTypeNames))), getOrElse(() => empty$2()));
+		const argumentNames = pipe(fromNullishOr(node.typeArguments), map((typeArguments) => pipe(typeArguments.params, flatMap(referencedTypeNames))), getOrElse(() => empty$2()));
 		if (node.typeName.type !== "Identifier") return argumentNames;
 		return prepend(argumentNames, node.typeName.name);
 	}
@@ -1293,8 +1307,8 @@ function referencedTypeNames(node) {
 		node.constraint,
 		node.nameType,
 		node.typeAnnotation
-	], map((child) => fromNullishOr(child)), getSomes, flatMap(referencedTypeNames));
-	if (node.type === "TSTypeLiteral") return pipe(node.members, map(memberType), getSomes, flatMap(referencedTypeNames));
+	], map$1((child) => fromNullishOr(child)), getSomes, flatMap(referencedTypeNames));
+	if (node.type === "TSTypeLiteral") return pipe(node.members, map$1(memberType), getSomes, flatMap(referencedTypeNames));
 	return empty$2();
 }
 function isNode(value) {
@@ -1379,12 +1393,12 @@ function schemaEdges(context, statement) {
 function schemaCycleNames(input) {
 	if (isArrayEmpty(input.seeds) || !some$1(input.program.body, (statement) => statement.type === "ImportDeclaration" && statement.source.value === "effect" && some$1(statement.specifiers, (specifier) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "Schema"))) return empty$2();
 	const edges = pipe(input.program.body, flatMap((statement) => schemaEdges(input.context, statement)));
-	const names = pipe(edges, map((edge) => edge.name), dedupe);
+	const names = pipe(edges, map$1((edge) => edge.name), dedupe);
 	const graph = directed((mutable) => {
-		const indices = fromEntries(map(names, (name) => [name, addNode(mutable, name)]));
+		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((component) => getSomes(map(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(input.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(input.seeds, name))), flatten);
 }
 function suspends(context, node) {
 	if (node.type === "YieldExpression" || node.type === "AwaitExpression") return true;
@@ -1432,12 +1446,16 @@ function bindingName(node) {
 	if (node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier") return some(node.parent.id.name);
 	return none();
 }
+function boundReads(input) {
+	return pipe(bindingName(input.node), flatMap$1((name) => readsOf({
+		context: input.context,
+		name,
+		node: input.node
+	})));
+}
 function singleUseThunk(input) {
 	if (isReadonlyArrayNonEmpty(input.node.params) || input.node.typeParameters !== null || !hasSingleStatementExpression(input.node)) return false;
-	return pipe(bindingName(input.node), flatMap$1((name) => variableFromScope({
-		name,
-		scope: input.context.sourceCode.getScope(input.node)
-	})), exists((variable) => countBy(variable.references, (reference) => reference.isRead()) === 1));
+	return exists(boundReads(input), (reads) => reads.length === 1);
 }
 // src/rules/explicit-effect-concurrency.ts
 function statesConcurrency(node) {
@@ -1477,13 +1495,11 @@ function isFunction(context, node) {
 }
 const explicitEffectConcurrency = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		if (node.callee.type !== "MemberExpression") return;
-		const name = memberName(node.callee);
-		if (!exists(name, (method) => method === "all" || method === "forEach") || !importedMember({
+		const name = effectMethod({
 			context,
-			importedName: "Effect",
-			node: node.callee
-		})) return;
+			node
+		});
+		if (!exists(name, (method) => method === "all" || method === "forEach")) return;
 		const index = match$2(contains$1(name, "all") || isFunction(context, node.arguments[0]) || node.arguments[1]?.type === "ObjectExpression", {
 			onFalse: () => 2,
 			onTrue: () => 1
@@ -1622,14 +1638,14 @@ function check$3(input) {
 	}
 	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(input.variable.references, (reference) => reference.identifier)], (node) => isSome(variableFromScope({
+		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((reference) => renamed({
+				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
@@ -1646,11 +1662,11 @@ function check$3(input) {
 }
 const moduleConstant = defineRule({
 	create: (context) => ({ Program: (program) => {
-		const leadingEnd = pipe(program.body, takeWhile((statement) => statement.type === "ImportDeclaration" || isSome(literalConstant(statement))), last, map$1((statement) => statement.range[1]), getOrElse(() => 0));
+		const leadingEnd = pipe(program.body, takeWhile((statement) => statement.type === "ImportDeclaration" || isSome(literalConstant(statement))), last, map((statement) => statement.range[1]), getOrElse(() => 0));
 		for (const statement of program.body) pipe(literalConstant(statement), flatMap$1((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$1((variable) => ({
+		}), filter((variable) => !some$1(variable.references, (reference) => reference.identifier.parent.type === "ExportSpecifier")), map((variable) => ({
 			found,
 			variable
 		})))), match({
@@ -1670,7 +1686,7 @@ const moduleConstant = defineRule({
 // src/rules/motion-limits.ts
 const MOTION_UTILITY = /duration-|zoom-|scale-/u;
 function amount(token, pattern) {
-	return pipe(token, match$1(pattern), flatMap$1((match) => fromNullishOr(match[1])), map$1((value) => pipe(parse(value), getOrElse(() => 0))));
+	return pipe(token, match$1(pattern), flatMap$1((match) => fromNullishOr(match[1])), map((value) => pipe(parse(value), getOrElse(() => 0))));
 }
 function violation(token) {
 	const name = pipe(token, split(":"), last, getOrElse(() => token), replaceAll(/^!|!$/gu, ""));
@@ -1681,7 +1697,7 @@ function violation(token) {
 }
 function check$2(context, node, text) {
 	if (!MOTION_UTILITY.test(text)) return;
-	pipe(split(text, /\s+/u), findFirst(violation), map$1((message) => context.report({
+	pipe(split(text, /\s+/u), findFirst(violation), map((message) => context.report({
 		message,
 		node
 	})));
@@ -1776,8 +1792,8 @@ const noAccumulatingCopy = defineRule({
 			pipe(variableFromScope({
 				name: parameter.name,
 				scope: context.sourceCode.getScope(callback)
-			}), map$1((variable) => {
-				for (const reference of variable.references) pipe(copySite(context, reference.identifier), filter((copy) => !has(reported, copy.range[0])), map$1((copy) => {
+			}), map((variable) => {
+				for (const reference of variable.references) pipe(copySite(context, reference.identifier), filter((copy) => !has(reported, copy.range[0])), map((copy) => {
 					add(reported, copy.range[0]);
 					context.report({
 						message: "Copying the accumulator in a fold can make collection building quadratic. Prefer Array.map/filterMap/flatMap/groupBy, Record.fromEntries, Array.mapAccum, or a local MutableList/MutableHashMap collector.",
@@ -1850,10 +1866,7 @@ const noComponentAtomAllocation = defineRule({
 function isConstantFunction(input) {
 	if (input.node.async || input.node.generator || isArrayNonEmpty(input.node.params) || isNotNullish(input.node.typeParameters)) return false;
 	const returned = returnedExpression(input.node);
-	return isNotNullish(returned) && (returned.type === "Literal" && !hasProperty(returned, "regex") || returned.type === "TemplateLiteral" && isArrayEmpty(returned.expressions)) && pipe(bindingName(input.node), flatMap$1((name) => variableFromScope({
-		name,
-		scope: input.context.sourceCode.getScope(input.node)
-	})), exists((variable) => every(filter$1(variable.references, (reference) => reference.isRead()), (reference) => reference.identifier.parent.type === "CallExpression" && reference.identifier.parent.callee === reference.identifier)));
+	return isNotNullish(returned) && (returned.type === "Literal" && !hasProperty(returned, "regex") || returned.type === "TemplateLiteral" && isArrayEmpty(returned.expressions)) && exists(boundReads(input), (reads) => every(reads, (reference) => reference.identifier.parent.type === "CallExpression" && reference.identifier.parent.callee === reference.identifier));
 }
 function isConstBound(node) {
 	return node.parent.type === "VariableDeclarator" && node.parent.parent.type === "VariableDeclaration" && node.parent.parent.kind === "const";
@@ -2041,7 +2054,7 @@ function operands(input) {
 function comparedNullish(input) {
 	if (input.node.type !== "BinaryExpression" || input.node.operator !== input.operator) return none();
 	const subject = input.node.left;
-	return map$1(nullishOperand({
+	return map(nullishOperand({
 		context: input.context,
 		node: input.node.right
 	}), (nullish) => ({
@@ -2059,7 +2072,7 @@ function guardCall(input) {
 		first: input.checks[0],
 		second: input.checks[1]
 	}) || input.context.sourceCode.getTokensBetween(input.checks[0].node, input.checks[1].node).length !== 1) return none();
-	return map$1(effectImport({
+	return map(effectImport({
 		context: input.context,
 		fixer: input.fixer,
 		name: "Predicate",
@@ -2071,7 +2084,7 @@ const noDoubleNullishCheck = defineRule({
 		if (node.operator === "??") return;
 		if (node.parent.type === "LogicalExpression" && node.parent.operator === node.operator) return;
 		const variant = VARIANTS[node.operator];
-		const checks = map(operands({
+		const checks = map$1(operands({
 			node,
 			operator: node.operator
 		}), (operand) => comparedNullish({
@@ -2114,7 +2127,7 @@ function generator(context, node) {
 		propertyName: "gen"
 	}) || node.arguments.length !== 1) return none();
 	const effect = node.callee.object;
-	return pipe(head(node.arguments), filter((argument) => argument.type === "FunctionExpression" && argument.generator && !argument.async && argument.id === null && isArrayEmpty(argument.params) && argument.body !== null && isNone(match$1(/\b(?:arguments|this)\b/u)(context.sourceCode.getText(argument.body)))), map$1((body) => ({
+	return pipe(head(node.arguments), filter((argument) => argument.type === "FunctionExpression" && argument.generator && !argument.async && argument.id === null && isArrayEmpty(argument.params) && argument.body !== null && isNone(match$1(/\b(?:arguments|this)\b/u)(context.sourceCode.getText(argument.body)))), map((body) => ({
 		body,
 		effect
 	})));
@@ -2227,12 +2240,10 @@ function recoversEmpty(context, name, node) {
 }
 const noEmptyRecovery = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		if (node.callee.type !== "MemberExpression" || !importedMember({
+		const name = pipe(effectMethod({
 			context,
-			importedName: "Effect",
-			node: node.callee
-		})) return;
-		const name = pipe(memberName(node.callee), getOrElse(() => ""));
+			node
+		}), getOrElse(() => ""));
 		if (!pipe(name, startsWith("catch")) && !pipe(name, startsWith("orElse"))) return;
 		for (const argument of node.arguments) {
 			const callback = resolveBinding(context, argument);
@@ -2329,17 +2340,16 @@ function inspectPredicate(context, node) {
 }
 const noErrorMessageControlFlow = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		if (node.callee.type !== "MemberExpression" || !importedMember({
+		const method = effectMethod({
 			context,
-			importedName: "Effect",
-			node: node.callee
-		})) return;
-		if (contains$1(memberName(node.callee), "catchIf")) {
+			node
+		});
+		if (contains$1(method, "catchIf")) {
 			if (node.arguments.length === 3) inspectPredicate(context, node.arguments[1]);
 			if (node.arguments.length === 2) inspectPredicate(context, node.arguments[0]);
 			return;
 		}
-		if (!contains$1(memberName(node.callee), "retry")) return;
+		if (!contains$1(method, "retry")) return;
 		for (const property of flatMap(node.arguments, (argument) => {
 			if (argument.type === "ObjectExpression") return argument.properties;
 			return [];
@@ -2504,7 +2514,7 @@ function check(input) {
 	}), check({
 		name: input.name,
 		node: input.node.right
-	})]), map$1(flatten));
+	})]), map(flatten));
 	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
@@ -2530,7 +2540,7 @@ function check(input) {
 		operator: input.node.operator,
 		other: input.node.left,
 		subject: input.node.right
-	})]), map$1(of));
+	})]), map(of));
 }
 function replaceableGuard(node) {
 	const predicate = node.returnType?.typeAnnotation;
@@ -2539,7 +2549,7 @@ function replaceableGuard(node) {
 	return pipe(check({
 		name: predicate.parameterName.name,
 		node: returned
-	}), map$1((checks) => pipe(checks, sort(Order), join(" && "))), flatMap$1((key) => get$2({
+	}), map((checks) => pipe(checks, sort(Order), join(" && "))), flatMap$1((key) => get$2({
 		"!= null": "isNotNullish",
 		"!== null": "isNotNull",
 		"!== null && !Array.isArray && typeof === object": "isObject",
@@ -2564,7 +2574,7 @@ function replaceableGuard(node) {
 	}, key)));
 }
 function report$4(input) {
-	map$1(replaceableGuard(input.node), (guard) => input.context.report({
+	map(replaceableGuard(input.node), (guard) => input.context.report({
 		message: `Use Predicate.${guard} instead of this hand-written type guard.`,
 		node: input.node
 	}));
@@ -2637,7 +2647,7 @@ const PRIMITIVES = {
 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(node.quasis, (quasi) => quasi.value.raw);
+	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(node.arguments, classStrings);
 	if (node.type === "ConditionalExpression") return flatMap([node.consequent, node.alternate], classStrings);
@@ -2649,8 +2659,8 @@ const noNativeControl = defineRule({
 	create: (context) => ({ JSXOpeningElement: (node) => {
 		if (node.name.type !== "JSXIdentifier") return;
 		const name = node.name.name;
-		map$1(get$2(PRIMITIVES, name), (primitive) => {
-			const styled = pipe(node.attributes, findFirst((attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "className"), map$1((attribute) => {
+		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$2();
 				return classStrings(attribute.value);
 			}), exists((values) => some$1(values, (value) => some$1(split(value, /\s+/u), matches(CONTROL_STYLE)))));
@@ -2674,7 +2684,7 @@ const noNativeEmptinessCheck = defineRule({
 			context,
 			node: node.left
 		})) return;
-		map$1(lengthTest(node), (test) => {
+		map(lengthTest(node), (test) => {
 			context.report({
 				message: `Use ${PREDICATES[test]}.`,
 				node
@@ -2770,10 +2780,10 @@ const noNativeMethodCall = defineRule({
 			"entries",
 			"keys",
 			"values"
-		], name) || isArrayEmpty(node.arguments)), flatMap$1((name) => pipe(get$2(REPLACEMENTS, name), map$1((replacement) => ({
+		], name) || isArrayEmpty(node.arguments)), flatMap$1((name) => pipe(get$2(REPLACEMENTS, name), map((replacement) => ({
 			name,
 			replacement
-		})))), map$1((method) => context.report({
+		})))), 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
 		})));
@@ -2900,8 +2910,8 @@ function receiverText(context, node) {
 function fix$5(input) {
 	const calls = chain(input.node);
 	if (!rewritable(input.context, calls)) return [];
-	const steps = filter$1(map(calls, (call) => argumentsText(input.context, call)), (text) => isNonEmpty(text));
-	return getOrElse(flatMap$1(head(calls), (innermost) => map$1(effectImport({
+	const steps = filter$1(map$1(calls, (call) => argumentsText(input.context, call)), (text) => isNonEmpty(text));
+	return getOrElse(flatMap$1(head(calls), (innermost) => map(effectImport({
 		context: input.context,
 		fixer: input.fixer,
 		name: "pipe",
@@ -2919,7 +2929,7 @@ const noPipeMethod = defineRule({
 			});
 			return;
 		}
-		if (call.parent?.type === "MemberExpression" && isNotNullish(call.parent.parent) && pipeCall(call.parent.parent)) {
+		if (call.parent.type === "MemberExpression" && isNotNullish(call.parent.parent) && pipeCall(call.parent.parent)) {
 			context.report({
 				message: MESSAGE$5,
 				node
@@ -3043,31 +3053,23 @@ const noPollingTest = defineRule({
 		}
 		return {
 			CallExpression: (node) => {
-				if (node.callee.type !== "MemberExpression") return;
-				const callee = node.callee;
-				if (importedMember({
+				const method = effectMethod({
 					context,
-					importedName: "Effect",
-					node: callee,
-					propertyName: "eventually"
-				})) {
+					node
+				});
+				if (contains$1(method, "eventually")) {
 					context.report({
 						message: MESSAGE$4,
 						node
 					});
 					return;
 				}
-				if (some$1([
+				if (exists(method, (name) => contains([
 					"repeat",
 					"repeatOrElse",
 					"retry",
 					"retryOrElse"
-				], (propertyName) => importedMember({
-					context,
-					importedName: "Effect",
-					node: callee,
-					propertyName
-				})) && (containsNode({
+				], name)) && (containsNode({
 					context,
 					matches: (child) => isWait(context, child),
 					node: pipedFrom(node),
@@ -3150,7 +3152,7 @@ function enclosed(input) {
 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(input.reads, (read) => ({
+	const paths = map$1(input.reads, (read) => ({
 		callback: enclosed({
 			block,
 			node: read,
@@ -3181,7 +3183,7 @@ function replacement(input) {
 	return input.text;
 }
 function report$3(input) {
-	const reads = pipe(input.variable.references, filter$1((reference) => reference.isRead()), map((reference) => reference.identifier));
+	const reads = pipe(input.variable.references, filter$1((reference) => reference.isRead()), map$1((reference) => reference.identifier));
 	const text = input.context.sourceCode.getText(input.init);
 	const aliasRequired = needsAlias({
 		context: input.context,
@@ -3232,7 +3234,7 @@ function report$3(input) {
 					node,
 					read
 				})) || !every(input.context.sourceCode.getTokensBetween(input.declaration, read), inert$1))) return [];
-				return [fixer.remove(input.declaration), ...map(reads, (read) => fixer.replaceText(read, replacement({
+				return [fixer.remove(input.declaration), ...map$1(reads, (read) => fixer.replaceText(read, replacement({
 					name: input.name,
 					read,
 					text
@@ -3320,7 +3322,7 @@ const noRedundantStateType = defineRule({
 			propertyName: "make"
 		})))) return;
 		if (isString(argument.value) && type?.type === "TSStringKeyword" || isNumber$1(argument.value) && type?.type === "TSNumberKeyword" || isBoolean(argument.value) && type?.type === "TSBooleanKeyword") context.report({
-			fix: (fixer) => toArray$1(map$1(fromNullishOr(node.typeArguments), (typeArguments) => fixer.remove(typeArguments))),
+			fix: (fixer) => toArray$1(map(fromNullishOr(node.typeArguments), (typeArguments) => fixer.remove(typeArguments))),
 			message: "Drop this state type; the initializer infers the same primitive type.",
 			node: type
 		});
@@ -3352,7 +3354,7 @@ function nullableType(input) {
 function removeNull(input) {
 	const before = input.context.sourceCode.getTokenBefore(input.member);
 	if (before?.value === "|" && before.range[0] >= input.type.range[0]) return some(input.fixer.removeRange([before.range[0], input.member.range[1]]));
-	return pipe(fromNullishOr(input.context.sourceCode.getTokenAfter(input.member)), filter((token) => token.value === "|"), map$1((token) => input.fixer.removeRange([input.member.range[0], token.range[1]])));
+	return pipe(fromNullishOr(input.context.sourceCode.getTokenAfter(input.member)), filter((token) => token.value === "|"), map((token) => input.fixer.removeRange([input.member.range[0], token.range[1]])));
 }
 const noRedundantUseRefNullType = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
@@ -3389,7 +3391,7 @@ function fix$4(input) {
 		name: "Array",
 		scope: input.context.sourceCode.getScope(input.init)
 	}), (variable) => some$1(variable.defs, (definition) => definition.type === "ImportBinding" && definition.parent?.type === "ImportDeclaration" && definition.parent.source.value === "effect"))) return [];
-	return getOrElse(flatMap$1(elementType(input.annotation.typeAnnotation), (element) => map$1(effectImport({
+	return getOrElse(flatMap$1(elementType(input.annotation.typeAnnotation), (element) => map(effectImport({
 		context: input.context,
 		fixer: input.fixer,
 		name: "Array",
@@ -3477,7 +3479,7 @@ function shippedSchema(input) {
 	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$1((entry) => entry.schema));
+	})), map((entry) => entry.schema));
 }
 function pipedBase(node) {
 	if (node.parent.type !== "CallExpression") return none();
@@ -3511,7 +3513,7 @@ function reinventedSchema(input) {
 }
 const noReinventedSchema = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		map$1(reinventedSchema({
+		map(reinventedSchema({
 			context,
 			node
 		}), (schema) => {
@@ -3548,7 +3550,7 @@ function fix$3(input) {
 			...input,
 			reference
 		}))) return none();
-		return some([input.fixer.removeRange([input.node.imported.range[1], input.node.local.range[1]]), ...map(variable.references, (reference) => {
+		return some([input.fixer.removeRange([input.node.imported.range[1], input.node.local.range[1]]), ...map$1(variable.references, (reference) => {
 			if (reference.identifier.parent.type === "Property" && reference.identifier.parent.shorthand) return input.fixer.replaceText(reference.identifier.parent, `${input.node.local.name}: ${input.imported}`);
 			return input.fixer.replaceText(reference.identifier, input.imported);
 		})]);
@@ -3615,7 +3617,7 @@ function reaches(input) {
 	if (isArrayEmpty(next)) return false;
 	return reaches({
 		...input,
-		nodes: pipe(next, flatMap((variable) => variable.defs), filter$1((definition) => definition.type === "FunctionName" || definition.type === "Variable"), map((definition) => definition.node)),
+		nodes: pipe(next, flatMap((variable) => variable.defs), filter$1((definition) => definition.type === "FunctionName" || definition.type === "Variable"), map$1((definition) => definition.node)),
 		visited: appendAll(input.visited, next)
 	});
 }
@@ -3718,7 +3720,7 @@ function forwardedChain(input) {
 	});
 }
 function exactForwardingFunction(input) {
-	const names = pipe(input.node.params, map(parameterName), getSomes);
+	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(returned)) return false;
 	if (returned.type === "Identifier") return names.length === 1 && returned.name === names[0];
@@ -3760,14 +3762,15 @@ function copiesSafely(input) {
 	});
 }
 function singleUseFunction(input) {
-	const names = pipe(input.node.params, map(parameterName), getSomes);
+	const names = pipe(input.node.params, map$1(parameterName), getSomes);
 	const returned = returnedExpression(input.node);
 	if (input.node.async || input.node.generator || input.node.typeParameters !== null || input.node.returnType?.typeAnnotation.type === "TSTypePredicate" || isArrayEmpty(names) || names.length !== input.node.params.length || isNullish(returned)) return false;
 	const oneLine = !pipe(input.context.sourceCode.getText(returned), includes("\n"));
-	return pipe(unexportedBindingName(input.node), flatMap$1((name) => variableFromScope({
+	return pipe(unexportedBindingName(input.node), flatMap$1((name) => readsOf({
+		context: input.context,
 		name,
-		scope: input.context.sourceCode.getScope(input.node)
-	})), map$1((variable) => filter$1(variable.references, (reference) => reference.isRead())), filter((reads) => reads.length === 1), flatMap$1(head), map$1((reference) => reference.identifier), filter((read) => read.range[0] < input.node.range[0] || read.range[0] > input.node.range[1]), exists((read) => {
+		node: input.node
+	})), filter((reads) => reads.length === 1), flatMap$1(head), map((reference) => reference.identifier), filter((read) => read.range[0] < input.node.range[0] || read.range[0] > input.node.range[1]), exists((read) => {
 		if (read.parent.type !== "CallExpression") return false;
 		if (read.parent.callee !== read) return oneLine && some$1(read.parent.arguments, (argument) => argument === read);
 		if (!copiesSafely({
@@ -3791,20 +3794,22 @@ function redundantConstAlias(input) {
 			return definition.node.type === "VariableDeclarator" && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const";
 		});
 	}))) return false;
-	return pipe(variableFromScope({
+	return pipe(readsOf({
+		context: input.context,
 		name: input.node.id.name,
-		scope: input.context.sourceCode.getScope(input.node)
-	}), exists((alias) => countBy(alias.references, (reference) => reference.isRead()) === 1));
+		node: input.node
+	}), exists((reads) => reads.length === 1));
 }
 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.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({
+	return pipe(readsOf({
+		context: input.context,
 		name: input.node.id.name,
-		scope: input.context.sourceCode.getScope(input.node)
-	}), map$1((variable) => filter$1(variable.references, (reference) => reference.isRead())), exists((reads) => reads.length === 1 && reads[0]?.identifier.parent.type !== "ExportSpecifier"));
+		node: input.node
+	}), exists((reads) => reads.length === 1 && reads[0]?.identifier.parent.type !== "ExportSpecifier"));
 }
 function singleUseLayerPart(input) {
 	const init = input.node.init;
@@ -3814,10 +3819,11 @@ function singleUseLayerPart(input) {
 		node: init.callee,
 		propertyName: "gen"
 	}))) return false;
-	return pipe(variableFromScope({
+	return pipe(readsOf({
+		context: input.context,
 		name: input.node.id.name,
-		scope: input.context.sourceCode.getScope(input.node)
-	}), map$1((variable) => filter$1(variable.references, (reference) => reference.isRead())), exists((reads) => {
+		node: input.node
+	}), exists((reads) => {
 		const consumer = reads[0]?.identifier.parent;
 		if (reads.length !== 1 || consumer?.type !== "CallExpression") return false;
 		if (init.type === "MemberExpression") return importedMember({
@@ -4057,10 +4063,11 @@ function report$2(input) {
 	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$1((index) => get$3(statements, index + 1)), flatMap$1((next) => pipe(variableFromScope({
+	pipe(findFirstIndex(statements, (statement) => statement === declaration), flatMap$1((index) => get$3(statements, index + 1)), flatMap$1((next) => pipe(readsOf({
+		context: input.context,
 		name,
-		scope: input.context.sourceCode.getScope(input.node)
-	}), map$1((variable) => filter$1(variable.references, (reference) => reference.isRead())), filter((reads) => reads.length === 1), flatMap$1(head), map$1((reference) => reference.identifier), filter((read) => read.range[0] >= next.range[0] && read.range[1] <= next.range[1] && climb({
+		node: input.node
+	}), filter((reads) => reads.length === 1), flatMap$1(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({
@@ -4070,7 +4077,7 @@ function report$2(input) {
 	}) && !(init.type === "ConditionalExpression" && insideConditional({
 		node: read,
 		statement: next
-	})) && !(suspends(input.context, init) && receiver(outermost(read))) && !some$1(input.effects, (effect) => effect.range[0] >= next.range[0] && effect.range[1] <= read.range[0])), map$1((read) => ({
+	})) && !(suspends(input.context, init) && receiver(outermost(read))) && !some$1(input.effects, (effect) => effect.range[0] >= next.range[0] && effect.range[1] <= read.range[0])), map((read) => ({
 		next,
 		read
 	})))), match({
@@ -4139,12 +4146,7 @@ function skips(context, node) {
 			context,
 			node: chain.root,
 			source: TEST_RUNNERS
-		}) || !contains([
-			"describe",
-			"it",
-			"suite",
-			"test"
-		], chain.root.name) || hasEffectMember(chain.members));
+		}) || hasEffectMember(chain.members));
 	}));
 }
 const noSkippedTest = defineRule({
@@ -4283,7 +4285,7 @@ function branches(node) {
 function returns(context, node) {
 	const chain = branches(node);
 	if (some$1(chain.tests, (test) => test.consequent.type === "ConditionalExpression")) return [];
-	return [...map(chain.tests, (test) => `if (${context.sourceCode.getText(test.test)}) return ${context.sourceCode.getText(test.consequent)}`), `return ${context.sourceCode.getText(chain.last)}`];
+	return [...map$1(chain.tests, (test) => `if (${context.sourceCode.getText(test.test)}) return ${context.sourceCode.getText(test.consequent)}`), `return ${context.sourceCode.getText(chain.last)}`];
 }
 function inStatementList(node) {
 	return node.parent?.type === "BlockStatement" || node.parent?.type === "StaticBlock" || node.parent?.type === "SwitchCase";
@@ -4483,7 +4485,7 @@ function fix$1(input) {
 	const guard = GUARDS[input.node.parent.right.value];
 	if (guard === void 0) return [];
 	const replacement = input.fixer.replaceTextRange(input.node.parent.range, `${NEGATIONS[input.node.parent.operator]}Predicate.${guard}(${input.node.argument.name})`);
-	return getOrElse(map$1(effectImport({
+	return getOrElse(map(effectImport({
 		context: input.context,
 		fixer: input.fixer,
 		name: "Predicate",
@@ -4621,7 +4623,7 @@ const WALL_CLOCKS = [
 function globalPath(context, node) {
 	if (node.type === "Identifier") return liftPredicate(node.name, () => !exists(variableFor(context, node), (variable) => isArrayNonEmpty(variable.defs)));
 	if (node.type !== "MemberExpression") return none();
-	return flatMap$1(memberName(node), (name) => map$1(globalPath(context, node.object), (path) => `${path}.${name}`));
+	return flatMap$1(memberName(node), (name) => map(globalPath(context, node.object), (path) => `${path}.${name}`));
 }
 function readsRealTime(context, node) {
 	if (importedMember({
@@ -4798,12 +4800,10 @@ function reportOption(context, key, bare, options) {
 }
 const preserveErrorCause = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		if (node.callee.type !== "MemberExpression" || !importedMember({
+		const name = effectMethod({
 			context,
-			importedName: "Effect",
-			node: node.callee
-		})) return;
-		const name = memberName(node.callee);
+			node
+		});
 		if (contains$1(name, "mapError")) {
 			const bare = detailedFailure(context, node);
 			forEach(filter$1(node.arguments, (argument) => dropsCause(context, argument, bare)), (callback) => report$1(context, callback));
@@ -4997,7 +4997,7 @@ function reportSchemaVariable(input) {
 				name
 			})) return [];
 			const start = pipe(input.context.sourceCode.getCommentsBefore(input.statement), head, getOrElse(() => input.statement)).range[0];
-			return [fixer.insertTextBeforeRange([start, start], `${EXPORT_PREFIXES[input.statement.type] ?? ""}type ${name} = typeof ${name}.Type\n`), ...pipe(input.queries, filter$1((query) => contains$1(queriedSchema(query), name) && readsModuleBinding(input.context, query, name)), map((query) => fixer.replaceText(query, name)))];
+			return [fixer.insertTextBeforeRange([start, start], `${EXPORT_PREFIXES[input.statement.type] ?? ""}type ${name} = typeof ${name}.Type\n`), ...pipe(input.queries, filter$1((query) => contains$1(queriedSchema(query), name) && readsModuleBinding(input.context, query, name)), map$1((query) => fixer.replaceText(query, name)))];
 		},
 		message: `Place \`type ${name} = typeof ${name}.Type\` immediately before this Schema.`,
 		node: input.variable
@@ -5023,7 +5023,7 @@ const schemaTypePair = defineRule({
 		const seeds = make$2();
 		return {
 			CallExpression: (node) => {
-				map$1(suspendedTypeName({
+				map(suspendedTypeName({
 					context,
 					node
 				}), (name) => append$1(seeds, name));
@@ -5098,7 +5098,7 @@ const swiftuiThemeValues = defineRule({
 				const name = calleeName(node);
 				if (contains(["listRowInsets", "padding"], name) && some$1(properties(node.arguments[0]), (property) => isNumber(property.value)) || name === "lineSpacing" && isNumber(node.arguments[0])) report(context, node, "Space with the theme’s spacing steps, such as padding({all: space[4]}).");
 				if (name === "font" && some$1(properties(node.arguments[0]), (property) => keyOf(property) === "size")) report(context, node, "Set type with a text token or a Dynamic Type textStyle, not a point size.");
-				if (contains(PAINTS, name) && some$1(flatMap(node.arguments, (argument) => [argument, ...map(properties(argument), (property) => property.value)]), (value) => value.type === "Literal" && isString(value.value) && isSome(match$1(/^#[\da-f]{3,8}$/iu)(value.value)))) report(context, node, "Paint with the theme’s colors, which follow light and dark, not a hex string.");
+				if (contains(PAINTS, name) && some$1(flatMap(node.arguments, (argument) => [argument, ...map$1(properties(argument), (property) => property.value)]), (value) => value.type === "Literal" && isString(value.value) && isSome(match$1(/^#[\da-f]{3,8}$/iu)(value.value)))) report(context, node, "Paint with the theme’s colors, which follow light and dark, not a hex string.");
 			},
 			ImportDeclaration: (node) => {
 				if (startsWith("@expo/ui/swift-ui")(node.source.value)) file.swiftui = true;
@@ -5294,12 +5294,15 @@ const lint = {
 		{
 			files: ["**/*.tsx"],
 			rules: {
+				"effecttsgo/async-function": "off",
 				"eslint/require-await": "error",
+				"typescript/strict-void-return": "off",
 				"unicorn/no-null": "off"
 			}
 		}
 	],
 	plugins: [
+		"effecttsgo",
 		"eslint",
 		"typescript",
 		"oxc",
@@ -5311,6 +5314,123 @@ const lint = {
 	],
 	rules: {
 		...mapEntries(RULES, (_, name) => [`@deslop/coding-standards/${name}`, "error"]),
+		"effecttsgo/any-unknown-in-error-context": "error",
+		"effecttsgo/class-self-mismatch": "error",
+		"effecttsgo/duplicate-package": "error",
+		"effecttsgo/effect-fn-implicit-any": "error",
+		"effecttsgo/error-payload-shadows-name": "error",
+		"effecttsgo/floating-effect": "error",
+		"effecttsgo/floating-effect-in-vitest": "error",
+		"effecttsgo/missing-effect-context": "error",
+		"effecttsgo/missing-effect-error": "error",
+		"effecttsgo/missing-layer-context": "error",
+		"effecttsgo/missing-return-yield-star": "error",
+		"effecttsgo/missing-star-in-yield-effect-gen": "error",
+		"effecttsgo/obsolete-match-import": "error",
+		"effecttsgo/obsolete-schema-import": "error",
+		"effecttsgo/outdated-api": "error",
+		"effecttsgo/overridden-schema-constructor": "error",
+		"effecttsgo/promise-in-effect-success": "error",
+		"effecttsgo/schema-class-object-literal": "error",
+		"effecttsgo/schema-literal-non-finite": "error",
+		"effecttsgo/unsafe-effect-type-assertion": "error",
+		"effecttsgo/catch-unfailable-effect": "error",
+		"effecttsgo/effect-fn-iife": "error",
+		"effecttsgo/effect-gen-uses-adapter": "error",
+		"effecttsgo/effect-in-failure": "error",
+		"effecttsgo/effect-in-void-success": "error",
+		"effecttsgo/effect-try-without-catch": "error",
+		"effecttsgo/global-error-in-effect-catch": "error",
+		"effecttsgo/global-error-in-effect-failure": "error",
+		"effecttsgo/layer-merge-all-with-dependencies": "error",
+		"effecttsgo/lazy-effect": "error",
+		"effecttsgo/lazy-promise-in-effect-sync": "error",
+		"effecttsgo/leaking-requirements": "error",
+		"effecttsgo/multiple-effect-provide": "error",
+		"effecttsgo/return-effect-in-gen": "error",
+		"effecttsgo/schema-sync-in-effect": "error",
+		"effecttsgo/strict-effect-provide": "error",
+		"effecttsgo/try-catch-in-effect-gen": "error",
+		"effecttsgo/async-function": "error",
+		"effecttsgo/global-console": "error",
+		"effecttsgo/global-console-in-effect": "error",
+		"effecttsgo/global-date": "error",
+		"effecttsgo/global-date-in-effect": "error",
+		"effecttsgo/global-fetch": "error",
+		"effecttsgo/global-fetch-in-effect": "error",
+		"effecttsgo/global-json": "error",
+		"effecttsgo/global-json-in-effect": "error",
+		"effecttsgo/global-random": "error",
+		"effecttsgo/global-random-in-effect": "error",
+		"effecttsgo/global-timers": "error",
+		"effecttsgo/global-timers-in-effect": "error",
+		"effecttsgo/instance-of-schema": "error",
+		"effecttsgo/node-builtin-import": "error",
+		"effecttsgo/prefer-effect-array": "error",
+		"effecttsgo/prefer-effect-record": "error",
+		"effecttsgo/prefer-effect-string": "error",
+		"effecttsgo/process-env": "error",
+		"effecttsgo/process-env-in-effect": "error",
+		"effecttsgo/acquire-release-disposable": "error",
+		"effecttsgo/all-of-map-to-for-each": "error",
+		"effecttsgo/catch-all-tag-dispatch-to-catch-tag": "error",
+		"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-if-tag-to-catch-tag": "error",
+		"effecttsgo/catch-refail-to-tap-error": "error",
+		"effecttsgo/catch-tag-to-catch-reason": "error",
+		"effecttsgo/catch-to-or-else-succeed": "error",
+		"effecttsgo/deterministic-keys": "error",
+		"effecttsgo/effect-do-notation": "error",
+		"effecttsgo/effect-fn-opportunity": "error",
+		"effecttsgo/effect-map-flatten": "error",
+		"effecttsgo/effect-map-void": "error",
+		"effecttsgo/effect-sleep-zero-to-yield-now": "error",
+		"effecttsgo/effect-succeed-with-undefined": "error",
+		"effecttsgo/effect-succeed-with-void": "error",
+		"effecttsgo/fail-cause-to-constructor": "error",
+		"effecttsgo/flat-map-conditional-to-filter-or-fail": "error",
+		"effecttsgo/flat-map-identity-to-flatten": "error",
+		"effecttsgo/flat-map-ignored-param-to-and-then": "error",
+		"effecttsgo/flat-map-to-map": "error",
+		"effecttsgo/flat-map-to-tap": "error",
+		"effecttsgo/manual-metric-tap-to-track": "error",
+		"effecttsgo/map-const-to-as": "error",
+		"effecttsgo/map-map-error-to-map-both": "error",
+		"effecttsgo/map-some-catch-no-such-element": "error",
+		"effecttsgo/map-some-to-as-some": "error",
+		"effecttsgo/match-boolean-to-is-success": "error",
+		"effecttsgo/match-effect-to-map-both": "error",
+		"effecttsgo/match-effect-to-match": "error",
+		"effecttsgo/match-to-result-or-option": "error",
+		"effecttsgo/multiple-catch-tag": "error",
+		"effecttsgo/nested-effect-gen-yield": "error",
+		"effecttsgo/new-schema-class": "error",
+		"effecttsgo/option-match-to-from-option": "error",
+		"effecttsgo/prefer-schema-type-property": "error",
+		"effecttsgo/prefer-succeed-some-or-none": "error",
+		"effecttsgo/prefer-typed-schema-decoder": "error",
+		"effecttsgo/provide-layer-succeed-to-provide-service": "error",
+		"effecttsgo/provide-merge-all-to-array": "error",
+		"effecttsgo/race-first-with-sleep-to-timeout": "error",
+		"effecttsgo/redundant-map-error": "error",
+		"effecttsgo/redundant-or-die": "error",
+		"effecttsgo/redundant-schema-tag-identifier": "error",
+		"effecttsgo/result-match-to-from-result": "error",
+		"effecttsgo/run-of-exit-to-run-exit": "error",
+		"effecttsgo/schema-number": "error",
+		"effecttsgo/schema-struct-with-tag": "error",
+		"effecttsgo/service-not-as-class": "error",
+		"effecttsgo/suspend-fail-to-fail-sync": "error",
+		"effecttsgo/sync-to-succeed": "error",
+		"effecttsgo/timeout-catch-tag-to-timeout-or-else": "error",
+		"effecttsgo/type-union-to-schema-union": "error",
+		"effecttsgo/unnecessary-effect-gen": "error",
+		"effecttsgo/unnecessary-fail-yieldable-error": "error",
+		"effecttsgo/unnecessary-pipe": "error",
+		"effecttsgo/unnecessary-pipe-chain": "error",
+		"effecttsgo/unnecessary-typeof-type": "error",
 		"eslint/arrow-body-style": ["error", "as-needed"],
 		"eslint/constructor-super": "error",
 		"eslint/curly": [
@@ -5377,10 +5497,18 @@ const lint = {
 				message: "Import Array from 'effect'.",
 				name: "Array"
 			},
+			{
+				message: "Use Base64 or Base64Url from effect/encoding.",
+				name: "atob"
+			},
 			{
 				message: "Import Boolean from 'effect'.",
 				name: "Boolean"
 			},
+			{
+				message: "Use Base64 or Base64Url from effect/encoding.",
+				name: "btoa"
+			},
 			{
 				message: "Use the effect/crypto services: SecureRandom, Digest, Signature.",
 				name: "crypto"
@@ -5552,7 +5680,7 @@ const lint = {
 				message: "Use Record or Struct from 'effect'.",
 				object: "Object"
 			},
-			...map(RUNNERS, (property) => ({
+			...map$1(RUNNERS, (property) => ({
 				message: RUN_MESSAGE,
 				object: "Effect",
 				property
@@ -5582,12 +5710,12 @@ const lint = {
 				object: "Math",
 				property: "round"
 			},
-			...map(REACT_LEGACY_APIS, (property) => ({
+			...map$1(REACT_LEGACY_APIS, (property) => ({
 				message: REACT_LEGACY_MESSAGE,
 				object: "React",
 				property
 			})),
-			...map(REACT_HOOKS, (property) => ({
+			...map$1(REACT_HOOKS, (property) => ({
 				message: `Import ${property} by name from react.`,
 				object: "React",
 				property
@@ -5627,7 +5755,7 @@ const lint = {
 				object: "Data",
 				property: "TaggedError"
 			},
-			...map([
+			...map$1([
 				"addEventListener",
 				"atob",
 				"btoa",
@@ -5647,7 +5775,7 @@ const lint = {
 				object: "window",
 				property
 			})),
-			...map([
+			...map$1([
 				"clearInterval",
 				"clearTimeout",
 				"setInterval",
@@ -5723,7 +5851,6 @@ const lint = {
 		"eslint/no-with": "error",
 		"eslint/object-shorthand": "error",
 		"eslint/prefer-arrow-callback": "error",
-		"eslint/prefer-const": ["error", { destructuring: "all" }],
 		"eslint/prefer-template": "error",
 		"eslint/preserve-caught-error": "error",
 		"eslint/require-yield": "error",
@@ -5935,7 +6062,7 @@ const lint = {
 		"typescript/no-explicit-any": "error",
 		"typescript/no-extraneous-class": "error",
 		"typescript/no-import-type-side-effects": "error",
-		"typescript/no-inferrable-types": "error",
+		"typescript/no-inferrable-types": ["error", { ignoreParameters: true }],
 		"typescript/no-misused-new": "error",
 		"typescript/no-namespace": ["error", { allowDeclarations: true }],
 		"typescript/no-non-null-assertion": "error",
@@ -5962,6 +6089,47 @@ const lint = {
 		"typescript/prefer-function-type": "error",
 		"typescript/triple-slash-reference": "error",
 		"typescript/unified-signatures": "error",
+		"typescript/await-thenable": "error",
+		"typescript/consistent-type-exports": "error",
+		"typescript/dot-notation": "error",
+		"typescript/no-array-delete": "error",
+		"typescript/no-base-to-string": "error",
+		"typescript/no-confusing-void-expression": ["error", { ignoreVoidReturningFunctions: true }],
+		"typescript/no-deprecated": "error",
+		"typescript/no-duplicate-type-constituents": "error",
+		"typescript/no-floating-promises": "error",
+		"typescript/no-for-in-array": "error",
+		"typescript/no-generated-empty-object-type": "error",
+		"typescript/no-misused-promises": ["error", { checksVoidReturn: { attributes: false } }],
+		"typescript/no-misused-spread": "error",
+		"typescript/no-redundant-type-constituents": "error",
+		"typescript/no-unnecessary-boolean-literal-compare": "error",
+		"typescript/no-unnecessary-condition": "error",
+		"typescript/no-unnecessary-qualifier": "error",
+		"typescript/no-unnecessary-template-expression": "error",
+		"typescript/no-unnecessary-type-arguments": "error",
+		"typescript/no-unnecessary-type-assertion": "error",
+		"typescript/no-unnecessary-type-conversion": "error",
+		"typescript/no-unnecessary-type-parameters": "error",
+		"typescript/no-unsafe-argument": "error",
+		"typescript/no-unsafe-assignment": "error",
+		"typescript/no-unsafe-call": "error",
+		"typescript/no-unsafe-member-access": "error",
+		"typescript/no-unsafe-return": "error",
+		"typescript/no-unsafe-unary-minus": "error",
+		"typescript/no-useless-default-assignment": "error",
+		"typescript/prefer-nullish-coalescing": ["error", { ignoreTernaryTests: true }],
+		"typescript/prefer-optional-chain": "error",
+		"typescript/restrict-plus-operands": "error",
+		"typescript/restrict-template-expressions": "error",
+		"typescript/strict-boolean-expressions": ["error", {
+			allowNullableObject: false,
+			allowNullableString: true,
+			allowNumber: false,
+			allowString: true
+		}],
+		"typescript/strict-void-return": "error",
+		"typescript/unbound-method": "error",
 		"unicorn/consistent-function-scoping": "error",
 		"unicorn/filename-case": "error",
 		"unicorn/no-abusive-eslint-disable": "error",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deslop/coding-standards",
-  "version": "0.1.1242",
+  "version": "0.1.1244",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/MP281X/deslop.git",
@@ -36,11 +36,11 @@
     "oxlint-plugin-react-doctor": "latest"
   },
   "peerDependencies": {
+    "@effect/tsgo": ">=0.67",
     "vite-plus": "^1.3"
   },
   "scripts": {
     "build": "vp pack",
-    "test": "vp test --config ../../vite.config.ts",
-    "typecheck": "tsrs --checkerAssignment go --pretty false"
+    "test": "vp test --config ../../vite.config.ts"
   }
 }

package/tsconfig.json

@@ -24,190 +24,6 @@
 		"noUncheckedSideEffectImports": true,
 		"noEmit": true,
 		"incremental": false,
-		"plugins": [
-			{
-				"name": "@effect/language-service",
-				"effectFn": ["span", "untraced"],
-				"diagnosticSeverity": {
-					"abortControllerInEffect": "off",
-					"acquireReleaseDisposable": "error",
-					"allOfMapToForEach": "error",
-					"anyUnknownInErrorContext": "error",
-					"apiStabilityLeak": "off",
-					"asyncFunction": "error",
-					"catchAllTagDispatchToCatchTag": "error",
-					"catchAllToMapError": "error",
-					"catchChainToFirstSuccessOf": "error",
-					"catchConditionalRefailToCatchIf": "error",
-					"catchDieToOrDie": "off",
-					"catchIfTagToCatchTag": "error",
-					"catchRefailToTapError": "error",
-					"catchTagToCatchReason": "error",
-					"catchToIgnore": "off",
-					"catchToOrElseSucceed": "error",
-					"catchUnfailableEffect": "error",
-					"classSelfMismatch": "error",
-					"cryptoRandomUUID": "off",
-					"cryptoRandomUUIDInEffect": "off",
-					"deterministicKeys": "error",
-					"duplicatePackage": "error",
-					"effectDoNotation": "error",
-					"effectFnIife": "error",
-					"effectFnImplicitAny": "error",
-					"effectFnOpportunity": "error",
-					"effectGenUsesAdapter": "error",
-					"effectInFailure": "error",
-					"effectInVoidSuccess": "error",
-					"effectMapFlatten": "error",
-					"effectMapVoid": "error",
-					"effectSleepZeroToYieldNow": "error",
-					"effectSucceedWithUndefined": "error",
-					"effectSucceedWithVoid": "error",
-					"effectTryWithoutCatch": "error",
-					"errorPayloadShadowsName": "error",
-					"experimentalApiUsage": "off",
-					"extendsNativeError": "off",
-					"failCauseToConstructor": "error",
-					"flatMapConditionalToFilterOrFail": "error",
-					"flatMapIdentityToFlatten": "error",
-					"flatMapIgnoredParamToAndThen": "error",
-					"flatMapToMap": "error",
-					"flatMapToTap": "error",
-					"floatingEffect": "error",
-					"floatingEffectInVitest": "error",
-					"globalConsole": "error",
-					"globalConsoleInEffect": "error",
-					"globalDate": "error",
-					"globalDateInEffect": "error",
-					"globalErrorInEffectCatch": "error",
-					"globalErrorInEffectFailure": "error",
-					"globalFetch": "error",
-					"globalFetchInEffect": "error",
-					"globalJson": "error",
-					"globalJsonInEffect": "error",
-					"globalRandom": "error",
-					"globalRandomInEffect": "error",
-					"globalTimers": "error",
-					"globalTimersInEffect": "error",
-					"instanceOfSchema": "error",
-					"layerMergeAllWithDependencies": "error",
-					"lazyEffect": "error",
-					"lazyPromiseInEffectSync": "error",
-					"leakingRequirements": "error",
-					"manualMetricTapToTrack": "error",
-					"mapConstToAs": "error",
-					"mapMapErrorToMapBoth": "error",
-					"mapSomeCatchNoSuchElement": "error",
-					"mapSomeToAsSome": "error",
-					"matchBooleanToIsSuccess": "error",
-					"matchEffectToMapBoth": "error",
-					"matchEffectToMatch": "error",
-					"missedPipeableOpportunity": "off",
-					"missingEffectContext": "error",
-					"missingEffectError": "error",
-					"missingLayerContext": "error",
-					"missingPipeableSignature": "off",
-					"missingReturnYieldStar": "error",
-					"missingStarInYieldEffectGen": "error",
-					"multipleCatchTag": "error",
-					"multipleEffectProvide": "error",
-					"nestedEffectGenYield": "error",
-					"newPromise": "off",
-					"newSchemaClass": "error",
-					"nodeBuiltinImport": "error",
-					"obsoleteMatchImport": "error",
-					"obsoleteSchemaImport": "error",
-					"optionMatchToFromOption": "error",
-					"outdatedApi": "error",
-					"overriddenSchemaConstructor": "error",
-					"preferBarrelImport": "off",
-					"preferEffectArray": "error",
-					"preferEffectRecord": "error",
-					"preferEffectString": "error",
-					"preferNamespaceImport": "off",
-					"preferSchemaTaggedError": "off",
-					"preferSchemaTypeProperty": "error",
-					"preferSucceedSomeOrNone": "error",
-					"preferTypedSchemaDecoder": "error",
-					"preferUnsafeConstructor": "off",
-					"processEnv": "error",
-					"processEnvInEffect": "error",
-					"promiseInEffectSuccess": "error",
-					"provideLayerSucceedToProvideService": "error",
-					"provideMergeAllToArray": "error",
-					"raceFirstWithSleepToTimeout": "error",
-					"redundantMapError": "error",
-					"redundantOrDie": "error",
-					"redundantSchemaTagIdentifier": "error",
-					"resultMatchToFromResult": "error",
-					"returnEffectInGen": "error",
-					"runEffectInsideEffect": "off",
-					"runOfExitToRunExit": "error",
-					"schemaClassMissingBrand": "off",
-					"schemaClassObjectLiteral": "error",
-					"schemaLiteralNonFinite": "error",
-					"schemaNumber": "error",
-					"schemaOpaqueInstanceMember": "off",
-					"schemaStructWithTag": "error",
-					"schemaSync": "off",
-					"schemaSyncInEffect": "error",
-					"serviceNotAsClass": "error",
-					"strictBooleanExpressions": "error",
-					"strictEffectProvide": "error",
-					"suspendFailToFailSync": "error",
-					"syncToSucceed": "error",
-					"timeoutCatchTagToTimeoutOrElse": "error",
-					"tryCatchInEffectGen": "error",
-					"typeUnionToSchemaUnion": "error",
-					"unknownInEffectCatch": "off",
-					"unnecessaryArrowBlock": "off",
-					"unnecessaryEffectGen": "error",
-					"unnecessaryFailYieldableError": "error",
-					"unnecessaryPipe": "error",
-					"unnecessaryPipeChain": "error",
-					"unnecessaryTypeofType": "error",
-					"unsafeEffectTypeAssertion": "error",
-					"unstableApiUsage": "off",
-					"unusedDirective": "error",
-					// no-single-use-value inlines a single-use yield into its call instead.
-					"yieldInCallArgument": "off"
-				},
-				"ignoreEffectErrorsInTscExitCode": false,
-				"ignoreEffectWarningsInTscExitCode": false,
-				"ignoreEffectSuggestionsInTscExitCode": false,
-				"overrides": [
-					{
-						// Absolute globs survive extends; the explicit dot component also covers hidden worktrees.
-						"include": ["/**/*.tsx", "/**/.*/**/*.tsx"],
-						"options": {"diagnosticSeverity": {"asyncFunction": "off"}}
-					},
-					{
-						// shadcn's components stay exactly what its CLI writes, so Effect's style checks do not apply to them.
-						"include": [
-							"/**/components-web/src/ui/**/*.ts",
-							"/**/components-web/src/ui/**/*.tsx",
-							"/**/.*/**/components-web/src/ui/**/*.ts",
-							"/**/.*/**/components-web/src/ui/**/*.tsx"
-						],
-						"options": {
-							"diagnosticSeverity": {
-								"globalRandom": "off",
-								"globalTimers": "off",
-								"preferEffectArray": "off",
-								"preferEffectRecord": "off",
-								"preferEffectString": "off",
-								"strictBooleanExpressions": "off"
-							}
-						}
-					},
-					{
-						// The directive scan reads string literals too, and test fixtures hold source text with directives.
-						"include": ["/**/*.test.ts", "/**/.*/**/*.test.ts"],
-						"options": {"diagnosticSeverity": {"unusedDirective": "off"}}
-					}
-				]
-			}
-		],
 		"noUnusedLocals": true,
 		"noUnusedParameters": true
 	},