@deslop/coding-standards 0.1.761 → 0.1.804

package/README.md

@@ -0,0 +1,73 @@
+# Coding standards
+
+A strict Oxlint preset and an installer for the engineering, design and testing agent skills. Requires Node 26+.
+
+## Install the skills
+
+Run inside a Git repository, including a linked worktree:
+
+```bash
+vpx @deslop/coding-standards@latest
+```
+
+It copies the three skills into the repository's existing `.agents`, `.claude` and `.codex` directories, or creates `.agents` when none exists. A refresh replaces only those three skills, and destinations outside the repository or inside global agent configuration are rejected. Nothing is added to the manifest, lockfile or lint configuration. Installed copies are read-only; refresh them with the CLI.
+
+## Use the lint preset
+
+```bash
+vp add -D @deslop/coding-standards @effect/tsgo
+vp exec effect-tsgo patch --no-typescript --oxlint
+```
+
+```ts
+import {defineConfig} from 'vite-plus'
+import {oxlint} from '@deslop/coding-standards'
+
+export default defineConfig({lint: {extends: [oxlint]}})
+```
+
+The preset needs Effect-tsgo's patched Oxlint, so keep the patch command in the project's `prepare` script.
+
+<details>
+<summary>For agents</summary>
+
+### Decisions
+
+| Owner      | Decision                                                                                                                                                                                                                                                                                                                                                                      |
+| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `src/`     | Flat package structure; rules in `src/rules`, no separate plugin or install-test harness                                                                                                                                                                                                                                                                                      |
+| `skills/`  | Maintained engineering, design and testing sources; refresh repository copies from the TypeScript CLI, no build needed                                                                                                                                                                                                                                                        |
+| Lint rules | Prefer an equivalent maintained rule before custom enforcement; consumer code conforms to strict standards, not the reverse. Fix broken or imprecise rules, not inconvenient valid diagnostics. A rule targets code the engineering skill and the other rules allow; an edge case that only unusual code reaches takes an inline disable with its reason, never a looser rule |
+| Rule proof | Existing public CLI regression cases, with accepted and rejected controls; no severity or exclusion workaround                                                                                                                                                                                                                                                                |
+
+With workspace dependencies installed, from the repository root:
+
+```bash
+vp test run tools/coding-standards/src/rules/rules.test.ts
+node tools/coding-standards/src/install.ts
+```
+
+### Rejected shortcuts
+
+| Candidate                                                | Reason                                                                                                              |
+| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| Blanket `unknown` type ban                               | Opaque SDK and framework contracts legitimately need it; narrow or decode before use instead of fabricating a shape |
+| Functional preset or dependency just to replace `no-let` | The preset conflicts; a selective plugin adds dependencies for a tiny rule                                          |
+| Syntax-only generator-failure rule                       | Factory-call syntax does not establish yieldability; the existing type-aware Effect rule owns that check            |
+
+### Skill sources
+
+| Source                                                                                                                                                                                                                       | Used and boundary                                                                                                                                                                                 |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [Matt Pocock's engineering skills](https://github.com/mattpocock/skills/tree/d81f3a183412e71a5b1e84ca21bc1a35eea03a60/skills/engineering)                                                                                    | Caller-first contracts, causal debugging and one uncertain behavior at a time; no universal TDD                                                                                                   |
+| [Cursor / pstack](https://github.com/cursor/plugins/tree/e43c7ee26e0038c6c1fa8380dd34ce86ff94cb2a/pstack)                                                                                                                    | Interface rationale, focused bug replay and defensible benchmarks; no playbook-stage machinery                                                                                                    |
+| [Kit Langton's Effect skill](https://github.com/kitlangton/skills/tree/71195e36024ebd2e66c5beac946e81eafd5abc43/skills/effect)                                                                                               | Schema construction/optionality, checked against actual [Effect 4 source](https://github.com/Effect-TS/effect/tree/67ba4e46a11ccda0b6761578bfd22c04ae00167d/packages/effect/src)                  |
+| [Vercel's agent skills](https://github.com/vercel-labs/agent-skills/tree/063bee94c3f4df8453406c830b0a7df0f2860278/skills)                                                                                                    | Independent I/O and narrow subscriptions, translated to Effect/atoms; no manual React memoization                                                                                                 |
+| [Anthropic frontend-design](https://github.com/anthropics/skills/tree/main/skills/frontend-design), [Taste Skill](https://github.com/Leonxlnx/taste-skill), [Vercel design guidelines](https://vercel.com/design/guidelines) | Task-led composition, typography and useful copy; no forced novelty, arbitrary aesthetic bans or plugin bundle                                                                                    |
+| [Emil Kowalski's skills](https://github.com/emilkowalski/skills/tree/e8a175de22ae1e49370fc144c1f3bb9aeedf988d/skills)                                                                                                        | Realistic layout stress, interruptible motion and mobile checks; no fixed variant picker or audit fan-out. Performance caveats checked against [Motion docs](https://motion.dev/docs/performance) |
+| [Dillon Mulroy's skills](https://github.com/dmmulroy/skills/tree/8603380821fee6a77c82639f364ce8fe4f5a92be) and [anti-slop](https://github.com/dmmulroy/anti-slop/tree/c44ef22ca116d0ba62a3ff663a0bd13a3f3fa40b)              | Reviewed Effect/error and cleanup approaches; retain our own service layout and ownership                                                                                                         |
+| [Awesome DESIGN.md](https://github.com/VoltAgent/awesome-design-md) and [Impeccable](https://github.com/pbakaus/impeccable)                                                                                                  | Reviewed reference collections; community brand analyses are inspiration, not authoritative/current tokens                                                                                        |
+
+These are selectively adapted ideas, not imported frameworks. Concrete behavior, existing stack and settled user decisions govern the maintained skills.
+
+</details>

package/dist/{MutableRef-DT4DAKeI.mjs → MutableRef-NhSl8G9M.mjs}

@@ -3444,7 +3444,7 @@ const isSome = isSome$1;
 * @category pattern matching
 * @since 2.0.0
 */
-const match$2 = /*#__PURE__*/ dual(2, (self, { onNone, onSome }) => isNone(self) ? onNone() : onSome(self.value));
+const match$3 = /*#__PURE__*/ dual(2, (self, { onNone, onSome }) => isNone(self) ? onNone() : onSome(self.value));
 /**
 * Extracts the value from a `Some`, or evaluates a fallback thunk on `None`.
 *
@@ -3604,6 +3604,37 @@ const fromNullishOr = (a) => a == null ? none() : some$1(a);
 */
 const fromUndefinedOr = (a) => a === void 0 ? none() : some$1(a);
 /**
+* Converts a possibly `null` value into an `Option`, leaving `undefined`
+* as a valid `Some`.
+*
+* **When to use**
+*
+* Use when you want to treat only `null` as absent while preserving
+* `undefined` as a meaningful value.
+*
+* **Details**
+*
+* - `null` → `None`
+* - Any other value (including `undefined`) → `Some`
+*
+* **Example** (Converting possibly null values to an Option)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.fromNullOr(null) // => Option.none()
+* Option.fromNullOr(undefined) // => Option.some(undefined)
+* Option.fromNullOr(42) // => Option.some(42)
+* ```
+*
+* @see {@link fromNullishOr} to treat both `null` and `undefined` as absent
+* @see {@link fromUndefinedOr} to only treat `undefined` as absent
+*
+* @category converting
+* @since 4.0.0
+*/
+const fromNullOr = (a) => a === null ? none() : some$1(a);
+/**
 * Extracts the value from a `Some`, or returns `undefined` for `None`.
 *
 * **When to use**
@@ -3741,6 +3772,34 @@ const map$2 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : some$1(
 */
 const flatMap$1 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : f(self.value));
 /**
+* Flattens a nested `Option<Option<A>>` into `Option<A>`.
+*
+* **When to use**
+*
+* Use when you need to remove one layer of nested `Option`.
+*
+* **Details**
+*
+* - `Some(Some(value))` → `Some(value)`
+* - `Some(None)` → `None`
+* - `None` → `None`
+*
+* **Example** (Flattening nested Options)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* Option.flatten(Option.some(Option.some("value"))) // => Option.some("value")
+* Option.flatten(Option.some(Option.none())) // => Option.none()
+* ```
+*
+* @see {@link flatMap} which is `map` + `flatten`
+*
+* @category sequencing
+* @since 2.0.0
+*/
+const flatten$1 = /*#__PURE__*/ flatMap$1(identity);
+/**
 * Combines two `Option`s into a `Some` containing a tuple `[A, B]` if both
 * are `Some`.
 *
@@ -4186,7 +4245,7 @@ const isSuccess = isSuccess$1;
 * @category pattern matching
 * @since 2.0.0
 */
-const match$1 = /*#__PURE__*/ dual(2, (self, { onFailure, onSuccess }) => isFailure(self) ? onFailure(self.failure) : onSuccess(self.success));
+const match$2 = /*#__PURE__*/ dual(2, (self, { onFailure, onSuccess }) => isFailure(self) ? onFailure(self.failure) : onSuccess(self.success));
 /**
 * Extracts the success value or throws the raw failure value `E`.
 *
@@ -4557,7 +4616,7 @@ const ensure = (self) => Array$1.isArray(self) ? self : [self];
 * @category pattern matching
 * @since 2.0.0
 */
-const match = /*#__PURE__*/ dual(2, (self, { onEmpty, onNonEmpty }) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(self) : onEmpty());
+const match$1 = /*#__PURE__*/ dual(2, (self, { onEmpty, onNonEmpty }) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(self) : onEmpty());
 /**
 * Adds a single element to the front of an iterable, returning a `NonEmptyArray`.
 *
@@ -4769,6 +4828,30 @@ const get$1 = /*#__PURE__*/ dual(2, (self, index) => {
 	return isOutOfBounds(i, self) ? none() : some$1(self[i]);
 });
 /**
+* Returns the first element of an array safely wrapped in `Option.some`, or
+* `Option.none` if the array is empty.
+*
+* **When to use**
+*
+* Use to safely get the first element of an array that may be empty.
+*
+* **Example** (Getting the first element)
+*
+* ```ts import.meta.vitest
+* import { Array, Option } from "effect"
+*
+* Array.head([1, 2, 3]) // => Option.some(1)
+* Array.head([]) // => Option.none()
+* ```
+*
+* @see {@link headNonEmpty} — direct access when array is known non-empty
+* @see {@link last} — get the last element
+*
+* @category getters
+* @since 2.0.0
+*/
+const head = /*#__PURE__*/ get$1(0);
+/**
 * Returns the last element of an array safely wrapped in `Option.some`, or
 * `Option.none` if the array is empty.
 *
@@ -5635,6 +5718,43 @@ const Order = String$2;
 */
 const trimEnd = (self) => self.trimEnd();
 /**
+* Splits a string into an array of substrings using a separator.
+*
+* **Example** (Splitting strings)
+*
+* ```ts import.meta.vitest
+* import { pipe, String } from "effect"
+*
+* pipe("abc", String.split("")) // => ["a", "b", "c"]
+* pipe("", String.split("")) // => [""]
+* String.split("hello,world", ",") // => ["hello", "world"]
+* ```
+*
+* @category transforming
+* @since 2.0.0
+*/
+const split = /*#__PURE__*/ dual(2, (self, separator) => {
+	const out = self.split(separator);
+	return isArrayNonEmpty$1(out) ? out : [self];
+});
+/**
+* Returns `true` if `searchString` appears as a substring of `self`, at one or more positions that are
+* greater than or equal to `position`; otherwise, returns `false`.
+*
+* **Example** (Checking for substrings)
+*
+* ```ts import.meta.vitest
+* import { pipe, String } from "effect"
+*
+* pipe("hello world", String.includes("world")) // => true
+* pipe("hello world", String.includes("foo")) // => false
+* ```
+*
+* @category predicates
+* @since 2.0.0
+*/
+const includes = (searchString, position) => (self) => self.includes(searchString, position);
+/**
 * Returns `true` if the string starts with the specified search string.
 *
 * **Example** (Checking string prefixes)
@@ -5650,6 +5770,27 @@ const trimEnd = (self) => self.trimEnd();
 * @since 2.0.0
 */
 const startsWith = (searchString, position) => (self) => self.startsWith(searchString, position);
+/**
+* Matches a string against a pattern safely and returns `Option.some` with the match
+* array, or `Option.none` when the pattern does not match.
+*
+* **Example** (Matching regular expressions)
+*
+* ```ts import.meta.vitest
+* import { Option, pipe, String } from "effect"
+*
+* pipe(
+*   "hello",
+*   String.match(/l+/),
+*   Option.map((match) => [match[0], match.index])
+* ) // => Option.some(["ll", 2])
+* pipe("hello", String.match(/x/)) // => Option.none()
+* ```
+*
+* @category searching
+* @since 2.0.0
+*/
+const match = (regExp) => (self) => fromNullOr(self.match(regExp));
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0/node_modules/effect/dist/MutableRef.js
 const TypeId = "~effect/MutableRef";
@@ -5848,4 +5989,4 @@ const set = /*#__PURE__*/ dual(2, (self, value) => {
 */
 const update = /*#__PURE__*/ dual(2, (self, f) => set(self, f(get(self))));
 //#endregion
-export { succeed as $, isReadonlyObject as $n, contE as $t, isCanonicalArrayIndex as A, symbol as An, Tuple as At, some as B, hasProperty as Bn, ReasonBase as Bt, flatMap as C, formatDate as Cn, String$2 as Ct, getSomes as D, currentFiberTypeId as Dn, isLessThanOrEqualTo as Dt, get$1 as E, formatPropertyKey as En, isLessThan as Et, map as F, optimize as Fn, Error$2 as Ft, map$1 as G, isNotNull as Gn, causeAnnotate as Gt, take as H, isError as Hn, TaggedError$1 as Ht, match as I, random as In, ExitTypeId as It, fail as J, isNullish as Jn, causeFail as Jt, remove as K, isNotNullish as Kn, causeDie as Kt, of as L, string as Ln, Fail as Lt, join as M, combine as Mn, strictEqual as Mt, last as N, hash as Nn, CauseImpl as Nt, isArrayEmpty as O, byReferenceUnsafe as On, make$1 as Ot, makeEquivalence as P, number as Pn, Done as Pt, match$1 as Q, isPropertyKey as Qn, contAll as Qt, prepend as R, structure as Rn, InterruptorStackTrace as Rt, findLast as S, format as Sn, Number$1 as St, fromIterable as T, formatPath as Tn, isGreaterThanOrEqualTo as Tt, fromEntries as U, isFunction as Un, Yield as Ut, sort as V, isBoolean as Vn, StackTraceKey as Vt, get$2 as W, isIterable as Wn, args as Wt, getOrThrow as X, isObject as Xn, constEmptyAnnotations as Xt, fromOption as Y, isNumber as Yn, causeFromReasons as Yt, isFailure as Z, isObjectKeyword as Zn, contA as Zt, every as _, getStackTraceLimit as _n, orElse as _t, startsWith as a, exitSucceed as an, constTrue as ar, firstSomeOf as at, findFirst as b, NodeInspectSymbol as bn, BigInt as bt, TaggedError as c, isDone as cn, constant as cr, fromUndefinedOr as ct, appendAll as d, isInterruptReason as dn, memoize as dr, isNone as dt, done as en, isString as er, normalize as et, contains as f, makePrimitive as fn, memoizeIdempotent as fr, isSome as ft, ensure as g, internalCall as gn, pipeArguments as gr, none as gt, empty as h, assignProperty as hn, Prototype as hr, match$2 as ht, Order as i, exitFailCause as in, constFalse as ir, filter$1 as it, isReadonlyArrayNonEmpty as j, array as jn, make$2 as jt, isArrayNonEmpty as k, equals as kn, mapInput as kt, taggedEnum as l, isEffect as ln, dual as lr, getOrElse as lt, dropRight as m, withFiber as mn, Class$1 as mr, map$2 as mt, make as n, exitDie as nn, isUndefined as nr, contains$1 as nt, trimEnd as o, isCause as on, constUndefined as or, flatMap$1 as ot, dedupe as p, makePrimitiveProto as pn, pipe as pr, liftThrowable as pt, values as q, isNotUndefined as qn, causeEmpty as qt, update as r, exitFail as rn, isUnknown as rr, exists as rt, Error$1 as s, isDieReason as sn, constVoid as sr, fromNullishOr as st, get as t, evaluate as tn, isTagged as tr, all as tt, append as u, isFailReason as un, identity as ur, getOrUndefined as ut, filter as v, setStackTraceLimit as vn, some$1 as vt, flatten as w, formatJson as wn, isGreaterThan as wt, findFirstIndex as x, toStringUnknown as xn, Date$1 as xt, filterMap as y, BaseProto as yn, zipWith as yt, reduce as z, symbol$1 as zn, PipeInspectableProto as zt };
+export { fromOption as $, isNullish as $n, causeFail as $t, getSomes as A, formatPath as An, isGreaterThanOrEqualTo as At, match$1 as B, optimize as Bn, Error$2 as Bt, findFirst as C, setStackTraceLimit as Cn, some$1 as Ct, flatten as D, format as Dn, Number$1 as Dt, flatMap as E, toStringUnknown as En, Date$1 as Et, isReadonlyArrayNonEmpty as F, symbol as Fn, Tuple as Ft, sort as G, hasProperty as Gn, ReasonBase as Gt, prepend as H, string as Hn, Fail as Ht, join as I, array as In, make$2 as It, get$2 as J, isFunction as Jn, Yield as Jt, take as K, isBoolean as Kn, StackTraceKey as Kt, last as L, combine as Ln, strictEqual as Lt, isArrayEmpty as M, currentFiberTypeId as Mn, isLessThanOrEqualTo as Mt, isArrayNonEmpty as N, byReferenceUnsafe as Nn, make$1 as Nt, fromIterable as O, formatDate as On, String$2 as Ot, isCanonicalArrayIndex as P, equals as Pn, mapInput as Pt, fail as Q, isNotUndefined as Qn, causeEmpty as Qt, makeEquivalence as R, hash as Rn, CauseImpl as Rt, filterMap as S, getStackTraceLimit as Sn, orElse as St, findLast as T, NodeInspectSymbol as Tn, BigInt as Tt, reduce as U, structure as Un, InterruptorStackTrace as Ut, of as V, random as Vn, ExitTypeId as Vt, some as W, symbol$1 as Wn, PipeInspectableProto as Wt, remove as X, isNotNull as Xn, causeAnnotate as Xt, map$1 as Y, isIterable as Yn, args as Yt, values as Z, isNotNullish as Zn, causeDie as Zt, dropRight as _, makePrimitive as _n, memoizeIdempotent as _r, isSome as _t, includes as a, done as an, isString as ar, all as at, every as b, assignProperty as bn, Prototype as br, match$3 as bt, startsWith as c, exitFail as cn, isUnknown as cr, filter$1 as ct, TaggedError as d, isCause as dn, constUndefined as dr, flatten$1 as dt, causeFromReasons as en, isNumber as er, getOrThrow as et, taggedEnum as f, isDieReason as fn, constVoid as fr, fromNullishOr as ft, dedupe as g, isInterruptReason as gn, memoize as gr, isNone as gt, contains as h, isFailReason as hn, identity as hr, getOrUndefined as ht, Order as i, contE as in, isReadonlyObject as ir, normalize as it, head as j, formatPropertyKey as jn, isLessThan as jt, get$1 as k, formatJson as kn, isGreaterThan as kt, trimEnd as l, exitFailCause as ln, constFalse as lr, firstSomeOf as lt, appendAll as m, isEffect as mn, dual as mr, getOrElse as mt, make as n, contA as nn, isObjectKeyword as nr, match$2 as nt, match as o, evaluate as on, isTagged as or, contains$1 as ot, append as p, isDone as pn, constant as pr, fromUndefinedOr as pt, fromEntries as q, isError as qn, TaggedError$1 as qt, update as r, contAll as rn, isPropertyKey as rr, succeed as rt, split as s, exitDie as sn, isUndefined as sr, exists as st, get as t, constEmptyAnnotations as tn, isObject as tr, isFailure as tt, Error$1 as u, exitSucceed as un, constTrue as ur, flatMap$1 as ut, empty as v, makePrimitiveProto as vn, pipe as vr, liftThrowable as vt, findFirstIndex as w, BaseProto as wn, zipWith as wt, filter as x, internalCall as xn, pipeArguments as xr, none as xt, ensure as y, withFiber as yn, Class$1 as yr, map$2 as yt, map as z, number as zn, Done as zt };

package/dist/install.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { $ as succeed$6, $t as contE, A as isCanonicalArrayIndex, An as symbol, B as some$1, Bn as hasProperty, Bt as ReasonBase, Ct as String$6, Dn as currentFiberTypeId, En as formatPropertyKey, F as map$9, Ft as Error$3, Gn as isNotNull, Gt as causeAnnotate, Hn as isError, Ht as TaggedError$2, I as match$5, In as random, It as ExitTypeId, J as fail$5, Jn as isNullish, Jt as causeFail, Kn as isNotNullish, Kt as causeDie, L as of, Ln as string$1, Lt as Fail, M as join, Mn as combine$1, Nn as hash, Nt as CauseImpl, O as isArrayEmpty, Pn as number$1, Pt as Done$1, Q as match$3, Qt as contAll, Rn as structure, Rt as InterruptorStackTrace, S as findLast, Sn as format$1, St as Number$6, T as fromIterable$1, Tn as formatPath, Un as isFunction, Ut as Yield, Vn as isBoolean$1, Vt as StackTraceKey, Wn as isIterable, Wt as args, Xn as isObject, Xt as constEmptyAnnotations, Yn as isNumber, Yt as causeFromReasons, Z as isFailure$1, Zn as isObjectKeyword, Zt as contA, _n as getStackTraceLimit, a as startsWith, an as exitSucceed, ar as constTrue, b as findFirst, bn as NodeInspectSymbol, c as TaggedError$1, cn as isDone$2, cr as constant, ct as fromUndefinedOr, dn as isInterruptReason, dr as memoize, dt as isNone, en as done$1, er as isString, et as normalize$1, f as contains, fn as makePrimitive$1, fr as memoizeIdempotent, ft as isSome, gn as internalCall, gr as pipeArguments, gt as none, h as empty$3, hn as assignProperty, hr as Prototype$1, ht as match$4, in as exitFailCause, ir as constFalse, j as isReadonlyArrayNonEmpty, k as isArrayNonEmpty, kn as equals$1, kt as mapInput, l as taggedEnum, ln as isEffect$1, lr as dual, lt as getOrElse, mn as withFiber$1, mr as Class, mt as map$10, n as make$29, nn as exitDie, nr as isUndefined, o as trimEnd, on as isCause, or as constUndefined, ot as flatMap$3, p as dedupe, pn as makePrimitiveProto, pr as pipe, qn as isNotUndefined, qt as causeEmpty, rn as exitFail, rr as isUnknown, rt as exists, s as Error$2, sn as isDieReason, sr as constVoid, st as fromNullishOr, tn as evaluate, tr as isTagged, u as append$1, un as isFailReason$1, ur as identity, ut as getOrUndefined$1, v as filter, vn as setStackTraceLimit, vt as some, wn as formatJson, wt as isGreaterThan$1, x as findFirstIndex, xn as toStringUnknown, yn as BaseProto, z as reduce, zn as symbol$1, zt as PipeInspectableProto } from "./MutableRef-DT4DAKeI.mjs";
+import { $n as isNullish, $t as causeFail, An as formatPath, B as match$5, Bt as Error$3, C as findFirst, Cn as setStackTraceLimit, Ct as some, Dn as format$1, Dt as Number$6, En as toStringUnknown, F as isReadonlyArrayNonEmpty, Fn as symbol, Gn as hasProperty, Gt as ReasonBase, Hn as string$1, Ht as Fail, I as join, Jn as isFunction, Jt as Yield, Kn as isBoolean$1, Kt as StackTraceKey, Ln as combine$1, M as isArrayEmpty, Mn as currentFiberTypeId, N as isArrayNonEmpty, O as fromIterable$1, Ot as String$6, P as isCanonicalArrayIndex, Pn as equals$1, Pt as mapInput, Q as fail$5, Qn as isNotUndefined, Qt as causeEmpty, Rn as hash, Rt as CauseImpl, Sn as getStackTraceLimit, T as findLast, Tn as NodeInspectSymbol, U as reduce, Un as structure, Ut as InterruptorStackTrace, V as of, Vn as random, Vt as ExitTypeId, W as some$1, Wn as symbol$1, Wt as PipeInspectableProto, Xn as isNotNull, Xt as causeAnnotate, Yn as isIterable, Yt as args, Zn as isNotNullish, Zt as causeDie, _n as makePrimitive$1, _r as memoizeIdempotent, _t as isSome, an as done$1, ar as isString, bn as assignProperty, br as Prototype$1, bt as match$4, c as startsWith, cn as exitFail, cr as isUnknown, d as TaggedError$1, dn as isCause, dr as constUndefined, en as causeFromReasons, er as isNumber, f as taggedEnum, fn as isDieReason, fr as constVoid, ft as fromNullishOr, g as dedupe, gn as isInterruptReason, gr as memoize, gt as isNone, h as contains, hn as isFailReason$1, hr as identity, ht as getOrUndefined$1, in as contE, it as normalize$1, jn as formatPropertyKey, kn as formatJson, kt as isGreaterThan$1, l as trimEnd, ln as exitFailCause, lr as constFalse, mn as isEffect$1, mr as dual, mt as getOrElse, n as make$29, nn as contA, nr as isObjectKeyword, nt as match$3, on as evaluate, or as isTagged, p as append$1, pn as isDone$2, pr as constant, pt as fromUndefinedOr, qn as isError, qt as TaggedError$2, rn as contAll, rt as succeed$6, sn as exitDie, sr as isUndefined, st as exists, tn as constEmptyAnnotations, tr as isObject, tt as isFailure$1, u as Error$2, un as exitSucceed, ur as constTrue, ut as flatMap$3, v as empty$3, vn as makePrimitiveProto, vr as pipe, w as findFirstIndex, wn as BaseProto, x as filter, xn as internalCall, xr as pipeArguments, xt as none, yn as withFiber$1, yr as Class, yt as map$10, z as map$9, zn as number$1, zt as Done$1 } from "./MutableRef-NhSl8G9M.mjs";
 import * as NodeChildProcess from "node:child_process";
 import { PassThrough } from "node:stream";
 import * as NodeCrypto from "node:crypto";
@@ -24685,7 +24685,7 @@ const runWith = (command, config) => {
 };
 //#endregion
 //#region package.json
-var version = "0.1.761";
+var version = "0.1.804";
 //#endregion
 //#region src/install.ts
 const cli = pipe(make("deslop-coding-standards", {}, fnUntraced(function* () {

package/dist/oxlint.d.ts

@@ -4093,12 +4093,12 @@ export declare const oxlint: {
     '@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-nullish-ternary': "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";
@@ -4107,6 +4107,7 @@ export declare const oxlint: {
     '@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-single-use-value': "error";
     '@deslop/coding-standards/no-stored-schema-operation': "error";
     '@deslop/coding-standards/no-switch-statement': "error";
     '@deslop/coding-standards/no-trivial-indirection': "error";
@@ -4320,6 +4321,7 @@ export declare const oxlint: {
     'max-depth': ["error", number];
     'max-nested-callbacks': ["error", number];
     'no-cond-assign': "error";
+    'no-constant-binary-expression': "error";
     'no-continue': "error";
     'no-control-regex': "error";
     'no-debugger': "error";
@@ -4335,6 +4337,7 @@ export declare const oxlint: {
     'no-invalid-regexp': "error";
     'no-iterator': "error";
     'no-lonely-if': "error";
+    'no-loss-of-precision': "error";
     'no-misleading-character-class': "error";
     'no-multi-assign': "error";
     'no-negated-condition': "error";
@@ -4504,6 +4507,9 @@ export declare const oxlint: {
     'no-unneeded-ternary': "error";
     'no-unreachable-loop': "error";
     'no-unsafe-finally': "error";
+    'no-unsafe-optional-chaining': ["error", {
+      disallowArithmeticOperators: true;
+    }];
     'no-unused-expressions': "error";
     'no-useless-assignment': "error";
     'no-useless-backreference': "error";
@@ -4515,6 +4521,7 @@ export declare const oxlint: {
     'no-useless-escape': "error";
     'no-useless-rename': "error";
     'no-useless-return': "error";
+    'no-var': "error";
     'no-void': "error";
     'object-shorthand': "error";
     'oxc/branches-sharing-code': "error";
@@ -4528,6 +4535,7 @@ export declare const oxlint: {
     'prefer-template': "error";
     'require-unicode-regexp': "error";
     'react-doctor/no-call-component-as-function': "error";
+    'react-doctor/no-controlled-input-value-without-state-update': "error";
     'react-doctor/no-create-context-in-render': "error";
     'react-doctor/no-default-props': "error";
     'react-doctor/no-inline-exhaustive-style': "error";