@deslop/coding-standards 0.0.0-stage → 0.1.761

package/dist/oxlint.js

@@ -0,0 +1,3076 @@
+import { $n as isReadonlyObject, An as symbol, B as some$1, Bn as hasProperty, C as flatMap$1, D as getSomes, E as get$1, F as map$1, Fn as optimize, Gn as isNotNull, H as take, Jn as isNullish, K as remove, Kn as isNotNullish, L as of, Ln as string, M as join, Mn as combine, N as last, Nn as hash, O as isArrayEmpty, On as byReferenceUnsafe, Pn as number, R as prepend, U as fromEntries, V as sort, Vn as isBoolean, W as get$2, Y as fromOption, Yn as isNumber, _ as every, _t as orElse, a as startsWith, at as firstSomeOf, b as findFirst, bn as NodeInspectSymbol, c as TaggedError, d as appendAll, er as isString, f as contains$1, ft as isSome, g as ensure, gr as pipeArguments, gt as none, h as empty, ht as match, i as Order, it as filter, k as isArrayNonEmpty, kn as equals, lr as dual, lt as getOrElse, m as dropRight, mt as map, n as make$2, nt as contains, ot as flatMap, p as dedupe, pr as pipe, q as values, r as update, rt as exists, st as fromNullishOr, t as get$3, tt as all, u as append, v as filter$1, vt as some, w as flatten, x as findFirstIndex, y as filterMap, yt as zipWith, zn as symbol$1 } from "./MutableRef-DT4DAKeI.mjs";
+//#region ../../node_modules/.pnpm/effect@4.0.0/node_modules/effect/dist/internal/graph.js
+/** @internal */
+const TypeId = "~effect/Graph";
+/** @internal */
+const toImpl = (graph) => graph;
+/** @internal */
+const isTransforming = (graph) => toImpl(graph).transforming;
+const edgeEquals = (type, self, that) => (type === "directed" ? self.source === that.source && self.target === that.target : self.source === that.source && self.target === that.target || self.source === that.target && self.target === that.source) && equals(self.data, that.data);
+const edgeHash = (type, edge) => type === "directed" ? hash(edge) : optimize(combine(hash(edge.data), endpointsHash(edge.source, edge.target)));
+/**
+* Addition is commutative and does not cancel self-loops.
+*
+* @internal
+*/
+const endpointsHash = (source, target) => combine(0, hash(source)) + combine(0, hash(target));
+const graphSeed = /*#__PURE__*/ string("Graph");
+const ProtoGraph = {
+	[TypeId]: {
+		_N: (_) => _,
+		_E: (_) => _
+	},
+	[Symbol.iterator]() {
+		return this.nodes[Symbol.iterator]();
+	},
+	[NodeInspectSymbol]() {
+		return this.toJSON();
+	},
+	[symbol](that) {
+		if (hasProperty(that, "~effect/Graph")) {
+			const thatImpl = toImpl(that);
+			if (this.nodes.size !== thatImpl.nodes.size || this.edges.size !== thatImpl.edges.size || this.type !== thatImpl.type) return false;
+			for (const [nodeIndex, nodeData] of this.nodes) if (!thatImpl.nodes.has(nodeIndex) || !equals(nodeData, thatImpl.nodes.get(nodeIndex))) return false;
+			for (const [edgeIndex, edgeData] of this.edges) {
+				const otherEdge = thatImpl.edges.get(edgeIndex);
+				if (otherEdge === void 0 || !edgeEquals(this.type, edgeData, otherEdge)) return false;
+			}
+			return true;
+		}
+		return false;
+	},
+	[symbol$1]() {
+		let hash$2 = graphSeed;
+		hash$2 = hash$2 ^ string(this.type);
+		hash$2 = hash$2 ^ number(this.nodes.size);
+		hash$2 = hash$2 ^ number(this.edges.size);
+		for (const [nodeIndex, nodeData] of this.nodes) hash$2 ^= combine(hash(nodeIndex), hash(nodeData));
+		for (const [edgeIndex, edgeData] of this.edges) hash$2 ^= combine(hash(edgeIndex), edgeHash(this.type, edgeData));
+		return optimize(hash$2);
+	},
+	toJSON() {
+		return {
+			_id: "Graph",
+			nodeCount: this.nodes.size,
+			edgeCount: this.edges.size,
+			type: this.type
+		};
+	},
+	toString() {
+		return `Graph(${this.type}, ${this.nodes.size}, ${this.edges.size})`;
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/** @internal */
+const make$1 = (type, mutable) => {
+	const graph = Object.create(ProtoGraph);
+	graph.type = type;
+	graph.mutable = mutable;
+	graph.transforming = false;
+	graph.nodes = /* @__PURE__ */ new Map();
+	graph.edges = /* @__PURE__ */ new Map();
+	graph.adjacency = /* @__PURE__ */ new Map();
+	graph.reverseAdjacency = /* @__PURE__ */ new Map();
+	graph.nextNodeIndex = 0;
+	graph.nextEdgeIndex = 0;
+	graph.acyclic = some(true);
+	return graph;
+};
+/** @internal */
+const finalize = (source) => {
+	const graph = Object.create(ProtoGraph);
+	graph.type = source.type;
+	graph.mutable = false;
+	graph.transforming = false;
+	graph.nodes = source.nodes;
+	graph.edges = source.edges;
+	graph.adjacency = source.adjacency;
+	graph.reverseAdjacency = source.reverseAdjacency;
+	graph.nextNodeIndex = source.nextNodeIndex;
+	graph.nextEdgeIndex = source.nextEdgeIndex;
+	graph.acyclic = source.acyclic;
+	return graph;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0/node_modules/effect/dist/internal/graphCsr.js
+const cache = /*#__PURE__*/ new WeakMap();
+const makeAdjacency = (csr, incoming) => {
+	const impl = toImpl(csr.graph);
+	const adjacencyMap = incoming ? impl.reverseAdjacency : impl.adjacency;
+	const rowOffsets = new Uint32Array(csr.nodeIds.length + 1);
+	for (let i = 0; i < csr.nodeIds.length; i++) rowOffsets[i + 1] = rowOffsets[i] + (adjacencyMap.get(csr.nodeIds[i])?.length ?? 0);
+	const columnIndices = new Uint32Array(rowOffsets[csr.nodeIds.length]);
+	for (let i = 0; i < csr.nodeIds.length; i++) {
+		const nodeId = csr.nodeIds[i];
+		const adjacency = adjacencyMap.get(nodeId);
+		if (adjacency === void 0) continue;
+		let offset = rowOffsets[i];
+		for (let j = 0; j < adjacency.length; j++) {
+			const edge = impl.edges.get(adjacency[j]);
+			const neighbor = csr.type === "undirected" ? edge.source === nodeId ? edge.target : edge.source : incoming ? edge.source : edge.target;
+			columnIndices[offset++] = csr.indexByNodeId === void 0 ? neighbor : csr.indexByNodeId.get(neighbor);
+		}
+	}
+	return {
+		rowOffsets,
+		columnIndices
+	};
+};
+/** @internal */
+const getOutgoing = (csr) => {
+	return csr.outgoingCsr ?? (csr.outgoingCsr = makeAdjacency(csr, false));
+};
+/** @internal */
+const getIncoming = (csr) => {
+	return csr.incomingCsr ?? (csr.incomingCsr = makeAdjacency(csr, true));
+};
+/** @internal */
+const invalidate = (graph) => {
+	cache.delete(graph);
+};
+/** @internal */
+const get = (graph) => {
+	const cacheEnabled = !isTransforming(graph);
+	if (cacheEnabled) {
+		const cached = cache.get(graph);
+		if (cached !== void 0) return cached;
+	}
+	const impl = toImpl(graph);
+	const nodeIds = new Array(impl.nodes.size);
+	const nodeData = new Array(impl.nodes.size);
+	let compactNodeIds = true;
+	let nodePosition = 0;
+	for (const [nodeId, data] of impl.nodes) {
+		nodeIds[nodePosition] = nodeId;
+		nodeData[nodePosition] = data;
+		if (nodeId !== nodePosition) compactNodeIds = false;
+		nodePosition++;
+	}
+	const indexByNodeId = compactNodeIds ? void 0 : /* @__PURE__ */ new Map();
+	if (indexByNodeId !== void 0) for (let i = 0; i < nodeIds.length; i++) indexByNodeId.set(nodeIds[i], i);
+	const result = {
+		type: impl.type,
+		graph,
+		nodeIds,
+		nodeData,
+		indexByNodeId,
+		outgoingCsr: void 0,
+		incomingCsr: void 0,
+		outgoingEdgeCsr: void 0,
+		edgesByIndex: void 0,
+		edgeIdsByIndex: void 0,
+		compactEdgeEndpoints: void 0,
+		indexByEdgeId: void 0
+	};
+	if (cacheEnabled) cache.set(graph, result);
+	return result;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0/node_modules/effect/dist/Graph.js
+/**
+* Models relationships between indexed nodes and edges.
+*
+* This module provides immutable and scoped-mutable graph data structures. A
+* graph can be directed or undirected, and it can store user-defined data on
+* both nodes and edges. The module includes traversal, analysis, path-finding,
+* transformation, and diagram export utilities.
+*
+* @since 4.0.0
+*/
+/**
+* Error thrown by graph operations when the requested graph structure is
+* invalid, such as referencing a missing node or using unsupported edge
+* weights.
+*
+* **When to use**
+*
+* Use when handling failures thrown by graph operations that reject invalid
+* graph structure or unsupported algorithm inputs.
+*
+* @category errors
+* @since 3.18.0
+*/
+var GraphError = class extends (/*#__PURE__*/ TaggedError("GraphError")) {};
+/** @internal */
+const missingNode = (node) => new GraphError({ message: `Node ${node} does not exist` });
+/** @internal */
+function assertMutable(graph) {
+	if (!graph.mutable) throw new GraphError({ message: "Graph is not mutable" });
+}
+/** @internal */
+const getMutableImplForMutation = (graph) => {
+	assertMutable(graph);
+	if (isTransforming(graph)) throw new GraphError({ message: "Cannot mutate graph during a transformation" });
+	invalidate(graph);
+	return toImpl(graph);
+};
+/**
+* Creates a graph constructor for the specified graph kind.
+*
+* **When to use**
+*
+* Use when the graph kind is selected dynamically. Prefer `directed` or
+* `undirected` when the kind is known statically.
+*
+* **Example** (Constructing by kind)
+*
+* ```ts import.meta.vitest
+* import { Graph } from "effect"
+*
+* const makeGraph = Graph.make("directed")
+* const graph = makeGraph<string, number>((mutable) => {
+*   Graph.addNode(mutable, "A")
+* })
+*
+* graph.type // => "directed"
+* ```
+*
+* @see {@link directed} for constructing a directed graph directly
+* @see {@link undirected} for constructing an undirected graph directly
+* @category constructors
+* @since 4.0.0
+*/
+const make = (type) => (mutate) => {
+	if (type !== "directed" && type !== "undirected") throw new GraphError({ message: "Graph type must be directed or undirected" });
+	if (mutate === void 0) return make$1(type, false);
+	const graph = make$1(type, true);
+	const mutable = byReferenceUnsafe(graph);
+	return mutateScoped(mutable, mutate);
+};
+/**
+* Creates a directed graph, optionally with initial mutations.
+*
+* **When to use**
+*
+* Use when relationships have a source-to-target direction, such as
+* dependencies, workflows, or routing links.
+*
+* **Gotchas**
+*
+* The mutable callback handle is finalized when the callback returns and must
+* not be retained for later mutation.
+*
+* **Example** (Creating a directed graph)
+*
+* ```ts import.meta.vitest
+* import { Graph } from "effect"
+*
+* // Directed graph with initial nodes and edges
+* const graph = Graph.directed<string, string>((mutable) => {
+*   const a = Graph.addNode(mutable, "A")
+*   const b = Graph.addNode(mutable, "B")
+*   const c = Graph.addNode(mutable, "C")
+*   Graph.addEdge(mutable, a, b, "A->B")
+*   Graph.addEdge(mutable, b, c, "B->C")
+* })
+* Array.of(Graph.nodeCount(graph), Graph.edgeCount(graph)) // => [3, 2]
+* ```
+*
+* @category constructors
+* @since 3.18.0
+*/
+const directed = /*#__PURE__*/ make("directed");
+/**
+* Converts a mutable graph back to an immutable graph, ending the mutation scope.
+*
+* **When to use**
+*
+* Use to finish a mutation scope opened with `beginMutation`.
+*
+* **Gotchas**
+*
+* Finalization is terminal. Later public mutation operations on the same
+* mutable handle fail with a `GraphError`.
+*
+* **Example** (Ending a mutation scope)
+*
+* ```ts import.meta.vitest
+* import { Graph } from "effect"
+*
+* const graph = Graph.directed<string, number>()
+* const mutable = Graph.beginMutation(graph)
+* // ... perform mutations on mutable ...
+* Graph.nodeCount(Graph.endMutation(mutable)) // => 0
+* ```
+*
+* @see {@link beginMutation} for opening a manual mutation scope
+* @see {@link mutate} for automatically scoped mutation
+* @category mutations
+* @since 3.18.0
+*/
+const endMutation = (mutable) => {
+	assertMutable(mutable);
+	if (isTransforming(mutable)) throw new GraphError({ message: "Cannot mutate graph during a transformation" });
+	const source = toImpl(mutable);
+	invalidate(mutable);
+	const graph = finalize(source);
+	source.mutable = false;
+	return graph;
+};
+/** @internal */
+const mutateScoped = (mutable, f) => {
+	try {
+		f(mutable);
+	} catch (error) {
+		if (mutable.mutable) endMutation(mutable);
+		throw error;
+	}
+	return endMutation(mutable);
+};
+/**
+* Adds a new node to a mutable graph and returns its index.
+*
+* **When to use**
+*
+* Use to allocate a new node in a mutable graph before storing edges or
+* querying it by index.
+*
+* **Details**
+*
+* The returned index is allocated from the graph's next node index. The mutable
+* graph stores the node data and initializes empty incoming and outgoing edge
+* indexes for the new node.
+*
+* **Gotchas**
+*
+* `NodeIndex` values are identifiers and are not reused after removals.
+*
+* **Example** (Adding nodes)
+*
+* ```ts import.meta.vitest
+* import { Graph } from "effect"
+*
+* Graph.mutate(Graph.directed<string, number>(), (mutable) => {
+*   Graph.addNode(mutable, "Node A") // => 0
+*   Graph.addNode(mutable, "Node B") // => 1
+* })
+* ```
+*
+* @see {@link mutate} for obtaining a mutable graph from an immutable graph
+* @see {@link addEdge} for connecting existing nodes
+*
+* @category mutations
+* @since 3.18.0
+*/
+const addNode = (mutable, data) => {
+	const impl = getMutableImplForMutation(mutable);
+	const nodeIndex = impl.nextNodeIndex;
+	if (!Number.isSafeInteger(nodeIndex)) throw new GraphError({ message: "Graph has exhausted safe node indexes" });
+	impl.nodes.set(nodeIndex, data);
+	impl.adjacency.set(nodeIndex, []);
+	impl.reverseAdjacency.set(nodeIndex, []);
+	impl.nextNodeIndex = impl.nextNodeIndex + 1;
+	return nodeIndex;
+};
+/**
+* Gets the data associated with a node index safely, if it exists.
+*
+* **Example** (Getting node data)
+*
+* ```ts import.meta.vitest
+* import { Graph, Option } from "effect"
+*
+* const graph = Graph.mutate(Graph.directed<string, number>(), (mutable) => {
+*   Graph.addNode(mutable, "Node A")
+* })
+*
+* Graph.getNode(graph, 0) // => Option.some("Node A")
+* ```
+*
+* @category getters
+* @since 3.18.0
+*/
+const getNode = /*#__PURE__*/ dual(2, (graph, nodeIndex) => {
+	const impl = toImpl(graph);
+	return impl.nodes.has(nodeIndex) ? some(impl.nodes.get(nodeIndex)) : none();
+});
+/** @internal */
+const invalidateCycleFlagOnAddition = (mutable) => {
+	if (isSome(mutable.acyclic) && mutable.acyclic.value === true) mutable.acyclic = none();
+};
+/**
+* Adds a new edge to a mutable graph and returns its index.
+*
+* **When to use**
+*
+* Use to connect two existing nodes in a mutable graph while storing edge data
+* and receiving the new edge identifier.
+*
+* **Details**
+*
+* Self-loops and parallel edges are allowed. Undirected graphs retain the
+* supplied source and target orientation in the stored `Edge`, while traversal
+* and neighbor queries treat the connection as bidirectional.
+*
+* **Gotchas**
+*
+* The source and target nodes must already exist in the mutable graph; missing
+* endpoints throw a `GraphError`.
+*
+* **Example** (Adding edges)
+*
+* ```ts import.meta.vitest
+* import { Graph } from "effect"
+*
+* Graph.mutate(Graph.directed<string, number>(), (mutable) => {
+*   const nodeA = Graph.addNode(mutable, "Node A")
+*   const nodeB = Graph.addNode(mutable, "Node B")
+*   Graph.addEdge(mutable, nodeA, nodeB, 42) // => 0
+* })
+* ```
+*
+* @see {@link mutate} for obtaining a mutable graph from an immutable graph
+* @see {@link addNode} for creating node indexes before connecting them
+*
+* @category mutations
+* @since 3.18.0
+*/
+const addEdge = (mutable, source, target, data) => {
+	const impl = getMutableImplForMutation(mutable);
+	if (!impl.nodes.has(source)) throw missingNode(source);
+	if (!impl.nodes.has(target)) throw missingNode(target);
+	const edgeIndex = impl.nextEdgeIndex;
+	if (!Number.isSafeInteger(edgeIndex)) throw new GraphError({ message: "Graph has exhausted safe edge indexes" });
+	const edgeData = {
+		source,
+		target,
+		data
+	};
+	impl.edges.set(edgeIndex, edgeData);
+	const sourceAdjacency = impl.adjacency.get(source);
+	if (sourceAdjacency !== void 0) sourceAdjacency.push(edgeIndex);
+	const targetReverseAdjacency = impl.reverseAdjacency.get(target);
+	if (targetReverseAdjacency !== void 0) targetReverseAdjacency.push(edgeIndex);
+	if (impl.type === "undirected") {
+		const targetAdjacency = impl.adjacency.get(target);
+		if (targetAdjacency !== void 0) targetAdjacency.push(edgeIndex);
+		const sourceReverseAdjacency = impl.reverseAdjacency.get(source);
+		if (sourceReverseAdjacency !== void 0) sourceReverseAdjacency.push(edgeIndex);
+	}
+	impl.nextEdgeIndex = impl.nextEdgeIndex + 1;
+	invalidateCycleFlagOnAddition(impl);
+	return edgeIndex;
+};
+/**
+* Returns the strongly connected components of a directed graph.
+*
+* **When to use**
+*
+* Use when grouping nodes so every node in a component can reach every other
+* node in that component.
+*
+* **Details**
+*
+* Each component is represented as an array of node indices and is computed
+* with Kosaraju's algorithm.
+*
+* **Gotchas**
+*
+* Throws a `GraphError` when used with an undirected graph.
+*
+* **Example** (Finding strongly connected components)
+*
+* ```ts import.meta.vitest
+* import { Graph } from "effect"
+*
+* const graph = Graph.directed<string, string>((mutable) => {
+*   const a = Graph.addNode(mutable, "A")
+*   const b = Graph.addNode(mutable, "B")
+*   const c = Graph.addNode(mutable, "C")
+*   Graph.addEdge(mutable, a, b, "A->B")
+*   Graph.addEdge(mutable, b, c, "B->C")
+*   Graph.addEdge(mutable, c, a, "C->A") // Creates SCC: A-B-C
+* })
+*
+* Graph.stronglyConnectedComponents(graph) // => [[0, 2, 1]]
+* ```
+*
+* @see {@link isStronglyConnected} when only a boolean check is needed
+* @see {@link weaklyConnectedComponents} when edge orientation should be ignored
+* @category algorithms
+* @since 3.18.0
+*/
+const stronglyConnectedComponents = (graph) => {
+	if (graph.type === "undirected") throw new GraphError({ message: "Cannot find strongly connected components of undirected graph" });
+	const cache = get(graph);
+	const outgoing = getOutgoing(cache);
+	const incoming = getIncoming(cache);
+	const visited = new Uint8Array(cache.nodeIds.length);
+	const finishOrder = [];
+	const stack = [];
+	const positions = [];
+	for (let start = 0; start < cache.nodeIds.length; start++) {
+		if (visited[start] !== 0) continue;
+		visited[start] = 1;
+		stack.push(start);
+		positions.push(outgoing.rowOffsets[start]);
+		while (stack.length > 0) {
+			const frame = stack.length - 1;
+			const node = stack[frame];
+			const position = positions[frame];
+			if (position < outgoing.rowOffsets[node + 1]) {
+				positions[frame] = position + 1;
+				const neighbor = outgoing.columnIndices[position];
+				if (visited[neighbor] === 0) {
+					visited[neighbor] = 1;
+					stack.push(neighbor);
+					positions.push(outgoing.rowOffsets[neighbor]);
+				}
+			} else {
+				finishOrder.push(node);
+				stack.pop();
+				positions.pop();
+			}
+		}
+	}
+	visited.fill(0);
+	const components = [];
+	for (let i = finishOrder.length - 1; i >= 0; i--) {
+		const start = finishOrder[i];
+		if (visited[start] !== 0) continue;
+		const component = [];
+		stack.push(start);
+		while (stack.length > 0) {
+			const node = stack.pop();
+			if (visited[node] !== 0) continue;
+			visited[node] = 1;
+			component.push(cache.nodeIds[node]);
+			for (let j = incoming.rowOffsets[node]; j < incoming.rowOffsets[node + 1]; j++) {
+				const predecessor = incoming.columnIndices[j];
+				if (visited[predecessor] === 0) stack.push(predecessor);
+			}
+		}
+		components.push(component);
+	}
+	return components;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@oxlint+plugins@1.85.0/node_modules/@oxlint/plugins/index.js
+/**
+* Define a plugin.
+*
+* No-op function, just to provide type safety. Input is passed through unchanged.
+*
+* @param plugin - Plugin to define
+* @returns Same plugin as passed in
+*/
+function definePlugin(plugin) {
+	return plugin;
+}
+/**
+* Define a rule.
+*
+* No-op function, just to provide type safety. Input is passed through unchanged.
+*
+* @param rule - Rule to define
+* @returns Same rule as passed in
+*/
+function defineRule(rule) {
+	return rule;
+}
+Object.freeze({
+	get filename() {
+		throw Error("Cannot access `context.filename` in `createOnce`");
+	},
+	getFilename() {
+		throw Error("Cannot call `context.getFilename` in `createOnce`");
+	},
+	get physicalFilename() {
+		throw Error("Cannot access `context.physicalFilename` in `createOnce`");
+	},
+	getPhysicalFilename() {
+		throw Error("Cannot call `context.getPhysicalFilename` in `createOnce`");
+	},
+	get cwd() {
+		throw Error("Cannot access `context.cwd` in `createOnce`");
+	},
+	getCwd() {
+		throw Error("Cannot call `context.getCwd` in `createOnce`");
+	},
+	get sourceCode() {
+		throw Error("Cannot access `context.sourceCode` in `createOnce`");
+	},
+	getSourceCode() {
+		throw Error("Cannot call `context.getSourceCode` in `createOnce`");
+	},
+	get languageOptions() {
+		throw Error("Cannot access `context.languageOptions` in `createOnce`");
+	},
+	get settings() {
+		throw Error("Cannot access `context.settings` in `createOnce`");
+	},
+	extend(extension) {
+		return Object.freeze(Object.assign(Object.create(this), extension));
+	},
+	get parserOptions() {
+		throw Error("Cannot access `context.parserOptions` in `createOnce`");
+	},
+	get parserPath() {
+		throw Error("Cannot access `context.parserPath` in `createOnce`");
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/oxlint@1.85.0_oxlint-tsgolint@7.0.2003_vite-plus@1.0.0_@opentelemetry+api@1.9.1_@types+_4709a04ba252a52ff927b8b254462122/node_modules/oxlint/dist/index.js
+/**
+* Define an Oxlint configuration with type inference.
+*
+* @param config - Oxlint configuration
+* @returns Config unchanged
+*/
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+//#region src/rules/shared.ts
+function variableFromScope(input) {
+	if (input.scope === null) return none();
+	const scope = input.scope;
+	return pipe(fromNullishOr(scope.set.get(input.name)), orElse(() => variableFromScope({
+		name: input.name,
+		scope: scope.upper
+	})));
+}
+function variableFor(context, node) {
+	return variableFromScope({
+		name: node.name,
+		scope: context.sourceCode.getScope(node)
+	});
+}
+function isImportBinding(input) {
+	return pipe(variableFor(input.context, input.node), exists((variable) => some$1(variable.defs, (definition) => {
+		if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") return false;
+		const source = definition.parent.source.value;
+		if (isString(input.source) ? source !== input.source : !input.source.test(source)) return false;
+		return input.importedName === void 0 || definition.node.type === "ImportSpecifier" && definition.node.imported.type === "Identifier" && definition.node.imported.name === input.importedName;
+	})));
+}
+function isNamespaceImport(input) {
+	return pipe(variableFor(input.context, input.node), exists((variable) => some$1(variable.defs, (definition) => definition.type === "ImportBinding" && definition.node.type === "ImportNamespaceSpecifier" && definition.parent?.type === "ImportDeclaration" && definition.parent.source.value === input.source)));
+}
+function returnedExpression(node) {
+	if (node.body === null) return;
+	if (node.body.type !== "BlockStatement") return node.body;
+	if (node.body.body.length !== 1 || node.body.body[0]?.type !== "ReturnStatement") return;
+	return node.body.body[0].argument;
+}
+function memberName(node) {
+	if (!node.computed && node.property.type === "Identifier") return some(node.property.name);
+	if (node.computed && node.property.type === "Literal" && isString(node.property.value)) return some(node.property.value);
+	return none();
+}
+function importedMember(input) {
+	return input.node.type === "MemberExpression" && input.node.object.type === "Identifier" && isImportBinding({
+		context: input.context,
+		importedName: input.importedName,
+		node: input.node.object,
+		source: "effect"
+	}) && (input.propertyName === void 0 || contains(memberName(input.node), input.propertyName));
+}
+function effectBuilderName(input) {
+	const builder = input.node.type === "CallExpression" ? input.node.callee : input.node;
+	return builder.type === "MemberExpression" && importedMember({
+		context: input.context,
+		importedName: "Effect",
+		node: builder
+	}) ? memberName(builder) : none();
+}
+function isSchemaOperationName(name) {
+	return /^(?:(?:decode|encode)(?:Unknown)?(?:Effect|Exit|Option|Promise|Result|Sync)|asserts|is)$/u.test(name);
+}
+function isSchemaOperationCall(input) {
+	if (input.node.callee.type !== "MemberExpression" || !importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node.callee
+	})) return false;
+	return pipe(memberName(input.node.callee), exists(isSchemaOperationName));
+}
+function isReactUseState(input) {
+	if (input.node.callee.type === "Identifier") return isImportBinding({
+		context: input.context,
+		importedName: "useState",
+		node: input.node.callee,
+		source: "react"
+	});
+	return input.node.callee.type === "MemberExpression" && contains(memberName(input.node.callee), "useState") && input.node.callee.object.type === "Identifier" && isNamespaceImport({
+		context: input.context,
+		node: input.node.callee.object,
+		source: "react"
+	});
+}
+function statementDeclaration(statement) {
+	return statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+}
+function typeAlias(statement) {
+	const declaration = statementDeclaration(statement);
+	return declaration?.type === "TSTypeAliasDeclaration" ? some(declaration) : none();
+}
+function isInferredType(input) {
+	return input.node.type === "TSTypeQuery" && input.node.exprName.type === "TSQualifiedName" && input.node.exprName.left.type === "Identifier" && input.node.exprName.left.name === input.name && input.node.exprName.right.name === "Type";
+}
+function schemaQualifiedType(input) {
+	return input.node.type === "TSTypeReference" && input.node.typeName.type === "TSQualifiedName" && input.node.typeName.left.type === "Identifier" && input.node.typeName.left.name === "Schema" && input.node.typeName.right.name === input.propertyName && isImportBinding({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node.typeName.left,
+		source: "effect"
+	});
+}
+function schemaSchemaType(input) {
+	return schemaQualifiedType({
+		context: input.context,
+		node: input.node,
+		propertyName: "Schema"
+	});
+}
+function isSchemaCodecType(input) {
+	return schemaQualifiedType({
+		context: input.context,
+		node: input.node,
+		propertyName: "Codec"
+	}) || schemaSchemaType(input);
+}
+function typeArgumentName(node) {
+	if (node.type !== "TSTypeReference" || node.typeArguments === null) return none();
+	return pipe(get$1(node.typeArguments.params, 0), flatMap((parameter) => parameter.type === "TSTypeReference" && parameter.typeName.type === "Identifier" ? some(parameter.typeName.name) : none()));
+}
+function suspendedTypeName(input) {
+	if (input.node.callee.type === "Super" || !importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node.callee,
+		propertyName: "suspend"
+	})) return none();
+	return pipe(get$1(input.node.arguments, 0), flatMap((argument) => argument.type === "ArrowFunctionExpression" || argument.type === "FunctionExpression" ? fromNullishOr(argument.returnType) : none()), filter((returnType) => isSchemaCodecType({
+		context: input.context,
+		node: returnType.typeAnnotation
+	})), flatMap((returnType) => typeArgumentName(returnType.typeAnnotation)));
+}
+function referencedTypeNames(node) {
+	if (node.type === "TSTypeReference") {
+		const argumentNames = pipe(fromNullishOr(node.typeArguments), map((typeArguments) => pipe(typeArguments.params, flatMap$1(referencedTypeNames))), getOrElse(() => empty()));
+		return node.typeName.type === "Identifier" ? prepend(argumentNames, node.typeName.name) : argumentNames;
+	}
+	if (node.type === "TSArrayType") return referencedTypeNames(node.elementType);
+	if (node.type === "TSUnionType" || node.type === "TSIntersectionType") return pipe(node.types, flatMap$1(referencedTypeNames));
+	if (node.type === "TSTemplateLiteralType") return pipe(node.types, flatMap$1(referencedTypeNames));
+	if (node.type === "TSTypeOperator" || node.type === "TSParenthesizedType" || node.type === "TSOptionalType" || node.type === "TSRestType") return referencedTypeNames(node.typeAnnotation);
+	if (node.type === "TSNamedTupleMember") return referencedTypeNames(node.elementType);
+	if (node.type === "TSTupleType") return pipe(node.elementTypes, flatMap$1(referencedTypeNames));
+	if (node.type === "TSIndexedAccessType") return appendAll(referencedTypeNames(node.objectType), referencedTypeNames(node.indexType));
+	if (node.type === "TSConditionalType") return pipe([
+		node.checkType,
+		node.extendsType,
+		node.trueType,
+		node.falseType
+	], flatMap$1(referencedTypeNames));
+	if (node.type === "TSFunctionType" || node.type === "TSConstructorType") return referencedTypeNames(node.returnType.typeAnnotation);
+	if (node.type === "TSMappedType") return pipe([
+		node.constraint,
+		node.nameType,
+		node.typeAnnotation
+	], map$1((child) => fromNullishOr(child)), getSomes, flatMap$1(referencedTypeNames));
+	if (node.type === "TSTypeLiteral") return pipe(node.members, flatMap$1(memberTypeNames));
+	return empty();
+}
+function memberTypeNames(member) {
+	if (member.type === "TSIndexSignature") return referencedTypeNames(member.typeAnnotation.typeAnnotation);
+	return pipe(fromNullishOr(member.type === "TSPropertySignature" ? member.typeAnnotation : member.returnType), map((annotation) => referencedTypeNames(annotation.typeAnnotation)), getOrElse(() => empty()));
+}
+function isNode(value) {
+	return hasProperty(value, "type") && isString(value.type);
+}
+function childNodes(node) {
+	if (!isReadonlyObject(node)) return empty();
+	return pipe(values(remove(node, "parent")), flatMap$1(ensure), filter$1(isNode));
+}
+function suspendSeeds(input) {
+	const seeds = pipe(childNodes(input.node), flatMap$1((child) => suspendSeeds({
+		context: input.context,
+		node: child
+	})));
+	if (input.node.type !== "CallExpression") return seeds;
+	return pipe(suspendedTypeName({
+		context: input.context,
+		node: input.node
+	}), match({
+		onNone: () => seeds,
+		onSome: (name) => prepend(seeds, name)
+	}));
+}
+function referenceNames(node) {
+	const nested = pipe(childNodes(node), filter$1((child) => !(node.type === "Property" && !node.computed && child === node.key) && !(node.type === "MemberExpression" && !node.computed && child === node.property)), flatMap$1(referenceNames));
+	return node.type === "Identifier" ? prepend(nested, node.name) : nested;
+}
+function schemaEdges(statement) {
+	const declaration = statementDeclaration(statement);
+	if (declaration?.type === "TSTypeAliasDeclaration") return isInferredType({
+		name: declaration.id.name,
+		node: declaration.typeAnnotation
+	}) ? empty() : [{
+		name: declaration.id.name,
+		targets: referencedTypeNames(declaration.typeAnnotation)
+	}];
+	if (declaration?.type !== "VariableDeclaration" || declaration.kind !== "const") return empty();
+	return flatMap$1(declaration.declarations, (declarator) => {
+		if (declarator.id.type !== "Identifier" || declarator.init === null) return empty();
+		return [{
+			name: declarator.id.name,
+			targets: referenceNames(declarator.init)
+		}];
+	});
+}
+function schemaCycleNames(input) {
+	const seeds = suspendSeeds({
+		context: input.context,
+		node: input.program
+	});
+	if (isArrayEmpty(seeds)) return empty();
+	const edges = pipe(input.program.body, flatMap$1(schemaEdges));
+	const names = pipe(edges, map$1((edge) => edge.name), dedupe);
+	const graph = directed((mutable) => {
+		const indices = fromEntries(map$1(names, (name) => [name, addNode(mutable, name)]));
+		for (const edge of edges) for (const target of edge.targets) zipWith(get$2(indices, edge.name), get$2(indices, target), (source, sink) => addEdge(mutable, source, sink, "reads"));
+	});
+	return pipe(stronglyConnectedComponents(graph), map$1((component) => getSomes(map$1(component, (index) => getNode(graph, index)))), filter$1((component) => (component.length > 1 || some$1(edges, (edge) => contains$1(component, edge.name) && contains$1(edge.targets, edge.name))) && some$1(component, (name) => contains$1(seeds, name))), flatten);
+}
+function hasSingleStatementExpression(node) {
+	if (node.body === null) return false;
+	if (node.body.type !== "BlockStatement") return true;
+	if (node.body.body.length !== 1) return false;
+	const statement = node.body.body[0];
+	return statement?.type === "ExpressionStatement" || statement?.type === "ReturnStatement" && statement.argument !== null;
+}
+function bindingName(node) {
+	if (node.type === "FunctionDeclaration") return fromNullishOr(node.id?.name);
+	if (node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier") return some(node.parent.id.name);
+	return none();
+}
+function singleUseThunk(input) {
+	if (input.node.params.length !== 0 || input.node.typeParameters !== null || !hasSingleStatementExpression(input.node)) return false;
+	return pipe(bindingName(input.node), flatMap((name) => variableFromScope({
+		name,
+		scope: input.context.sourceCode.getScope(input.node)
+	})), exists((variable) => filter$1(variable.references, (reference) => reference.isRead()).length === 1));
+}
+//#endregion
+//#region src/rules/no-array-wrap-ternary.ts
+function testedValue(node) {
+	if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression" || node.callee.object.type !== "Identifier" || node.callee.object.name !== "Array" || !contains(memberName(node.callee), "isArray") || node.arguments.length !== 1) return none();
+	const argument = node.arguments[0];
+	if (argument?.type !== "Identifier" && argument?.type !== "MemberExpression") return none();
+	return some(argument);
+}
+function isSingletonArray(input) {
+	if (input.node.type !== "ArrayExpression" || input.node.elements.length !== 1) return false;
+	const element = input.node.elements[0];
+	if (isNullish(element) || element.type === "SpreadElement") return false;
+	return input.context.sourceCode.getText(element) === input.context.sourceCode.getText(input.value);
+}
+function restatesArrayEnsure(input) {
+	const test = input.node.test.type === "UnaryExpression" && input.node.test.operator === "!" ? input.node.test.argument : input.node.test;
+	const negated = test !== input.node.test;
+	return exists(testedValue(test), (value) => input.context.sourceCode.getText(negated ? input.node.alternate : input.node.consequent) === input.context.sourceCode.getText(value) && isSingletonArray({
+		context: input.context,
+		node: negated ? input.node.consequent : input.node.alternate,
+		value
+	}));
+}
+const noArrayWrapTernary = defineRule({
+	create: (context) => ({ ConditionalExpression: (node) => {
+		if (restatesArrayEnsure({
+			context,
+			node
+		})) context.report({
+			message: "Use Array.ensure; the ternary restates it.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-constant-function.ts
+function returnsConstant(node) {
+	const returned = returnedExpression(node);
+	return isNotNullish(returned) && (returned.type === "Literal" || returned.type === "Identifier" || returned.type === "MemberExpression" || returned.type === "TemplateLiteral" && isArrayEmpty(returned.expressions));
+}
+function functionScope(input) {
+	if (input.scope.block === input.node) return some(input.scope);
+	return findFirst(input.scope.childScopes, (child) => child.block === input.node);
+}
+function scopeReferences(scope) {
+	return appendAll(scope.references, flatMap$1(scope.childScopes, scopeReferences));
+}
+function isImportedVariable(variable) {
+	return isArrayNonEmpty(variable.defs) && every(variable.defs, (definition) => definition.type === "ImportBinding");
+}
+function resolvesToImport(reference) {
+	return pipe(variableFromScope({
+		name: reference.identifier.name,
+		scope: reference.from
+	}), exists(isImportedVariable));
+}
+function isConstantFunction(input) {
+	if (input.node.async || input.node.generator || isNotNullish(input.node.typeParameters)) return false;
+	if (some$1(input.spans, (span) => span.start >= input.node.start && span.end <= input.node.end)) return false;
+	return returnsConstant(input.node) && pipe(functionScope({
+		node: input.node,
+		scope: input.context.sourceCode.getScope(input.node)
+	}), exists((scope) => every(scopeReferences(scope), resolvesToImport))) && pipe(bindingName(input.node), flatMap((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)));
+}
+function isConstBound(node) {
+	return node.parent.type === "VariableDeclarator" && node.parent.parent.type === "VariableDeclaration" && node.parent.parent.kind === "const";
+}
+const noConstantFunction = defineRule({
+	create: (context) => {
+		const spans = make$2(empty());
+		function mark(node) {
+			update(spans, append(node));
+		}
+		function report(node) {
+			if (isConstantFunction({
+				context,
+				node,
+				spans: get$3(spans)
+			}) && !singleUseThunk({
+				context,
+				node
+			})) context.report({
+				message: "This function reads nothing but imports, so it is a value: hold its result in a const.",
+				node
+			});
+		}
+		return {
+			"ArrowFunctionExpression:exit": (node) => {
+				if (isConstBound(node)) report(node);
+			},
+			"FunctionDeclaration:exit": report,
+			"FunctionExpression:exit": (node) => {
+				if (isConstBound(node)) report(node);
+			},
+			JSXElement: mark,
+			JSXFragment: mark,
+			ThisExpression: mark
+		};
+	},
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-deep-pipe.ts
+function isPipeCall(node) {
+	return node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "pipe";
+}
+function enclosingPipes(node) {
+	if (node.type === "Program" || contains$1([
+		"ArrowFunctionExpression",
+		"FunctionDeclaration",
+		"FunctionExpression"
+	], node.type)) return 0;
+	const nested = isPipeCall(node.parent) && some$1(node.parent.arguments, (argument) => argument === node);
+	return enclosingPipes(node.parent) + (nested ? 1 : 0);
+}
+const noDeepPipe = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (isPipeCall(node) && enclosingPipes(node) >= 3) context.report({
+			message: "Flatten this pipeline; pipe calls nest at most three deep.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-destructured-parameter.ts
+function isPattern(node) {
+	const target = node.type === "AssignmentPattern" ? node.left : node;
+	if (target.type === "ArrayPattern") return true;
+	if (target.type !== "ObjectPattern") return false;
+	const named = filter$1(target.properties, (property) => property.type === "Property");
+	return !(named.length === 1 && named[0]?.key.type === "Identifier" && named[0].key.name === "ref" && some$1(target.properties, (property) => property.type === "RestElement"));
+}
+const noDestructuredParameter = defineRule({
+	create: (context) => {
+		function reportParameters(node) {
+			for (const parameter of filter$1(node.params, isPattern)) context.report({
+				message: "Take the value whole and read its fields instead of destructuring it.",
+				node: parameter
+			});
+		}
+		function reportLoopVariable(node) {
+			if (node.left.type === "VariableDeclaration" && some$1(node.left.declarations, (declarator) => isPattern(declarator.id))) context.report({
+				message: "Take the value whole and read its fields instead of destructuring it.",
+				node: node.left
+			});
+		}
+		return {
+			ArrowFunctionExpression: reportParameters,
+			ForInStatement: reportLoopVariable,
+			ForOfStatement: reportLoopVariable,
+			FunctionDeclaration: reportParameters,
+			FunctionExpression: reportParameters
+		};
+	},
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-double-nullish-check.ts
+function nullishOperand(node) {
+	if (node.type === "Literal" && node.value === null) return some("null");
+	return node.type === "Identifier" && node.name === "undefined" ? some("undefined") : none();
+}
+function operands(input) {
+	if (input.node.type !== "LogicalExpression" || input.node.operator !== input.operator) return [input.node];
+	return appendAll(operands({
+		node: input.node.left,
+		operator: input.operator
+	}), operands({
+		node: input.node.right,
+		operator: input.operator
+	}));
+}
+function comparedNullish(input) {
+	if (input.node.type !== "BinaryExpression" || input.node.operator !== input.operator) return none();
+	const subject = input.context.sourceCode.getText(input.node.left);
+	return map(nullishOperand(input.node.right), (nullish) => ({
+		nullish,
+		subject
+	}));
+}
+const noDoubleNullishCheck = defineRule({
+	create: (context) => ({ LogicalExpression: (node) => {
+		if (node.operator === "??") return;
+		if (node.parent.type === "LogicalExpression" && node.parent.operator === node.operator) return;
+		const comparison = node.operator === "&&" ? "!==" : "===";
+		const checks = pipe(operands({
+			node,
+			operator: node.operator
+		}), filterMap((operand) => fromOption(comparedNullish({
+			context,
+			node: operand,
+			operator: comparison
+		}), () => void 0)));
+		if (some$1(checks, (check) => some$1(checks, (other) => other.subject === check.subject && other.nullish !== check.nullish))) context.report({
+			message: comparison === "!==" ? "Use Predicate.isNotNullish." : "Use Predicate.isNullish.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-effect-property-arrow.ts
+const noEffectPropertyArrow = defineRule({
+	create: (context) => ({ Property: (node) => {
+		if (node.value.type !== "ArrowFunctionExpression" || isArrayEmpty(node.value.params) || node.value.body.type !== "CallExpression") return;
+		const callee = node.value.body.callee;
+		if (callee.type === "Identifier" && isImportBinding({
+			context,
+			importedName: "pipe",
+			node: callee,
+			source: "effect"
+		}) && some$1(node.value.body.arguments, (argument) => argument.type !== "SpreadElement" && importedMember({
+			context,
+			importedName: "Effect",
+			node: argument
+		}) || argument.type === "CallExpression" && importedMember({
+			context,
+			importedName: "Effect",
+			node: argument.callee
+		})) || callee.type === "MemberExpression" && importedMember({
+			context,
+			importedName: "Effect",
+			node: callee,
+			propertyName: "tryPromise"
+		})) context.report({
+			message: "Define this property with Effect.fn or Effect.fnUntraced instead of an arrow.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-error-message-assertion.ts
+function receiverName(node) {
+	if (node.type === "Identifier") return some(node.name);
+	return node.type === "MemberExpression" ? memberName(node) : none();
+}
+function isErrorMessage(node) {
+	return node?.type === "MemberExpression" && contains(memberName(node), "message") && exists(receiverName(node.object), (name) => /^(?:e|err|error|failure|cause|exception)$|Error$/iu.test(name));
+}
+function expectsMessage(node) {
+	const subject = node.object.type === "MemberExpression" && contains(memberName(node.object), "not") ? node.object.object : node.object;
+	return subject.type === "CallExpression" && subject.callee.type === "Identifier" && subject.callee.name === "expect" && isErrorMessage(subject.arguments[0]);
+}
+function assertsMessage(node) {
+	const [actual, expected] = node.arguments;
+	return node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "assert" && isErrorMessage(actual) && (expected?.type === "Literal" || expected?.type === "TemplateLiteral");
+}
+const noErrorMessageAssertion = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (assertsMessage(node)) {
+			context.report({
+				message: "Assert the failure, never its message wording.",
+				node
+			});
+			return;
+		}
+		if (node.callee.type === "MemberExpression" && (node.arguments[0]?.type === "Literal" || node.arguments[0]?.type === "TemplateLiteral") && (exists(memberName(node.callee), (name) => contains$1(["toThrow", "toThrowError"], name)) || expectsMessage(node.callee))) context.report({
+			message: "Assert the failure, never its message wording.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-fail-in-generator.ts
+function insideEffectGenerator(input) {
+	if (input.node.type === "Program") return false;
+	if ((input.node.type === "ArrowFunctionExpression" || input.node.type === "FunctionDeclaration" || input.node.type === "FunctionExpression") && !input.node.generator) return false;
+	if (input.node.type === "FunctionExpression" && input.node.generator && input.node.parent.type === "CallExpression" && exists(effectBuilderName({
+		context: input.context,
+		node: input.node.parent.callee
+	}), (name) => contains$1([
+		"fn",
+		"fnUntraced",
+		"gen"
+	], name))) return true;
+	return insideEffectGenerator({
+		context: input.context,
+		node: input.node.parent
+	});
+}
+const noFailInGenerator = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (node.callee.type === "MemberExpression" && importedMember({
+			context,
+			importedName: "Effect",
+			node: node.callee,
+			propertyName: "fail"
+		}) && node.parent.type === "YieldExpression" && node.parent.delegate && node.arguments[0]?.type !== "NewExpression" && insideEffectGenerator({
+			context,
+			node
+		})) context.report({
+			message: "Yield the error instead: return yield* E.make(...).",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-fake-ref-state.ts
+function propertyName(node) {
+	if (!node.computed && node.key.type === "Identifier") return some(node.key.name);
+	if (node.key.type === "Literal" && isString(node.key.value)) return some(node.key.value);
+	return none();
+}
+function isFakeRefState(input) {
+	if (!isReactUseState(input) || input.node.arguments[0]?.type !== "ArrowFunctionExpression" || input.node.arguments[0].body.type !== "ObjectExpression") return false;
+	return some$1(input.node.arguments[0].body.properties, (property) => property.type === "Property" && contains(propertyName(property), "current"));
+}
+const noFakeRefState = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (isFakeRefState({
+			context,
+			node
+		})) context.report({
+			message: "Use useRef for ref-shaped lifecycle state.",
+			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;
+}
+function comparison(input) {
+	if (input.subject.type === "UnaryExpression" && input.subject.operator === "typeof" && isSubject({
+		name: input.name,
+		node: input.subject.argument
+	}) && input.other.type === "Literal" && isString(input.other.value)) return some(`typeof ${input.operator} ${input.other.value}`);
+	if (!isSubject({
+		name: input.name,
+		node: input.subject
+	})) return none();
+	if (input.other.type === "Literal" && input.other.raw === "null") return some(`${input.operator} null`);
+	if (input.other.type === "Identifier" && input.other.name === "undefined") return some(`${input.operator} undefined`);
+	return none();
+}
+function check(input) {
+	if (input.node.type === "LogicalExpression" && input.node.operator === "&&") return pipe(all([check({
+		name: input.name,
+		node: input.node.left
+	}), check({
+		name: input.name,
+		node: input.node.right
+	})]), 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
+	}) && contains(memberName(input.node.argument.callee), "isArray") && input.node.argument.arguments.length === 1 && every(input.node.argument.arguments, (argument) => isSubject({
+		name: input.name,
+		node: argument
+	}))) return some(["!Array.isArray"]);
+	if (input.node.type !== "BinaryExpression") return none();
+	if (input.node.operator === "instanceof") return isSubject({
+		name: input.name,
+		node: input.node.left
+	}) && input.node.right.type === "Identifier" ? some([`instanceof ${input.node.right.name}`]) : none();
+	return pipe(firstSomeOf([comparison({
+		name: input.name,
+		operator: input.node.operator,
+		other: input.node.right,
+		subject: input.node.left
+	}), comparison({
+		name: input.name,
+		operator: input.node.operator,
+		other: input.node.left,
+		subject: input.node.right
+	})]), map(of));
+}
+function report(input) {
+	const predicate = input.node.returnType?.typeAnnotation;
+	const returned = returnedExpression(input.node);
+	if (predicate?.type !== "TSTypePredicate" || predicate.asserts || predicate.parameterName.type !== "Identifier" || isNullish(returned)) return;
+	const name = pipe(check({
+		name: predicate.parameterName.name,
+		node: returned
+	}), map((checks) => pipe(checks, sort(Order), join(" && "))), flatMap((key) => get$2({
+		"!= null": "isNotNullish",
+		"!== null": "isNotNull",
+		"!== null && !Array.isArray && typeof === object": "isObject",
+		"!== null && typeof === object": "isObjectOrArray",
+		"!== undefined": "isNotUndefined",
+		"== null": "isNullish",
+		"=== null": "isNull",
+		"=== undefined": "isUndefined",
+		"instanceof Date": "isDate",
+		"instanceof Error": "isError",
+		"instanceof Map": "isMap",
+		"instanceof RegExp": "isRegExp",
+		"instanceof Set": "isSet",
+		"instanceof Uint8Array": "isUint8Array",
+		"typeof === bigint": "isBigInt",
+		"typeof === boolean": "isBoolean",
+		"typeof === function": "isFunction",
+		"typeof === number": "isNumber",
+		"typeof === string": "isString",
+		"typeof === symbol": "isSymbol",
+		"typeof === undefined": "isUndefined"
+	}, key)));
+	map(name, (guard) => {
+		input.context.report({
+			message: `Use Predicate.${guard} instead of this hand-written type guard.`,
+			node: input.node
+		});
+	});
+}
+const noHandWrittenGuard = defineRule({
+	create: (context) => ({
+		ArrowFunctionExpression: (node) => {
+			report({
+				context,
+				node
+			});
+		},
+		FunctionDeclaration: (node) => {
+			report({
+				context,
+				node
+			});
+		},
+		FunctionExpression: (node) => {
+			report({
+				context,
+				node
+			});
+		}
+	}),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-let.ts
+const noLet = defineRule({
+	create: (context) => ({ VariableDeclaration: (node) => {
+		if (node.kind === "let") context.report({
+			message: "Replace let with a const pipeline or a fold such as Array.reduce.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-native-emptiness-check.ts
+function emptinessPredicate(node) {
+	const comparesLength = node.left.type === "MemberExpression" && contains(memberName(node.left), "length") && node.right.type === "Literal" && node.right.value === 0;
+	if (comparesLength && node.operator === "===") return some("Array.isArrayEmpty, Array.isReadonlyArrayEmpty, or String.isEmpty");
+	if (comparesLength && node.operator === ">") return some("Array.isArrayNonEmpty, Array.isReadonlyArrayNonEmpty, or String.isNonEmpty");
+	return none();
+}
+const noNativeEmptinessCheck = defineRule({
+	create: (context) => ({ BinaryExpression: (node) => {
+		map(emptinessPredicate(node), (predicate) => {
+			context.report({
+				message: `Use ${predicate}.`,
+				node
+			});
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-native-method-call.ts
+const nativeMethods = [
+	"at",
+	"catch",
+	"charAt",
+	"charCodeAt",
+	"codePointAt",
+	"concat",
+	"endsWith",
+	"entries",
+	"every",
+	"fill",
+	"filter",
+	"finally",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"flat",
+	"flatMap",
+	"forEach",
+	"includes",
+	"indexOf",
+	"join",
+	"keys",
+	"lastIndexOf",
+	"localeCompare",
+	"map",
+	"match",
+	"matchAll",
+	"normalize",
+	"padEnd",
+	"padStart",
+	"pop",
+	"push",
+	"reduce",
+	"reduceRight",
+	"repeat",
+	"replace",
+	"replaceAll",
+	"reverse",
+	"shift",
+	"slice",
+	"some",
+	"sort",
+	"splice",
+	"split",
+	"startsWith",
+	"substring",
+	"then",
+	"toLocaleLowerCase",
+	"toLocaleUpperCase",
+	"toLowerCase",
+	"toReversed",
+	"toSorted",
+	"toSpliced",
+	"toUpperCase",
+	"trim",
+	"trimEnd",
+	"trimStart",
+	"unshift",
+	"values",
+	"with"
+];
+const noNativeMethodCall = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (node.callee.type !== "MemberExpression" || node.callee.object.type === "Identifier" && (node.callee.object.name === "path" || isImportBinding({
+			context,
+			node: node.callee.object,
+			source: /^(?:effect(?:\/|$)|@effect\/)/u
+		}))) return;
+		const receiver = node.callee.object;
+		pipe(memberName(node.callee), filter((name) => contains$1(nativeMethods, name)), filter((name) => !contains$1([
+			"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
+			});
+		}));
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-option-value-access.ts
+function checks(input) {
+	if (input.test.type === "LogicalExpression" && input.test.operator === input.operator) return checks({
+		...input,
+		test: input.test.left
+	}) || checks({
+		...input,
+		test: input.test.right
+	});
+	return input.test.type === "CallExpression" && importedMember({
+		context: input.context,
+		importedName: "Option",
+		node: input.test.callee,
+		propertyName: input.name
+	}) && input.test.arguments[0] !== void 0 && input.context.sourceCode.getText(input.test.arguments[0]) === input.subject;
+}
+function exits(node) {
+	return contains$1([
+		"ContinueStatement",
+		"ReturnStatement",
+		"ThrowStatement"
+	], node.type) || node.type === "BlockStatement" && some$1(node.body, exits);
+}
+function earlyExit(input) {
+	const parent = input.node.parent;
+	if (parent?.type !== "BlockStatement" && parent?.type !== "Program") return false;
+	const index = findFirstIndex(parent.body, (statement) => statement === input.node);
+	return some$1(take(parent.body, getOrElse(index, () => 0)), (statement) => statement.type === "IfStatement" && exits(statement.consequent) && checks({
+		...input,
+		name: "isNone",
+		operator: "||",
+		test: statement.test
+	}));
+}
+function guarded(input) {
+	const parent = input.node.parent;
+	if (parent === null || parent.type === "FunctionDeclaration") return false;
+	function some(test) {
+		return checks({
+			...input,
+			name: "isSome",
+			operator: "&&",
+			test
+		});
+	}
+	return parent.type === "IfStatement" && parent.consequent === input.node && some(parent.test) || parent.type === "ConditionalExpression" && parent.consequent === input.node && some(parent.test) || parent.type === "LogicalExpression" && parent.right === input.node && parent.operator === "&&" && some(parent.left) || parent.type === "LogicalExpression" && parent.right === input.node && parent.operator === "||" && checks({
+		...input,
+		name: "isNone",
+		operator: "||",
+		test: parent.left
+	}) || earlyExit(input) || guarded({
+		...input,
+		node: parent
+	});
+}
+const noOptionValueAccess = defineRule({
+	create: (context) => ({ MemberExpression: (node) => {
+		if (!contains(memberName(node), "value")) return;
+		if (guarded({
+			context,
+			node,
+			subject: context.sourceCode.getText(node.object)
+		})) context.report({
+			message: "Read the value with Option.match, Option.map, or Option.getOrElse.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-readonly-type-syntax.ts
+function isTopLevelStatement(node) {
+	if (node.parent.type === "Program") return true;
+	return node.parent.type === "ExportNamedDeclaration" && node.parent.parent.type === "Program";
+}
+function insideCycleType(input) {
+	if (input.node.type === "Program") return false;
+	if (input.node.type === "TSTypeAliasDeclaration" && isTopLevelStatement(input.node)) return contains$1(input.cycleNames, input.node.id.name);
+	return insideCycleType({
+		cycleNames: input.cycleNames,
+		node: input.node.parent
+	});
+}
+function referencedName(node) {
+	if (node.type !== "TSTypeReference") return none();
+	if (node.typeName.type === "Identifier") return some(node.typeName.name);
+	return node.typeName.type === "TSQualifiedName" ? some(node.typeName.right.name) : none();
+}
+function shapeLiterals(input) {
+	if (input.type.type === "TSTypeLiteral") return [input.type];
+	return pipe(referencedName(input.type), filter((name) => !contains$1(input.seen, name)), map((name) => pipe(input.aliases, filter$1((alias) => alias.id.name === name), flatMap$1((alias) => shapeLiterals({
+		aliases: input.aliases,
+		seen: append(input.seen, name),
+		type: alias.typeAnnotation
+	})))), getOrElse(() => empty()));
+}
+const noReadonlyTypeSyntax = defineRule({
+	create: (context) => {
+		const cycleNames = schemaCycleNames({
+			context,
+			program: context.sourceCode.ast
+		});
+		const shapes = make$2(empty());
+		const aliases = make$2(empty());
+		const properties = make$2(empty());
+		const methods = make$2(empty());
+		function exempt(node) {
+			return insideCycleType({
+				cycleNames,
+				node
+			});
+		}
+		return {
+			CallExpression: (node) => {
+				if (importedMember({
+					context,
+					importedName: "Context",
+					node: node.callee,
+					propertyName: "Service"
+				})) pipe(fromNullishOr(node.typeArguments?.params[1]), map((shape) => update(shapes, append(shape))));
+			},
+			"Program:exit": () => {
+				const literals = pipe(get$3(shapes), flatMap$1((shape) => shapeLiterals({
+					aliases: get$3(aliases),
+					seen: [],
+					type: shape
+				})));
+				function inShape(node) {
+					return some$1(literals, (literal) => literal === node.parent);
+				}
+				for (const node of get$3(properties)) {
+					if (inShape(node) && !node.readonly) context.report({
+						message: "Mark this service property readonly.",
+						node
+					});
+					if (!inShape(node) && node.readonly && !exempt(node)) context.report({
+						message: "Remove the readonly property modifier.",
+						node
+					});
+				}
+				for (const node of get$3(methods)) if (inShape(node)) context.report({
+					message: "Write this service method as a readonly property holding a function.",
+					node
+				});
+			},
+			TSIndexSignature: (node) => {
+				if (node.readonly) context.report({
+					message: "Remove the readonly index modifier.",
+					node
+				});
+			},
+			TSMappedType: (node) => {
+				if (node.readonly === true || node.readonly === "+") context.report({
+					message: "Remove the readonly mapped-type modifier.",
+					node
+				});
+			},
+			TSMethodSignature: (node) => {
+				update(methods, append(node));
+			},
+			TSPropertySignature: (node) => {
+				update(properties, append(node));
+			},
+			TSTypeAliasDeclaration: (node) => {
+				update(aliases, append(node));
+			},
+			TSTypeOperator: (node) => {
+				if (node.operator === "readonly" && !exempt(node)) context.report({
+					message: "Use a mutable type shape.",
+					node
+				});
+			},
+			TSTypeReference: (node) => {
+				if (node.typeName.type === "Identifier" && node.typeName.name === "Readonly" && !exempt(node)) context.report({
+					message: "Use a mutable type shape.",
+					node
+				});
+			}
+		};
+	},
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-redundant-return-type.ts
+function isExported(node) {
+	if (node.parent.type === "ExportNamedDeclaration" || node.parent.type === "ExportDefaultDeclaration") return true;
+	return node.parent.type === "VariableDeclarator" && node.parent.parent.type === "VariableDeclaration" && node.parent.parent.parent.type === "ExportNamedDeclaration";
+}
+function inferredIdentically$1(input) {
+	const text = input.context.sourceCode.getText;
+	const body = input.node.body;
+	if (body === null) return false;
+	const block = body.type === "BlockStatement";
+	const values = body.type === "BlockStatement" ? map$1(input.returns, (statement) => statement.argument) : [body];
+	const expressions = filter$1(values, isNotNull);
+	if (input.type.type === "TSVoidKeyword") return block && isArrayEmpty(expressions);
+	if (isArrayEmpty(expressions) || expressions.length !== values.length) return false;
+	if (input.type.type === "TSStringKeyword") return every(expressions, (value) => value.type === "TemplateLiteral" && isArrayNonEmpty(value.expressions));
+	if (isExported(input.node)) return false;
+	return every(expressions, (value) => value.type === "TSAsExpression" && text(value.typeAnnotation) === text(input.type) || !block && value.type === "NewExpression" && input.type.type === "TSTypeReference" && input.type.typeArguments === null && text(value.callee) === text(input.type.typeName));
+}
+const noRedundantReturnType = defineRule({
+	create: (context) => {
+		const frames = make$2(empty());
+		function enter() {
+			update(frames, append({ returns: empty() }));
+		}
+		function exit(node) {
+			const frame = last(get$3(frames));
+			update(frames, dropRight(1));
+			if (node.async || node.generator || isNullish(node.returnType)) return;
+			if (inferredIdentically$1({
+				context,
+				node,
+				returns: match(frame, {
+					onNone: () => empty(),
+					onSome: (top) => top.returns
+				}),
+				type: node.returnType.typeAnnotation
+			})) context.report({
+				message: "Drop this return type; inference gives the same type.",
+				node: node.returnType
+			});
+		}
+		return {
+			ArrowFunctionExpression: enter,
+			"ArrowFunctionExpression:exit": exit,
+			FunctionDeclaration: enter,
+			"FunctionDeclaration:exit": exit,
+			FunctionExpression: enter,
+			"FunctionExpression:exit": exit,
+			ReturnStatement: (node) => {
+				update(frames, (stack) => pipe(last(stack), match({
+					onNone: () => stack,
+					onSome: (top) => append(dropRight(stack, 1), { returns: append(top.returns, node) })
+				})));
+			}
+		};
+	},
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-redundant-state-type.ts
+const noRedundantStateType = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		const argument = node.arguments[0];
+		const type = node.typeArguments?.params[0];
+		if (node.arguments.length !== 1 || node.typeArguments?.params.length !== 1 || argument?.type !== "Literal" || node.callee.type === "Super") return;
+		if (!(isReactUseState({
+			context,
+			node
+		}) || some$1([
+			"MutableRef",
+			"Ref",
+			"SubscriptionRef"
+		], (importedName) => importedMember({
+			context,
+			importedName,
+			node: node.callee,
+			propertyName: "make"
+		})))) return;
+		if (isString(argument.value) && type?.type === "TSStringKeyword" || isNumber(argument.value) && type?.type === "TSNumberKeyword" || isBoolean(argument.value) && type?.type === "TSBooleanKeyword") context.report({
+			message: "Drop this state type; the initializer infers the same primitive type.",
+			node: type
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-redundant-use-ref-null-type.ts
+function isReactUseRef(input) {
+	if (input.node.callee.type === "Identifier") return isImportBinding({
+		context: input.context,
+		importedName: "useRef",
+		node: input.node.callee,
+		source: "react"
+	});
+	return input.node.callee.type === "MemberExpression" && contains(memberName(input.node.callee), "useRef") && input.node.callee.object.type === "Identifier" && isNamespaceImport({
+		context: input.context,
+		node: input.node.callee.object,
+		source: "react"
+	});
+}
+function redundantUseRefNullType(input) {
+	const type = input.node.typeArguments?.params[0];
+	return isReactUseRef(input) && input.node.arguments[0]?.type === "Literal" && input.node.arguments[0].value === null && type?.type === "TSUnionType" && some$1(type.types, (member) => member.type === "TSNullKeyword");
+}
+const noRedundantUseRefNullType = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (redundantUseRefNullType({
+			context,
+			node
+		})) context.report({
+			message: "Remove null from the explicit useRef type; the null initializer already owns it.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-redundant-variable-annotation.ts
+function isStringLiteral(node) {
+	return node.type === "Literal" && isString(node.value);
+}
+function inferredIdentically(input) {
+	const text = input.context.sourceCode.getText;
+	if (input.init.type === "TSAsExpression") return text(input.init.typeAnnotation) === text(input.type);
+	return input.init.type === "ConditionalExpression" && input.type.type === "TSStringKeyword" && isStringLiteral(input.init.consequent) && isStringLiteral(input.init.alternate);
+}
+const noRedundantVariableAnnotation = defineRule({
+	create: (context) => ({ VariableDeclarator: (node) => {
+		const annotation = node.id.typeAnnotation;
+		if (node.init === null || isNullish(annotation)) return;
+		if (node.init.type === "ArrayExpression" && isArrayEmpty(node.init.elements)) {
+			context.report({
+				message: "Write Array.empty<T>() instead of annotating an empty array.",
+				node: annotation
+			});
+			return;
+		}
+		if (inferredIdentically({
+			context,
+			init: node.init,
+			type: annotation.typeAnnotation
+		})) context.report({
+			message: "Drop this annotation; inference gives the same type.",
+			node: annotation
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-reinvented-schema.ts
+const shipped = [
+	{
+		base: "String",
+		check: "isMinLength",
+		only: 1,
+		schema: "NonEmptyString"
+	},
+	{
+		base: "String",
+		check: "isNonEmpty",
+		only: void 0,
+		schema: "NonEmptyString"
+	},
+	{
+		base: "String",
+		check: "isTrimmed",
+		only: void 0,
+		schema: "Trimmed"
+	},
+	{
+		base: "Number",
+		check: "isInt",
+		only: void 0,
+		schema: "Int"
+	},
+	{
+		base: "Int",
+		check: "isGreaterThanOrEqualTo",
+		only: 0,
+		schema: "Natural"
+	}
+];
+function schemaMember(input) {
+	return input.node.type === "MemberExpression" && importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node
+	}) ? memberName(input.node) : none();
+}
+function shippedSchema(input) {
+	if (input.filter.type !== "CallExpression") return none();
+	const base = schemaMember({
+		context: input.context,
+		node: input.base
+	});
+	const check = schemaMember({
+		context: input.context,
+		node: input.filter.callee
+	});
+	const [value, ...rest] = input.filter.arguments;
+	return pipe(shipped, findFirst((entry) => contains(base, entry.base) && contains(check, entry.check) && isArrayEmpty(rest) && (entry.only === void 0 ? value === void 0 : value?.type === "Literal" && value.value === entry.only)), map((entry) => entry.schema));
+}
+function pipedBase(node) {
+	const parent = node.parent;
+	if (parent.type !== "CallExpression") return none();
+	if (parent.callee.type === "Identifier" && parent.callee.name === "pipe" && parent.arguments.length === 2) return parent.arguments[1] === node ? fromNullishOr(parent.arguments[0]) : none();
+	return parent.callee.type === "MemberExpression" && contains(memberName(parent.callee), "pipe") && parent.arguments.length === 1 ? some(parent.callee.object) : none();
+}
+function reinventedSchema(input) {
+	if (input.node.callee.type !== "MemberExpression" || !contains(memberName(input.node.callee), "check")) return none();
+	const callee = input.node.callee;
+	const [filter] = input.node.arguments;
+	if (isSome(schemaMember({
+		context: input.context,
+		node: callee
+	}))) return pipe(pipedBase(input.node), flatMap((base) => input.node.arguments.length === 1 && filter !== void 0 ? shippedSchema({
+		base,
+		context: input.context,
+		filter
+	}) : none()));
+	return findFirst(input.node.arguments, (argument) => shippedSchema({
+		base: callee.object,
+		context: input.context,
+		filter: argument
+	}));
+}
+const noReinventedSchema = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		map(reinventedSchema({
+			context,
+			node
+		}), (schema) => {
+			context.report({
+				message: `Replace this base and its matching refinement with Schema.${schema}, keeping every other check.`,
+				node
+			});
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-renamed-import.ts
+const noRenamedImport = defineRule({
+	create: (context) => ({ ImportSpecifier: (node) => {
+		const imported = node.imported.type === "Literal" ? node.imported.value : node.imported.name;
+		if (imported === node.local.name || imported === "it" && node.local.name === "test") return;
+		context.report({
+			message: `Import ${imported} under its own name.`,
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-stored-schema-operation.ts
+function storedSchemaOperation(node) {
+	return node.parent.type === "VariableDeclarator" && node.parent.init === node || node.parent.type === "Property" && node.parent.value === node || node.parent.type === "PropertyDefinition" && node.parent.value === node || node.parent.type === "ArrayExpression" || node.parent.type === "AssignmentExpression" && node.parent.right === node;
+}
+const noStoredSchemaOperation = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (isSchemaOperationCall({
+			context,
+			node
+		}) && storedSchemaOperation(node)) context.report({
+			message: "Inline this Schema operation at its consumption site; never store compiled operations.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-switch-statement.ts
+const noSwitchStatement = defineRule({
+	create: (context) => ({ SwitchStatement: (node) => {
+		context.report({
+			message: "Use Match instead of switch.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-trivial-indirection.ts
+function parameterName(parameter) {
+	if (parameter.type === "Identifier") return some(parameter.name);
+	if (parameter.type === "RestElement" && parameter.argument.type === "Identifier") return some(parameter.argument.name);
+	return none();
+}
+function forwardedCall(input) {
+	return input.node.arguments.length === input.names.length && every(input.node.arguments, (argument, index) => {
+		const name = input.names[index];
+		if (argument.type === "SpreadElement") return argument.argument.type === "Identifier" && argument.argument.name === name;
+		return argument.type === "Identifier" && argument.name === name;
+	});
+}
+function exactForwardingFunction(node) {
+	const names = pipe(node.params, map$1(parameterName), getSomes);
+	const returned = returnedExpression(node);
+	if (isArrayEmpty(names) || names.length !== node.params.length || isNullish(returned)) return false;
+	if (returned.type === "Identifier") return names.length === 1 && returned.name === names[0];
+	return (returned.type === "CallExpression" || returned.type === "NewExpression") && returned.callee.type === "Identifier" && forwardedCall({
+		names,
+		node: returned
+	});
+}
+function isIdentity(node) {
+	const [parameter] = node.params;
+	const returned = returnedExpression(node);
+	return node.params.length === 1 && parameter?.type === "Identifier" && returned?.type === "Identifier" && returned.name === parameter.name;
+}
+function indirectionMessage(node) {
+	return isIdentity(node) ? "Pass identity from effect instead of this function." : "Inline this function at its only use site.";
+}
+function isExport(node) {
+	return node?.type === "ExportNamedDeclaration" || node?.type === "ExportDefaultDeclaration";
+}
+function unexportedBindingName(node) {
+	if (node.type === "FunctionDeclaration" && node.id !== null && !isExport(node.parent)) return some(node.id.name);
+	if (node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier" && node.parent.id.typeAnnotation === null && !isExport(node.parent.parent.parent)) return some(node.parent.id.name);
+	return none();
+}
+function singleCallerWrapper(input) {
+	const names = pipe(input.node.params, map$1(parameterName), getSomes);
+	const returned = returnedExpression(input.node);
+	if (input.node.async || input.node.generator || input.node.returnType?.typeAnnotation.type === "TSTypePredicate" || isArrayEmpty(names) || names.length !== input.node.params.length || returned?.type !== "CallExpression") return false;
+	return pipe(unexportedBindingName(input.node), flatMap((name) => variableFromScope({
+		name,
+		scope: input.context.sourceCode.getScope(input.node)
+	})), exists((variable) => {
+		const reads = filter$1(variable.references, (reference) => reference.isRead());
+		return reads.length === 1 && every(reads, (reference) => reference.identifier.parent.type === "CallExpression" && reference.identifier.parent.callee === reference.identifier);
+	}));
+}
+function redundantConstAlias(input) {
+	if (input.node.parent.type !== "VariableDeclaration" || input.node.parent.kind !== "const" || input.node.id.type !== "Identifier" || input.node.id.typeAnnotation !== null || input.node.init?.type !== "Identifier" || !pipe(variableFor(input.context, input.node.init), exists((variable) => {
+		if (some$1(variable.references, (reference) => reference.isWrite() && !reference.init)) return false;
+		return some$1(variable.defs, (definition) => {
+			if (definition.type === "ImportBinding" || definition.type === "Parameter") return true;
+			return definition.node.type === "VariableDeclarator" && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const";
+		});
+	}))) return false;
+	return pipe(variableFromScope({
+		name: input.node.id.name,
+		scope: input.context.sourceCode.getScope(input.node)
+	}), exists((alias) => filter$1(alias.references, (reference) => reference.isRead()).length === 1));
+}
+function singleUseLiteral(input) {
+	if (input.node.parent.type !== "VariableDeclaration" || input.node.parent.kind !== "const" || isExport(input.node.parent.parent) || input.node.id.type !== "Identifier" || input.node.id.typeAnnotation !== null || !(input.node.init?.type === "Literal" && !hasProperty(input.node.init, "regex") || input.node.init?.type === "TemplateLiteral" && isArrayEmpty(input.node.init.expressions))) return false;
+	return pipe(variableFromScope({
+		name: input.node.id.name,
+		scope: input.context.sourceCode.getScope(input.node)
+	}), map((variable) => filter$1(variable.references, (reference) => reference.isRead())), exists((reads) => reads.length === 1 && reads[0]?.identifier.parent.type !== "ExportSpecifier"));
+}
+function singleUseLayerPart(input) {
+	const init = input.node.init;
+	if (input.node.parent.type !== "VariableDeclaration" || input.node.parent.kind !== "const" || isExport(input.node.parent.parent) || input.node.id.type !== "Identifier" || input.node.id.typeAnnotation !== null || init === null) return false;
+	return pipe(variableFromScope({
+		name: input.node.id.name,
+		scope: input.context.sourceCode.getScope(input.node)
+	}), map((variable) => filter$1(variable.references, (reference) => reference.isRead())), exists((reads) => {
+		const consumer = reads[0]?.identifier.parent;
+		if (reads.length !== 1 || consumer?.type !== "CallExpression") return false;
+		if (init.type === "MemberExpression") return contains(memberName(init), "layer") && (importedMember({
+			context: input.context,
+			importedName: "Layer",
+			node: consumer.callee
+		}) || importedMember({
+			context: input.context,
+			importedName: "Effect",
+			node: consumer.callee,
+			propertyName: "provide"
+		}));
+		return init.type === "CallExpression" && importedMember({
+			context: input.context,
+			importedName: "Effect",
+			node: init.callee,
+			propertyName: "gen"
+		}) && consumer.arguments[1] === reads[0]?.identifier && importedMember({
+			context: input.context,
+			importedName: "Layer",
+			node: consumer.callee,
+			propertyName: "effect"
+		});
+	}));
+}
+const noTrivialIndirection = defineRule({
+	create: (context) => ({
+		ArrowFunctionExpression: (node) => {
+			if ((node.parent.type === "VariableDeclarator" || node.parent.type === "Property") && (exactForwardingFunction(node) || singleUseThunk({
+				context,
+				node
+			}) || singleCallerWrapper({
+				context,
+				node
+			}))) context.report({
+				message: indirectionMessage(node),
+				node
+			});
+		},
+		FunctionDeclaration: (node) => {
+			if (exactForwardingFunction(node) || singleUseThunk({
+				context,
+				node
+			}) || singleCallerWrapper({
+				context,
+				node
+			})) context.report({
+				message: indirectionMessage(node),
+				node
+			});
+		},
+		FunctionExpression: (node) => {
+			if ((node.parent.type === "VariableDeclarator" || node.parent.type === "Property" || node.parent.type === "MethodDefinition" && node.parent.override !== true) && (exactForwardingFunction(node) || singleUseThunk({
+				context,
+				node
+			}) || singleCallerWrapper({
+				context,
+				node
+			}))) context.report({
+				message: indirectionMessage(node),
+				node
+			});
+		},
+		VariableDeclarator: (node) => {
+			if (redundantConstAlias({
+				context,
+				node
+			})) context.report({
+				message: "Use the immutable source binding directly.",
+				node
+			});
+			if (singleUseLiteral({
+				context,
+				node
+			})) context.report({
+				message: "Inline this literal at its only use site.",
+				node
+			});
+			if (singleUseLayerPart({
+				context,
+				node
+			})) context.report({
+				message: "Write this layer part where its only layer uses it.",
+				node
+			});
+		}
+	}),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-typeof.ts
+const noTypeof = defineRule({
+	create: (context) => ({ UnaryExpression: (node) => {
+		if (node.operator !== "typeof") return;
+		if (node.argument.type === "Identifier" && !exists(variableFor(context, node.argument), (variable) => isArrayNonEmpty(variable.defs))) return;
+		context.report({
+			message: "Replace typeof with a Predicate guard such as Predicate.isString.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-undestructured-use-state.ts
+const noUndestructuredUseState = defineRule({
+	create: (context) => ({ VariableDeclarator: (node) => {
+		if (node.init?.type === "CallExpression" && isReactUseState({
+			context,
+			node: node.init
+		}) && node.id.type !== "ArrayPattern") context.report({
+			message: "Destructure the state value and setter at the declaration.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-unexplained-disable.ts
+const noUnexplainedDisable = defineRule({
+	create: (context) => ({ Program: () => {
+		for (const comment of context.sourceCode.getAllComments()) if (/^\s*(?:eslint|oxlint)-disable\S*\s(?:(?!\s--\s).)*\bsort-keys\b/u.test(comment.value)) context.report({
+			message: "Sort the keys, starting a new sorted group after a blank line; never disable sort-keys.",
+			node: comment
+		});
+		else if (/^\s*(?:eslint-disable|oxlint-disable|@effect-diagnostics)/u.test(comment.value) && !/\s--\s*\S/u.test(comment.value)) context.report({
+			message: "Give this disable a `-- reason`.",
+			node: comment
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/no-unvalidated-json-decode.ts
+function unknownJsonSchema(input) {
+	if (isSchemaOperationCall(input) && input.node.callee.type === "MemberExpression" && pipe(memberName(input.node.callee), exists(startsWith("decode"))) && input.node.arguments[0]?.type === "MemberExpression" && importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node.arguments[0],
+		propertyName: "UnknownFromJsonString"
+	})) return true;
+	if (input.node.callee.type !== "MemberExpression" || !importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node.callee,
+		propertyName: "fromJsonString"
+	}) || input.node.arguments[0]?.type !== "MemberExpression" || !importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node.arguments[0],
+		propertyName: "Unknown"
+	})) return false;
+	const parent = input.node.parent;
+	if (parent.type !== "CallExpression" || parent.arguments[0] !== input.node || parent.callee.type !== "MemberExpression") return false;
+	return importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: parent.callee
+	}) && pipe(memberName(parent.callee), exists(startsWith("decode")));
+}
+const noUnvalidatedJsonDecode = defineRule({
+	create: (context) => ({ CallExpression: (node) => {
+		if (unknownJsonSchema({
+			context,
+			node
+		})) context.report({
+			message: "Replace Schema.Unknown with the protocol Schema at this JSON boundary.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/rules/schema-type-pair.ts
+function expressionRoot(node) {
+	if (node.type === "MemberExpression") return expressionRoot(node.object);
+	if (node.type === "CallExpression" && node.callee.type !== "Super") return expressionRoot(node.callee);
+	if (node.type === "ChainExpression") return expressionRoot(node.expression);
+	if (node.type === "TSInstantiationExpression") return expressionRoot(node.expression);
+	if (node.type === "TSSatisfiesExpression") return expressionRoot(node.expression);
+	return node;
+}
+function expressionUsesImport(input) {
+	const root = expressionRoot(input.node);
+	return root.type === "Identifier" && isImportBinding({
+		context: input.context,
+		importedName: input.importedName,
+		node: root,
+		source: "effect"
+	});
+}
+function schemaDefinitionMember(node) {
+	if (node.type === "CallExpression" && node.callee.type !== "Super") return schemaDefinitionMember(node.callee);
+	if (node.type === "TSInstantiationExpression") return schemaDefinitionMember(node.expression);
+	if (node.type === "TSSatisfiesExpression") return schemaDefinitionMember(node.expression);
+	if (node.type === "MemberExpression") {
+		if (node.object.type === "Identifier") return some(node);
+		if (node.object.type !== "Super") return schemaDefinitionMember(node.object);
+	}
+	return none();
+}
+function isSchemaDefinitionName(name) {
+	return !isSchemaOperationName(name) && !/^to[A-Z]/u.test(name);
+}
+function isSchemaDefinition(input) {
+	if (input.node.type === "CallExpression" && input.node.callee.type === "Identifier" && isImportBinding({
+		context: input.context,
+		importedName: "pipe",
+		node: input.node.callee,
+		source: "effect"
+	}) && input.node.arguments[0] !== void 0 && input.node.arguments[0].type !== "SpreadElement") return isSchemaDefinition({
+		context: input.context,
+		node: input.node.arguments[0]
+	});
+	if (input.node.type === "TSSatisfiesExpression") return isSchemaDefinition({
+		context: input.context,
+		node: input.node.expression
+	});
+	if (input.node.type === "CallExpression" && input.node.callee.type === "MemberExpression" && !importedMember({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node.callee
+	}) && contains(memberName(input.node.callee), "make")) return false;
+	if (!expressionUsesImport({
+		context: input.context,
+		importedName: "Schema",
+		node: input.node
+	})) return false;
+	return pipe(schemaDefinitionMember(input.node), exists((member) => {
+		if (!importedMember({
+			context: input.context,
+			importedName: "Schema",
+			node: member
+		})) return false;
+		return pipe(memberName(member), exists(isSchemaDefinitionName));
+	}));
+}
+function namedTypeAlias(input) {
+	return pipe(input.typeStatement, flatMap(typeAlias), filter((declaration) => declaration.id.name === input.name));
+}
+function reportSchemaVariable(input) {
+	if (input.variable.id.type !== "Identifier" || !/^[A-Z]/u.test(input.variable.id.name)) return;
+	if (input.variable.init === null || !isSchemaDefinition({
+		context: input.context,
+		node: input.variable.init
+	})) return;
+	const name = input.variable.id.name;
+	const annotation = input.variable.id.typeAnnotation;
+	const typeStatement = pipe(input.program.body, findFirstIndex((statement) => statement === input.statement), filter((index) => index > 0), flatMap((index) => get$1(input.program.body, index - 1)));
+	if (contains$1(input.cycleNames, name)) {
+		if (!pipe(namedTypeAlias({
+			name,
+			typeStatement
+		}), exists((declaration) => !isInferredType({
+			name,
+			node: declaration.typeAnnotation
+		})))) input.context.report({
+			message: `Write \`type ${name} = ...\` by hand immediately before this recursive Schema; typeof ${name}.Type is circular.`,
+			node: input.variable
+		});
+		if (isNotNullish(annotation)) input.context.report({
+			message: "Annotate the Schema.suspend thunk, not the recursive Schema.",
+			node: input.variable.id
+		});
+		return;
+	}
+	if (!pipe(namedTypeAlias({
+		name,
+		typeStatement
+	}), exists((declaration) => isInferredType({
+		name,
+		node: declaration.typeAnnotation
+	})))) input.context.report({
+		message: `Place \`type ${name} = typeof ${name}.Type\` immediately before this Schema.`,
+		node: input.variable
+	});
+	if (input.variable.init.type === "TSSatisfiesExpression" && schemaSchemaType({
+		context: input.context,
+		node: input.variable.init.typeAnnotation
+	})) input.context.report({
+		message: "Infer this schema instead of restating Schema.Schema.",
+		node: input.variable.init
+	});
+	if (isNotNullish(annotation) && schemaSchemaType({
+		context: input.context,
+		node: annotation.typeAnnotation
+	})) input.context.report({
+		message: "Infer this schema instead of annotating Schema.Schema.",
+		node: input.variable.id
+	});
+}
+const schemaTypePair = defineRule({
+	createOnce: (context) => ({ "Program:exit": (program) => {
+		const cycleNames = schemaCycleNames({
+			context,
+			program
+		});
+		for (const statement of program.body) {
+			const declaration = statementDeclaration(statement);
+			if (declaration?.type === "VariableDeclaration") for (const variable of declaration.declarations) reportSchemaVariable({
+				context,
+				cycleNames,
+				program,
+				statement,
+				variable
+			});
+		}
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
+//#region src/oxlint.ts
+const reactLegacyApis = [
+	"Component",
+	"PureComponent",
+	"createRef",
+	"forwardRef",
+	"memo",
+	"useCallback",
+	"useMemo"
+];
+const reactLegacyMessage = "Use React 19 function components with refs as props; React Compiler owns memoization.";
+const mapMessage = "Use HashMap, or MutableHashMap for local mutation; for identity keys, wrap objects the code owns in Equal.byReferenceUnsafe, which marks them reference-compared globally.";
+const runMessage = "Run the entry point with NodeRuntime.runMain, or bridge a Promise an external contract demands once, where it is returned, with Effect.runPromiseWith(Context.empty()).";
+const setMessage = "Use HashSet, or MutableHashSet for local mutation; for identity keys, wrap objects the code owns in Equal.byReferenceUnsafe, which marks them reference-compared globally.";
+const oxlint = defineConfig({
+	categories: {
+		correctness: "off",
+		nursery: "off",
+		pedantic: "off",
+		perf: "off",
+		restriction: "off",
+		style: "off",
+		suspicious: "off"
+	},
+	ignorePatterns: [
+		"**/node_modules/**",
+		"**/dist/**",
+		"**/*.gen.ts"
+	],
+	jsPlugins: [
+		{
+			name: "@deslop/coding-standards",
+			specifier: import.meta.url
+		},
+		{
+			name: "react-doctor",
+			specifier: import.meta.resolve("oxlint-plugin-react-doctor")
+		},
+		{
+			name: "shadcn",
+			specifier: import.meta.resolve("@shadcn/lint")
+		}
+	],
+	options: {
+		denyWarnings: true,
+		reportUnusedDisableDirectives: "deny",
+		typeAware: true,
+		typeCheck: true
+	},
+	overrides: [
+		{
+			files: ["**/*.config.ts", "**/main.*"],
+			rules: { "import/no-default-export": "off" }
+		},
+		{
+			files: ["**/components/ui/**"],
+			rules: {
+				"shadcn/no-restyle": "off",
+				"shadcn/require-static-classes": "off"
+			}
+		},
+		{
+			files: ["**/components/ui/**", "**/packages/ui/**"],
+			rules: {
+				"@deslop/coding-standards/no-destructured-parameter": "off",
+				"@deslop/coding-standards/no-renamed-import": "off"
+			}
+		},
+		{
+			files: ["**/*.ts"],
+			rules: { "react/rules-of-hooks": "off" }
+		},
+		{
+			files: ["**/*.tsx"],
+			rules: {
+				"effecttsgo/async-function": "off",
+				"typescript/require-await": "error",
+				"typescript/strict-void-return": "off",
+				"unicorn/no-null": "off"
+			}
+		}
+	],
+	plugins: [
+		"effecttsgo",
+		"eslint",
+		"typescript",
+		"oxc",
+		"import",
+		"react",
+		"unicorn"
+	],
+	rules: {
+		"@deslop/coding-standards/no-array-wrap-ternary": "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-double-nullish-check": "error",
+		"@deslop/coding-standards/no-effect-property-arrow": "error",
+		"@deslop/coding-standards/no-error-message-assertion": "error",
+		"@deslop/coding-standards/no-fail-in-generator": "error",
+		"@deslop/coding-standards/no-fake-ref-state": "error",
+		"@deslop/coding-standards/no-hand-written-guard": "error",
+		"@deslop/coding-standards/no-let": "error",
+		"@deslop/coding-standards/no-native-emptiness-check": "error",
+		"@deslop/coding-standards/no-native-method-call": "error",
+		"@deslop/coding-standards/no-option-value-access": "error",
+		"@deslop/coding-standards/no-readonly-type-syntax": "error",
+		"@deslop/coding-standards/no-redundant-return-type": "error",
+		"@deslop/coding-standards/no-redundant-state-type": "error",
+		"@deslop/coding-standards/no-redundant-use-ref-null-type": "error",
+		"@deslop/coding-standards/no-redundant-variable-annotation": "error",
+		"@deslop/coding-standards/no-reinvented-schema": "error",
+		"@deslop/coding-standards/no-renamed-import": "error",
+		"@deslop/coding-standards/no-stored-schema-operation": "error",
+		"@deslop/coding-standards/no-switch-statement": "error",
+		"@deslop/coding-standards/no-trivial-indirection": "error",
+		"@deslop/coding-standards/no-typeof": "error",
+		"@deslop/coding-standards/no-undestructured-use-state": "error",
+		"@deslop/coding-standards/no-unexplained-disable": "error",
+		"@deslop/coding-standards/no-unvalidated-json-decode": "error",
+		"@deslop/coding-standards/schema-type-pair": "error",
+		"effecttsgo/abort-controller-in-effect": "error",
+		"effecttsgo/crypto-random-uuid": "error",
+		"effecttsgo/crypto-random-uuid-in-effect": "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-random": "error",
+		"effecttsgo/global-random-in-effect": "error",
+		"effecttsgo/global-timers": "error",
+		"effecttsgo/global-timers-in-effect": "error",
+		"effecttsgo/node-builtin-import": "error",
+		"effecttsgo/prefer-schema-over-json": "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/async-function": "error",
+		"effecttsgo/catch-if-tag-to-catch-tag": "error",
+		"effecttsgo/catch-refail-to-tap-error": "error",
+		"effecttsgo/duplicate-package": "error",
+		"effecttsgo/effect-do-notation": "error",
+		"effecttsgo/effect-fn-iife": "error",
+		"effecttsgo/effect-fn-implicit-any": "error",
+		"effecttsgo/effect-fn-opportunity": "error",
+		"effecttsgo/effect-gen-uses-adapter": "error",
+		"effecttsgo/effect-in-failure": "error",
+		"effecttsgo/effect-in-void-success": "error",
+		"effecttsgo/effect-map-flatten": "error",
+		"effecttsgo/effect-map-void": "error",
+		"effecttsgo/effect-succeed-with-void": "error",
+		"effecttsgo/flat-map-ignored-param-to-and-then": "error",
+		"effecttsgo/flat-map-to-map": "error",
+		"effecttsgo/floating-effect": "error",
+		"effecttsgo/floating-effect-in-vitest": "error",
+		"effecttsgo/layer-merge-all-with-dependencies": "error",
+		"effecttsgo/lazy-effect": "error",
+		"effecttsgo/lazy-promise-in-effect-sync": "error",
+		"effecttsgo/leaking-requirements": "error",
+		"effecttsgo/map-some-to-as-some": "error",
+		"effecttsgo/match-effect-to-map-both": "error",
+		"effecttsgo/match-effect-to-match": "error",
+		"effecttsgo/missing-effect-context": "error",
+		"effecttsgo/missing-layer-context": "error",
+		"effecttsgo/missing-return-yield-star": "error",
+		"effecttsgo/missing-star-in-yield-effect-gen": "error",
+		"effecttsgo/multiple-effect-provide": "error",
+		"effecttsgo/nested-effect-gen-yield": "error",
+		"effecttsgo/option-match-to-from-option": "error",
+		"effecttsgo/outdated-api": "error",
+		"effecttsgo/prefer-succeed-some-or-none": "error",
+		"effecttsgo/promise-in-effect-success": "error",
+		"effecttsgo/provide-layer-succeed-to-provide-service": "error",
+		"effecttsgo/race-first-with-sleep-to-timeout": "error",
+		"effecttsgo/return-effect-in-gen": "error",
+		"effecttsgo/run-effect-inside-effect": "error",
+		"effecttsgo/run-of-exit-to-run-exit": "error",
+		"effecttsgo/strict-effect-provide": "error",
+		"effecttsgo/sync-to-succeed": "error",
+		"effecttsgo/try-catch-in-effect-gen": "error",
+		"effecttsgo/unnecessary-effect-gen": "error",
+		"effecttsgo/unnecessary-fail-yieldable-error": "error",
+		"effecttsgo/unnecessary-pipe": "error",
+		"effecttsgo/unnecessary-pipe-chain": "error",
+		"effecttsgo/unsafe-effect-type-assertion": "error",
+		"effecttsgo/any-unknown-in-error-context": "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-die-to-or-die": "error",
+		"effecttsgo/catch-tag-to-catch-reason": "error",
+		"effecttsgo/catch-to-ignore": "error",
+		"effecttsgo/catch-to-or-else-succeed": "error",
+		"effecttsgo/catch-unfailable-effect": "error",
+		"effecttsgo/flat-map-conditional-to-filter-or-fail": "error",
+		"effecttsgo/global-error-in-effect-catch": "error",
+		"effecttsgo/global-error-in-effect-failure": "error",
+		"effecttsgo/missing-effect-error": "error",
+		"effecttsgo/multiple-catch-tag": "error",
+		"effecttsgo/redundant-map-error": "error",
+		"effecttsgo/redundant-or-die": "error",
+		"effecttsgo/timeout-catch-tag-to-timeout-or-else": "error",
+		"effecttsgo/unknown-in-effect-catch": "error",
+		"effecttsgo/class-self-mismatch": "error",
+		"effecttsgo/deterministic-keys": "error",
+		"effecttsgo/generic-effect-services": "error",
+		"effecttsgo/instance-of-schema": "error",
+		"effecttsgo/new-schema-class": "error",
+		"effecttsgo/obsolete-match-import": "error",
+		"effecttsgo/obsolete-schema-import": "error",
+		"effecttsgo/overridden-schema-constructor": "error",
+		"effecttsgo/prefer-schema-type-property": "error",
+		"effecttsgo/prefer-typed-schema-decoder": "error",
+		"effecttsgo/redundant-schema-tag-identifier": "error",
+		"effecttsgo/schema-literal-non-finite": "error",
+		"effecttsgo/schema-number": "error",
+		"effecttsgo/schema-struct-with-tag": "error",
+		"effecttsgo/schema-sync-in-effect": "error",
+		"effecttsgo/service-not-as-class": "error",
+		"effecttsgo/unnecessary-typeof-type": "error",
+		"typescript/consistent-generic-constructors": "error",
+		"typescript/consistent-indexed-object-style": "error",
+		"typescript/consistent-type-assertions": ["error", {
+			arrayLiteralTypeAssertions: "never",
+			assertionStyle: "never",
+			objectLiteralTypeAssertions: "never"
+		}],
+		"typescript/consistent-type-definitions": ["error", "type"],
+		"typescript/consistent-type-exports": "error",
+		"typescript/consistent-type-imports": ["error", {
+			fixStyle: "separate-type-imports",
+			prefer: "type-imports"
+		}],
+		"typescript/method-signature-style": "error",
+		"typescript/prefer-function-type": "error",
+		"typescript/await-thenable": "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-dynamic-delete": "error",
+		"typescript/no-empty-object-type": "error",
+		"typescript/no-explicit-any": "error",
+		"typescript/no-floating-promises": "error",
+		"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-spread": "error",
+		"typescript/no-namespace": ["error", { allowDeclarations: true }],
+		"typescript/no-non-null-assertion": "error",
+		"typescript/no-redundant-type-constituents": "error",
+		"typescript/no-require-imports": "error",
+		"typescript/no-this-alias": "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-constraint": "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-declaration-merging": "error",
+		"typescript/no-unsafe-function-type": "error",
+		"typescript/no-unsafe-member-access": "error",
+		"typescript/no-unsafe-return": "error",
+		"typescript/no-useless-empty-export": "error",
+		"typescript/no-wrapper-object-types": "error",
+		"typescript/unbound-method": "error",
+		"typescript/unified-signatures": "error",
+		"typescript/prefer-as-const": "error",
+		"typescript/prefer-nullish-coalescing": "error",
+		"typescript/prefer-optional-chain": "error",
+		"typescript/restrict-plus-operands": "error",
+		"typescript/restrict-template-expressions": "error",
+		"typescript/strict-boolean-expressions": ["error", {
+			allowNumber: false,
+			allowString: false
+		}],
+		"typescript/strict-void-return": "error",
+		"arrow-body-style": ["error", "as-needed"],
+		curly: [
+			"error",
+			"multi-line",
+			"consistent"
+		],
+		eqeqeq: "error",
+		"func-names": [
+			"error",
+			"as-needed",
+			{ generators: "never" }
+		],
+		"func-style": ["error", "declaration"],
+		"import/newline-after-import": "error",
+		"import/no-absolute-path": "error",
+		"import/no-commonjs": "error",
+		"import/no-default-export": "error",
+		"import/no-duplicates": "error",
+		"import/no-empty-named-blocks": "error",
+		"import/no-mutable-exports": "error",
+		"import/no-namespace": ["error", { ignore: ["[!#./]*", "[!#./]*/**"] }],
+		"import/no-relative-parent-imports": "error",
+		"no-restricted-imports": ["error", {
+			paths: [
+				{
+					importNames: reactLegacyApis,
+					message: reactLegacyMessage,
+					name: "react"
+				},
+				{
+					importNames: ["vi"],
+					message: "A Layer is the seam; never use vi.",
+					name: "vitest"
+				},
+				{
+					importNames: ["vi"],
+					message: "A Layer is the seam; never use vi.",
+					name: "@effect/vitest"
+				},
+				{
+					importNames: ["expect"],
+					message: "Use assert from @effect/vitest.",
+					name: "vitest"
+				},
+				{
+					importNames: ["expect"],
+					message: "Use assert from @effect/vitest.",
+					name: "@effect/vitest"
+				}
+			],
+			patterns: [
+				{
+					message: "Use public package exports.",
+					regex: "^@[^/]+/[^/]+/(?:src|lib)(?:/|$)"
+				},
+				{
+					message: "Use glob from the FileSystem service.",
+					regex: "^glob(?:/|$)"
+				},
+				{
+					message: "Use effect/cli.",
+					regex: "^(?:commander|yargs)(?:/|$)"
+				},
+				{
+					message: "Use randomUUIDv4 from the Crypto service.",
+					regex: "^uuid(?:/|$)"
+				},
+				{
+					message: "Use HttpClient.",
+					regex: "^(?:axios|node-fetch)(?:/|$)"
+				},
+				{
+					message: "Use Config.",
+					regex: "^dotenv(?:/|$)"
+				},
+				{
+					message: "Use ChildProcess from effect/process.",
+					regex: "^execa(?:/|$)"
+				},
+				{
+					message: "Use the concurrency option of Effect.all or Effect.forEach.",
+					regex: "^p-limit(?:/|$)"
+				}
+			]
+		}],
+		"max-depth": ["error", 3],
+		"max-nested-callbacks": ["error", 6],
+		"no-cond-assign": "error",
+		"no-continue": "error",
+		"no-control-regex": "error",
+		"no-debugger": "error",
+		"no-else-return": "error",
+		"no-empty-function": ["error", { allow: ["arrowFunctions"] }],
+		"no-eval": "error",
+		"no-extend-native": "error",
+		"no-extra-bind": "error",
+		"no-extra-boolean-cast": "error",
+		"no-implied-eval": "error",
+		"no-invalid-regexp": "error",
+		"no-iterator": "error",
+		"no-lonely-if": "error",
+		"no-misleading-character-class": "error",
+		"no-multi-assign": "error",
+		"no-negated-condition": "error",
+		"no-nested-ternary": "error",
+		"no-new": "error",
+		"no-param-reassign": ["error", { props: true }],
+		"no-plusplus": "error",
+		"no-proto": "error",
+		"no-restricted-exports": ["error", { restrictedNamedExportsPattern: "Live$" }],
+		"no-restricted-globals": [
+			"error",
+			{
+				message: "Interrupt through Effect: a fiber, Effect.timeout, or a Scope.",
+				name: "AbortController"
+			},
+			{
+				message: "Import Array from 'effect'.",
+				name: "Array"
+			},
+			{
+				message: "Import Boolean from 'effect'.",
+				name: "Boolean"
+			},
+			{
+				message: "Define a Schema.TaggedError and fail with it.",
+				name: "Error"
+			},
+			{
+				message: mapMessage,
+				name: "Map"
+			},
+			{
+				message: "Import Number from 'effect'.",
+				name: "Number"
+			},
+			{
+				message: "Use Record or Struct from 'effect'.",
+				name: "Object"
+			},
+			{
+				message: "Use Number.parse.",
+				name: "parseFloat"
+			},
+			{
+				message: "Use Number.parse.",
+				name: "parseInt"
+			},
+			{
+				message: "Use Effect: Effect.tryPromise at the boundary, Effect.all to combine.",
+				name: "Promise"
+			},
+			{
+				message: "Use Predicate or Record from 'effect'.",
+				name: "Reflect"
+			},
+			{
+				message: setMessage,
+				name: "Set"
+			},
+			{
+				message: "Import String from 'effect'.",
+				name: "String"
+			},
+			{
+				message: "Read configuration with Config and services from the context.",
+				name: "global"
+			},
+			{
+				message: "Read configuration with Config and services from the context.",
+				name: "globalThis"
+			}
+		],
+		"no-restricted-properties": [
+			"error",
+			{
+				message: "Use standalone pipe.",
+				property: "pipe"
+			},
+			{
+				allowObjects: ["Predicate"],
+				message: "Use Predicate.hasProperty.",
+				property: "hasOwnProperty"
+			},
+			{
+				message: runMessage,
+				object: "Effect",
+				property: "runFork"
+			},
+			{
+				message: runMessage,
+				object: "Effect",
+				property: "runPromise"
+			},
+			{
+				message: runMessage,
+				object: "Effect",
+				property: "runPromiseExit"
+			},
+			{
+				message: runMessage,
+				object: "Effect",
+				property: "runSync"
+			},
+			{
+				message: runMessage,
+				object: "Effect",
+				property: "runSyncExit"
+			},
+			{
+				message: runMessage,
+				object: "ManagedRuntime",
+				property: "make"
+			},
+			{
+				message: "Use Number.max.",
+				object: "Math",
+				property: "max"
+			},
+			{
+				message: "Use Number.min.",
+				object: "Math",
+				property: "min"
+			},
+			{
+				message: "Use Number.round.",
+				object: "Math",
+				property: "round"
+			},
+			...map$1(reactLegacyApis, (property) => ({
+				message: reactLegacyMessage,
+				object: "React",
+				property
+			})),
+			{
+				message: "Use Schema.Struct.",
+				object: "Schema",
+				property: "Class"
+			},
+			{
+				message: "Use a branded schema.",
+				object: "Schema",
+				property: "Opaque"
+			},
+			{
+				message: "Use Schema.Struct.",
+				object: "Schema",
+				property: "TaggedClass"
+			},
+			{
+				message: "Use Schema.Struct.",
+				object: "Data",
+				property: "Class"
+			},
+			{
+				message: "Use Schema.TaggedError.",
+				object: "Data",
+				property: "Error"
+			},
+			{
+				message: "Use Schema.Struct.",
+				object: "Data",
+				property: "TaggedClass"
+			},
+			{
+				message: "Use Schema.TaggedError.",
+				object: "Data",
+				property: "TaggedError"
+			},
+			...map$1([
+				"addEventListener",
+				"atob",
+				"btoa",
+				"cancelAnimationFrame",
+				"cancelIdleCallback",
+				"dispatchEvent",
+				"localStorage",
+				"navigator",
+				"queueMicrotask",
+				"removeEventListener",
+				"requestAnimationFrame",
+				"requestIdleCallback",
+				"sessionStorage",
+				"structuredClone"
+			], (property) => ({
+				message: `Use the bare ${property} global.`,
+				object: "window",
+				property
+			})),
+			...map$1([
+				"clearInterval",
+				"clearTimeout",
+				"setInterval",
+				"setTimeout"
+			], (property) => ({
+				message: "Use Effect.sleep or Schedule.",
+				object: "window",
+				property
+			})),
+			{
+				message: "Use Console.",
+				object: "window",
+				property: "console"
+			},
+			{
+				message: "Use the Crypto service.",
+				object: "window",
+				property: "crypto"
+			},
+			{
+				message: "Use HttpClient.",
+				object: "window",
+				property: "fetch"
+			},
+			{
+				message: "Use Clock.",
+				object: "window",
+				property: "performance"
+			}
+		],
+		"no-self-assign": "error",
+		"no-shadow": ["error", { allow: [
+			"Array",
+			"Boolean",
+			"Console",
+			"Effect",
+			"HashMap",
+			"Number",
+			"Option",
+			"Schema",
+			"String"
+		] }],
+		"no-sparse-arrays": "error",
+		"no-throw-literal": "error",
+		"no-unmodified-loop-condition": "error",
+		"no-unneeded-ternary": "error",
+		"no-unreachable-loop": "error",
+		"no-unsafe-finally": "error",
+		"no-unused-expressions": "error",
+		"no-useless-assignment": "error",
+		"no-useless-backreference": "error",
+		"no-useless-call": "error",
+		"no-useless-catch": "error",
+		"no-useless-computed-key": "error",
+		"no-useless-concat": "error",
+		"no-useless-constructor": "error",
+		"no-useless-escape": "error",
+		"no-useless-rename": "error",
+		"no-useless-return": "error",
+		"no-void": "error",
+		"object-shorthand": "error",
+		"oxc/branches-sharing-code": "error",
+		"oxc/no-accumulating-spread": "error",
+		"oxc/no-map-spread": "error",
+		"oxc/only-used-in-recursion": "error",
+		"prefer-arrow-callback": "error",
+		"prefer-const": ["error", { destructuring: "all" }],
+		"prefer-template": "error",
+		"require-unicode-regexp": "error",
+		"react-doctor/no-call-component-as-function": "error",
+		"react-doctor/no-create-context-in-render": "error",
+		"react-doctor/no-default-props": "error",
+		"react-doctor/no-inline-exhaustive-style": "error",
+		"react-doctor/no-jsx-element-type": "error",
+		"react-doctor/no-many-boolean-props": "error",
+		"react-doctor/no-prop-types": "error",
+		"react-doctor/no-uncontrolled-input": "error",
+		"react-doctor/shadcn-icon-button-requires-label": "error",
+		"react-doctor/effect-listener-cleanup-mismatch": "error",
+		"react-doctor/no-async-effect-callback": "error",
+		"react-doctor/no-create-object-url-without-revoke": "error",
+		"react-doctor/no-derived-useState": "error",
+		"react-doctor/no-effect-event-in-deps": "error",
+		"react-doctor/no-effect-with-fresh-deps": "error",
+		"react-doctor/no-effect-wrapper-discards-callback-cleanup-return": "error",
+		"react-doctor/no-impure-state-updater": "error",
+		"react-doctor/no-mutable-in-deps": "error",
+		"react-doctor/no-mutating-reducer-state": "error",
+		"react-doctor/no-self-updating-effect": "error",
+		"react-doctor/no-set-state-in-render": "error",
+		"react-doctor/no-stale-timer-ref": "error",
+		"react-doctor/prefer-use-effect-event": "error",
+		"react-doctor/rerender-functional-setstate": "error",
+		"react-doctor/rerender-lazy-ref-init": "error",
+		"react-doctor/rerender-lazy-state-init": "error",
+		"react-doctor/no-enter-submit-without-ime-composition-guard": "error",
+		"react-doctor/no-event-handler": "error",
+		"react-doctor/no-flush-sync": "error",
+		"react-doctor/no-render-in-render": "error",
+		"react-doctor/rendering-conditional-render": "error",
+		"react-doctor/design-no-redundant-padding-axes": "error",
+		"react-doctor/design-no-redundant-size-axes": "error",
+		"react-doctor/no-global-css-variable-animation": "error",
+		"react-doctor/no-gray-on-colored-background": "error",
+		"react-doctor/no-inline-bounce-easing": "error",
+		"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-transition-all": "error",
+		"react/button-has-type": "error",
+		"react/checked-requires-onchange-or-readonly": "error",
+		"react/exhaustive-deps": "error",
+		"react/iframe-missing-sandbox": "error",
+		"react/immutability": "error",
+		"react/incompatible-library": "error",
+		"react/jsx-boolean-value": ["error", "never"],
+		"react/jsx-curly-brace-presence": ["error", {
+			children: "never",
+			propElementValues: "always",
+			props: "never"
+		}],
+		"react/jsx-fragments": ["error", "syntax"],
+		"react/jsx-key": "error",
+		"react/jsx-no-script-url": "error",
+		"react/jsx-no-target-blank": "error",
+		"react/jsx-no-useless-fragment": "error",
+		"react/memo-dependencies": "error",
+		"react/no-array-index-key": "error",
+		"react/no-children-prop": "error",
+		"react/no-clone-element": "error",
+		"react/no-danger": "error",
+		"react/no-object-type-as-default-prop": "error",
+		"react/no-react-children": "error",
+		"react/no-unknown-property": "error",
+		"react/no-unstable-nested-components": ["error", { allowAsProps: true }],
+		"react/preserve-manual-memoization": "error",
+		"react/purity": "error",
+		"react/refs": "error",
+		"react/rules-of-hooks": "error",
+		"react/self-closing-comp": "error",
+		"react/set-state-in-effect": "error",
+		"react/set-state-in-render": "error",
+		"react/static-components": "error",
+		"react/use-memo": "error",
+		"react/void-dom-elements-no-children": "error",
+		"react/void-use-memo": "error",
+		"shadcn/no-arbitrary-values": "error",
+		"shadcn/no-inline-styles": "error",
+		"shadcn/no-raw-colors": "error",
+		"shadcn/no-restyle": ["error", { allow: ["layout"] }],
+		"shadcn/no-unknown-classes": "error",
+		"shadcn/require-static-classes": "error",
+		"sort-keys": [
+			"error",
+			"asc",
+			{
+				allowLineSeparatedGroups: true,
+				natural: true
+			}
+		],
+		"typescript/ban-ts-comment": ["error", { "ts-nocheck": true }],
+		"typescript/no-restricted-types": ["error", { types: {
+			AbortController: "Use Effect interruption.",
+			Array: "Use T[].",
+			Date: "Use DateTime.",
+			Error: "Use Schema.TaggedError.",
+			Iterable: "Use T[].",
+			Map: mapMessage,
+			Promise: "Use Effect.",
+			ReadonlyArray: "Use T[].",
+			ReadonlyMap: mapMessage,
+			ReadonlySet: setMessage,
+			Set: setMessage,
+			undefined: "Use an optional property or parameter, or let inference supply undefined."
+		} }],
+		"typescript/no-unnecessary-type-assertion": "error",
+		"typescript/no-useless-default-assignment": "error",
+		"unicorn/filename-case": "error",
+		"unicorn/no-immediate-mutation": "error",
+		"unicorn/no-null": "error",
+		"unicorn/no-object-as-default-parameter": "error",
+		"unicorn/no-process-exit": "error",
+		"unicorn/no-static-only-class": "error",
+		"unicorn/no-useless-fallback-in-spread": "error",
+		"unicorn/no-useless-length-check": "error",
+		"unicorn/no-useless-spread": "error",
+		"unicorn/prefer-logical-operator-over-ternary": "error",
+		"unicorn/prefer-optional-catch-binding": "error",
+		"use-isnan": "error"
+	},
+	settings: {
+		react: { version: "19.0" },
+		shadcn: { ui: ["@deslop/components/ui", "@dual/ui/components"] }
+	}
+});
+var oxlint_default = definePlugin({
+	meta: { name: "@deslop/coding-standards" },
+	rules: {
+		"no-array-wrap-ternary": noArrayWrapTernary,
+		"no-constant-function": noConstantFunction,
+		"no-deep-pipe": noDeepPipe,
+		"no-destructured-parameter": noDestructuredParameter,
+		"no-double-nullish-check": noDoubleNullishCheck,
+		"no-effect-property-arrow": noEffectPropertyArrow,
+		"no-error-message-assertion": noErrorMessageAssertion,
+		"no-fail-in-generator": noFailInGenerator,
+		"no-fake-ref-state": noFakeRefState,
+		"no-hand-written-guard": noHandWrittenGuard,
+		"no-let": noLet,
+		"no-native-emptiness-check": noNativeEmptinessCheck,
+		"no-native-method-call": noNativeMethodCall,
+		"no-option-value-access": noOptionValueAccess,
+		"no-readonly-type-syntax": noReadonlyTypeSyntax,
+		"no-redundant-return-type": noRedundantReturnType,
+		"no-redundant-state-type": noRedundantStateType,
+		"no-redundant-use-ref-null-type": noRedundantUseRefNullType,
+		"no-redundant-variable-annotation": noRedundantVariableAnnotation,
+		"no-reinvented-schema": noReinventedSchema,
+		"no-renamed-import": noRenamedImport,
+		"no-stored-schema-operation": noStoredSchemaOperation,
+		"no-switch-statement": noSwitchStatement,
+		"no-trivial-indirection": noTrivialIndirection,
+		"no-typeof": noTypeof,
+		"no-undestructured-use-state": noUndestructuredUseState,
+		"no-unexplained-disable": noUnexplainedDisable,
+		"no-unvalidated-json-decode": noUnvalidatedJsonDecode,
+		"schema-type-pair": schemaTypePair
+	}
+});
+//#endregion
+export { oxlint_default as default, oxlint };