@deslop/coding-standards 0.1.785 → 0.1.804

package/README.md

@@ -1,20 +1,16 @@
 # Coding standards
 
-Strict Oxlint preset and repository skill installer. Requires Node 26+; skill installation runs inside a Git repository, including linked worktrees.
+A strict Oxlint preset and an installer for the engineering, design and testing agent skills. Requires Node 26+.
 
-## Install skills
+## Install the skills
+
+Run inside a Git repository, including a linked worktree:
 
 ```bash
 vpx @deslop/coding-standards@latest
 ```
 
-| Result                                 | Scope                                                                                              |
-| -------------------------------------- | -------------------------------------------------------------------------------------------------- |
-| Engineering, design and testing skills | Git root's existing `.agents`, `.claude` and `.codex` directories; creates `.agents` if none exist |
-| Refresh                                | Replaces only those three skill names; preserves other skills and global configuration             |
-| Boundary                               | Rejects destinations escaping the repository or overlapping global configuration                   |
-
-No repository dependency, manifest/lock change or lint configuration change. Treat installed skill copies as read-only; refresh through the CLI.
+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
 
@@ -30,24 +26,19 @@ import {oxlint} from '@deslop/coding-standards'
 export default defineConfig({lint: {extends: [oxlint]}})
 ```
 
-The preset uses Effect-tsgo's patched Oxlint and compatible tsgolint; keep the patch command in the project's prepare script. Match upstream supported tool versions. The skill installer neither configures lint nor upgrades/patches its toolchain.
-
-## Working here
+The preset needs Effect-tsgo's patched Oxlint, so keep the patch command in the project's `prepare` script.
 
-| Owner      | Decision                                                                                                                                                                                    |
-| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `src/`     | Flat package structure; rules in `src/rules`, no separate plugin or install-test harness                                                                                                    |
-| `skills/`  | Maintained engineering/design/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/imprecise rules, not inconvenient valid diagnostics |
-| Rule proof | Existing public CLI regression cases, with accepted/rejected controls; no severity/exclusion workaround                                                                                     |
+<details>
+<summary>For agents</summary>
 
-## Rejected shortcuts
+### Decisions
 
-| Candidate                                                | Reason                                                                                                       |
-| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
-| Blanket `unknown` type ban                               | Opaque SDK/framework contracts legitimately need it; narrow/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     |
+| 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:
 
@@ -56,9 +47,17 @@ vp test run tools/coding-standards/src/rules/rules.test.ts
 node tools/coding-standards/src/install.ts
 ```
 
-## Skill inspiration
+### Rejected shortcuts
 
-| Source                                                                                                                                                                                                                       | Used / boundary                                                                                                                                                                                   |
+| 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                                                                                                    |
@@ -70,3 +69,5 @@ node tools/coding-standards/src/install.ts
 | [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.785";
+var version = "0.1.804";
 //#endregion
 //#region src/install.ts
 const cli = pipe(make("deslop-coding-standards", {}, fnUntraced(function* () {

package/dist/oxlint.d.ts

@@ -4098,6 +4098,7 @@ export declare const oxlint: {
     '@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";
@@ -4106,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";

package/dist/oxlint.js

@@ -1,4 +1,4 @@
-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";
+import { $ as fromOption, $n as isNullish$1, A as getSomes, Bn as optimize, C as findFirst, Ct as some, D as flatten, E as flatMap$1, Fn as symbol, G as sort, Gn as hasProperty, H as prepend, Hn as string, I as join, J as get$2, K as take, Kn as isBoolean, L as last, Ln as combine, M as isArrayEmpty, N as isArrayNonEmpty, Nn as byReferenceUnsafe, Pn as equals, Rn as hash, S as filterMap, St as orElse, Tn as NodeInspectSymbol, V as of, W as some$1, Wn as symbol$1, X as remove, Xn as isNotNull, Z as values, Zn as isNotNullish, _ as dropRight, _t as isSome, a as includes, ar as isString, at as all, b as every, bt as match$1, c as startsWith, ct as filter, d as TaggedError, dt as flatten$1, er as isNumber, ft as fromNullishOr, g as dedupe, h as contains$1, i as Order, ir as isReadonlyObject, j as head, k as get$1, lt as firstSomeOf, m as appendAll, mr as dual, mt as getOrElse, n as make$2, o as match, ot as contains, p as append, pt as fromUndefinedOr, q as fromEntries, r as update, s as split, st as exists, t as get$3, ut as flatMap, v as empty, vr as pipe, w as findFirstIndex, wt as zipWith, x as filter$1, xr as pipeArguments, xt as none, y as ensure, yt as map, z as map$1, zn as number } from "./MutableRef-NhSl8G9M.mjs";
 //#region ../../node_modules/.pnpm/effect@4.0.0/node_modules/effect/dist/internal/graph.js
 /** @internal */
 const TypeId = "~effect/Graph";
@@ -668,8 +668,11 @@ function importedMember(input) {
 		source: "effect"
 	}) && (input.propertyName === void 0 || contains(memberName(input.node), input.propertyName));
 }
+function matches(regExp) {
+	return (text) => isSome(pipe(text, match(regExp)));
+}
 function isSchemaOperationName(name) {
-	return /^(?:(?:decode|encode)(?:Unknown)?(?:Effect|Exit|Option|Promise|Result|Sync)|asserts|is)$/u.test(name);
+	return matches(/^(?:(?:decode|encode)(?:Unknown)?(?:Effect|Exit|Option|Promise|Result|Sync)|asserts|is)$/u)(name);
 }
 function isSchemaOperationCall(input) {
 	if (input.node.callee.type !== "MemberExpression" || !importedMember({
@@ -787,7 +790,7 @@ function suspendSeeds(input) {
 	return pipe(suspendedTypeName({
 		context: input.context,
 		node: input.node
-	}), match({
+	}), match$1({
 		onNone: () => seeds,
 		onSome: (name) => prepend(seeds, name)
 	}));
@@ -858,7 +861,7 @@ function testedValue(node) {
 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;
+	if (isNullish$1(element) || element.type === "SpreadElement") return false;
 	return input.context.sourceCode.getText(element) === input.context.sourceCode.getText(input.value);
 }
 function restatesArrayEnsure(input) {
@@ -937,8 +940,7 @@ function enclosingPipes(context, node) {
 		"FunctionDeclaration",
 		"FunctionExpression"
 	], node.type)) return 0;
-	const nested = isPipeCall(context, node.parent) && some$1(node.parent.arguments, (argument) => argument === node);
-	return enclosingPipes(context, node.parent) + (nested ? 1 : 0);
+	return enclosingPipes(context, node.parent) + (isPipeCall(context, node.parent) && some$1(node.parent.arguments, (argument) => argument === node) ? 1 : 0);
 }
 const noDeepPipe = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
@@ -970,10 +972,8 @@ function namedTuple(input) {
 	}))));
 }
 function component(node) {
-	const declared = node.type === "ArrowFunctionExpression" ? void 0 : node.id;
-	const assigned = node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier" ? node.parent.id : void 0;
-	const name = declared ?? assigned;
-	if (name === void 0 || !/^[A-Z]/u.test(name.name) || node.params.length !== 1 || node.body === null) return false;
+	const name = (node.type === "ArrowFunctionExpression" ? void 0 : node.id) ?? (node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier" ? node.parent.id : void 0);
+	if (name === void 0 || !matches(/^[A-Z]/u)(name.name) || node.params.length !== 1 || node.body === null) return false;
 	if (node.body.type === "JSXElement" || node.body.type === "JSXFragment") return true;
 	return node.body.type === "BlockStatement" && some$1(node.body.body, (statement) => statement.type === "ReturnStatement" && (statement.argument?.type === "JSXElement" || statement.argument?.type === "JSXFragment"));
 }
@@ -1102,7 +1102,7 @@ function receiverName(node) {
 	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));
+	return node?.type === "MemberExpression" && contains(memberName(node), "message") && exists(receiverName(node.object), matches(/^(?:e|err|error|failure|cause|exception)$|Error$/iu));
 }
 function expectsMessage(node) {
 	const subject = node.object.type === "MemberExpression" && contains(memberName(node.object), "not") ? node.object.object : node.object;
@@ -1139,7 +1139,7 @@ function hasUnusedSetter(input) {
 	const declaration = input.node.parent;
 	if (declaration.type !== "VariableDeclarator" || declaration.id.type !== "ArrayPattern") return false;
 	const setter = declaration.id.elements[1];
-	if (isNullish(setter)) return true;
+	if (isNullish$1(setter)) return true;
 	if (setter.type !== "Identifier") return false;
 	return pipe(variableFromScope({
 		name: setter.name,
@@ -1212,10 +1212,10 @@ function check(input) {
 		subject: input.node.right
 	})]), map(of));
 }
-function report(input) {
+function report$1(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;
+	if (predicate?.type !== "TSTypePredicate" || predicate.asserts || predicate.parameterName.type !== "Identifier" || isNullish$1(returned)) return;
 	const name = pipe(check({
 		name: predicate.parameterName.name,
 		node: returned
@@ -1252,19 +1252,19 @@ function report(input) {
 const noHandWrittenGuard = defineRule({
 	create: (context) => ({
 		ArrowFunctionExpression: (node) => {
-			report({
+			report$1({
 				context,
 				node
 			});
 		},
 		FunctionDeclaration: (node) => {
-			report({
+			report$1({
 				context,
 				node
 			});
 		},
 		FunctionExpression: (node) => {
-			report({
+			report$1({
 				context,
 				node
 			});
@@ -1367,6 +1367,13 @@ const nativeMethods = [
 	"values",
 	"with"
 ];
+function freshRegExpFlags(input) {
+	if (input.node.type === "Literal" && hasProperty(input.node, "regex")) return some(pipe(input.context.sourceCode.getText(input.node), split("/"), last));
+	if (input.node.type !== "NewExpression" && input.node.type !== "CallExpression" || input.node.callee.type !== "Identifier" || input.node.callee.name !== "RegExp") return none();
+	const flags = input.node.arguments[1];
+	if (flags === void 0) return some(some(""));
+	return some(flags.type === "Literal" && isString(flags.value) ? some(flags.value) : none());
+}
 const noNativeMethodCall = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
 		if (node.callee.type !== "MemberExpression" || node.callee.object.type === "Identifier" && (node.callee.object.name === "path" || isImportBinding({
@@ -1375,6 +1382,17 @@ const noNativeMethodCall = defineRule({
 			source: /^(?:effect(?:\/|$)|@effect\/)/u
 		}))) return;
 		const receiver = node.callee.object;
+		const regExpFlags = freshRegExpFlags({
+			context,
+			node: receiver
+		});
+		if (isSome(regExpFlags) && exists(memberName(node.callee), (name) => name === "test" || name === "exec" && exists(flatten$1(regExpFlags), (flags) => !pipe(flags, includes("g"))))) {
+			context.report({
+				message: "Match with String.match, which returns an Option, instead of a native RegExp method.",
+				node: node.callee
+			});
+			return;
+		}
 		pipe(memberName(node.callee), filter((name) => contains$1(nativeMethods, name)), filter((name) => !contains$1([
 			"entries",
 			"keys",
@@ -1389,6 +1407,50 @@ const noNativeMethodCall = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-nullish-ternary.ts
+const nullishPredicates = [
+	"isNotNull",
+	"isNotNullish",
+	"isNotUndefined",
+	"isNull",
+	"isNullish",
+	"isUndefined"
+];
+function isNullish(input) {
+	if (input.node.type === "Literal") return input.node.value === null;
+	return input.node.type === "Identifier" && input.node.name === "undefined";
+}
+function testsNullish(input) {
+	if (input.node.type === "UnaryExpression" && input.node.operator === "!") return testsNullish({
+		context: input.context,
+		node: input.node.argument
+	});
+	if (input.node.type === "BinaryExpression" && (input.node.operator === "===" || input.node.operator === "!==")) return isNullish({
+		context: input.context,
+		node: input.node.left
+	}) || isNullish({
+		context: input.context,
+		node: input.node.right
+	});
+	return input.node.type === "CallExpression" && input.node.callee.type === "MemberExpression" && importedMember({
+		context: input.context,
+		importedName: "Predicate",
+		node: input.node.callee
+	}) && exists(memberName(input.node.callee), (name) => contains$1(nullishPredicates, name));
+}
+const noNullishTernary = defineRule({
+	create: (context) => ({ ConditionalExpression: (node) => {
+		if (testsNullish({
+			context,
+			node: node.test
+		})) context.report({
+			message: "Use ?? for a default, or Option for a value that may be absent, instead of a nullish ternary.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/no-option-value-access.ts
 function checks(input) {
 	if (input.test.type === "LogicalExpression" && input.test.operator === input.operator) return checks({
@@ -1415,8 +1477,7 @@ function exits(node) {
 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({
+	return some$1(take(parent.body, getOrElse(findFirstIndex(parent.body, (statement) => statement === input.node), () => 0)), (statement) => statement.type === "IfStatement" && exits(statement.consequent) && checks({
 		...input,
 		name: "isNone",
 		operator: "||",
@@ -1620,11 +1681,11 @@ const noRedundantReturnType = defineRule({
 		function exit(node) {
 			const frame = last(get$3(frames));
 			update(frames, dropRight(1));
-			if (node.async || node.generator || isNullish(node.returnType)) return;
+			if (node.async || node.generator || isNullish$1(node.returnType)) return;
 			if (inferredIdentically({
 				context,
 				node,
-				returns: match(frame, {
+				returns: match$1(frame, {
 					onNone: () => empty(),
 					onSome: (top) => top.returns
 				}),
@@ -1642,7 +1703,7 @@ const noRedundantReturnType = defineRule({
 			FunctionExpression: enter,
 			"FunctionExpression:exit": exit,
 			ReturnStatement: (node) => {
-				update(frames, (stack) => pipe(last(stack), match({
+				update(frames, (stack) => pipe(last(stack), match$1({
 					onNone: () => stack,
 					onSome: (top) => append(dropRight(stack, 1), { returns: append(top.returns, node) })
 				})));
@@ -1714,7 +1775,7 @@ const noRedundantUseRefNullType = defineRule({
 const noRedundantVariableAnnotation = defineRule({
 	create: (context) => ({ VariableDeclarator: (node) => {
 		const annotation = node.id.typeAnnotation;
-		if (node.init === null || isNullish(annotation)) return;
+		if (node.init === null || isNullish$1(annotation)) return;
 		if (node.init.type === "ArrayExpression" && isArrayEmpty(node.init.elements)) {
 			context.report({
 				message: "Write Array.empty<T>() instead of annotating an empty array.",
@@ -1781,7 +1842,10 @@ function shippedSchema(input) {
 		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));
+	return pipe(shipped, findFirst((entry) => contains(base, entry.base) && contains(check, entry.check) && isArrayEmpty(rest) && match$1(fromUndefinedOr(entry.only), {
+		onNone: () => value === void 0,
+		onSome: (only) => value?.type === "Literal" && value.value === only
+	})), map((entry) => entry.schema));
 }
 function pipedBase(node) {
 	const parent = node.parent;
@@ -1835,6 +1899,104 @@ const noRenamedImport = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-single-use-value.ts
+const repeating = [
+	"ArrowFunctionExpression",
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"WhileStatement"
+];
+function runsOnce(input) {
+	const node = input.node;
+	const child = input.child;
+	if ((node.type === "ForOfStatement" || node.type === "ForInStatement") && node.right === child || node.type === "IfStatement" && node.test === child || node.type === "ConditionalExpression" && node.test === child || node.type === "LogicalExpression" && node.left === child) return climb({
+		...input,
+		node
+	});
+	if (contains$1(repeating, node.type) || node.type === "IfStatement" || node.type === "ConditionalExpression" || node.type === "LogicalExpression" || node.type === "ChainExpression" || node.type === "SwitchStatement" || node.type === "TryStatement") return false;
+	return climb({
+		...input,
+		node
+	});
+}
+function climb(input) {
+	if (input.node === input.statement) return true;
+	if (isNullish$1(input.node.parent)) return false;
+	return runsOnce({
+		child: input.node,
+		node: input.node.parent,
+		statement: input.statement
+	});
+}
+function insideConditional(input) {
+	if (input.node === input.statement) return false;
+	if (input.node.type === "ConditionalExpression") return true;
+	return isNotNullish(input.node.parent) && insideConditional({
+		...input,
+		node: input.node.parent
+	});
+}
+function candidate(node) {
+	const declaration = node.parent;
+	const init = node.init;
+	return declaration.type === "VariableDeclaration" && declaration.kind === "const" && declaration.declarations.length === 1 && declaration.parent.type === "BlockStatement" && node.id.type === "Identifier" && node.id.typeAnnotation === null && init !== null && !contains$1(["ArrowFunctionExpression", "FunctionExpression"], init.type) && !(init.type === "Literal" && !hasProperty(init, "regex")) && !(init.type === "TemplateLiteral" && isArrayEmpty(init.expressions));
+}
+function report(input) {
+	const declaration = input.node.parent;
+	const init = input.node.init;
+	if (declaration.type !== "VariableDeclaration" || declaration.parent.type !== "BlockStatement" || input.node.id.type !== "Identifier" || init === null || pipe(input.context.sourceCode.getText(init), includes("\n"))) return;
+	const statements = declaration.parent.body;
+	const name = input.node.id.name;
+	pipe(findFirstIndex(statements, (statement) => statement === declaration), flatMap((index) => get$1(statements, index + 1)), flatMap((next) => pipe(variableFromScope({
+		name,
+		scope: input.context.sourceCode.getScope(input.node)
+	}), map((variable) => filter$1(variable.references, (reference) => reference.isRead())), filter((reads) => reads.length === 1), flatMap(head), map((reference) => reference.identifier), filter((read) => read.range[0] >= next.range[0] && read.range[1] <= next.range[1] && climb({
+		node: read,
+		statement: next
+	}) && !(init.type === "ConditionalExpression" && insideConditional({
+		node: read,
+		statement: next
+	})) && !some$1(input.effects, (effect) => effect.range[0] >= next.range[0] && effect.range[1] <= read.range[0])))), map(() => {
+		input.context.report({
+			message: "Inline this value into the next statement, its only use.",
+			node: input.node
+		});
+	}));
+}
+const noSingleUseValue = defineRule({
+	create: (context) => {
+		const effects = make$2(empty());
+		const candidates = make$2(empty());
+		function effect(node) {
+			update(effects, append(node));
+		}
+		return {
+			AssignmentExpression: effect,
+			AwaitExpression: effect,
+			CallExpression: effect,
+			NewExpression: effect,
+			"Program:exit": () => {
+				for (const node of get$3(candidates)) report({
+					context,
+					effects: get$3(effects),
+					node
+				});
+			},
+			TaggedTemplateExpression: effect,
+			UpdateExpression: effect,
+			VariableDeclarator: (node) => {
+				if (candidate(node)) update(candidates, append(node));
+			},
+			YieldExpression: effect
+		};
+	},
+	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;
@@ -1879,7 +2041,7 @@ function forwardedCall(input) {
 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 (isArrayEmpty(names) || names.length !== node.params.length || isNullish$1(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,
@@ -1904,8 +2066,7 @@ function unexportedBindingName(node) {
 }
 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;
+	if (input.node.async || input.node.generator || input.node.returnType?.typeAnnotation.type === "TSTypePredicate" || isArrayEmpty(names) || names.length !== input.node.params.length || returnedExpression(input.node)?.type !== "CallExpression") return false;
 	return pipe(unexportedBindingName(input.node), flatMap((name) => variableFromScope({
 		name,
 		scope: input.context.sourceCode.getScope(input.node)
@@ -2061,11 +2222,11 @@ const noUndestructuredUseState = defineRule({
 //#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({
+		for (const comment of context.sourceCode.getAllComments()) if (matches(/^\s*(?:eslint|oxlint)-disable\S*\s(?:(?!\s--\s).)*\bsort-keys\b/u)(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({
+		else if (matches(/^\s*(?:eslint-disable|oxlint-disable|@effect-diagnostics)/u)(comment.value) && !matches(/\s--\s*\S/u)(comment.value)) context.report({
 			message: "Give this disable a `-- reason`.",
 			node: comment
 		});
@@ -2142,7 +2303,7 @@ function schemaDefinitionMember(node) {
 	return none();
 }
 function isSchemaDefinitionName(name) {
-	return !isSchemaOperationName(name) && !/^(?:is|to)[A-Z]/u.test(name) && !/^makeFilter(?:Group)?$/u.test(name);
+	return !isSchemaOperationName(name) && !matches(/^(?:is|to)[A-Z]/u)(name) && !matches(/^makeFilter(?:Group)?$/u)(name);
 }
 function isSchemaDefinition(input) {
 	if (input.node.type === "CallExpression" && input.node.callee.type === "Identifier" && isImportBinding({
@@ -2181,7 +2342,7 @@ 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.id.type !== "Identifier" || !matches(/^[A-Z]/u)(input.variable.id.name)) return;
 	if (input.variable.init === null || !isSchemaDefinition({
 		context: input.context,
 		node: input.variable.init
@@ -2355,6 +2516,7 @@ const oxlint = defineConfig({
 		"@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",
@@ -2363,6 +2525,7 @@ const oxlint = defineConfig({
 		"@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",
@@ -3046,6 +3209,7 @@ var oxlint_default = definePlugin({
 		"no-let": noLet,
 		"no-native-emptiness-check": noNativeEmptinessCheck,
 		"no-native-method-call": noNativeMethodCall,
+		"no-nullish-ternary": noNullishTernary,
 		"no-option-value-access": noOptionValueAccess,
 		"no-readonly-type-syntax": noReadonlyTypeSyntax,
 		"no-redundant-return-type": noRedundantReturnType,
@@ -3054,6 +3218,7 @@ var oxlint_default = definePlugin({
 		"no-redundant-variable-annotation": noRedundantVariableAnnotation,
 		"no-reinvented-schema": noReinventedSchema,
 		"no-renamed-import": noRenamedImport,
+		"no-single-use-value": noSingleUseValue,
 		"no-stored-schema-operation": noStoredSchemaOperation,
 		"no-switch-statement": noSwitchStatement,
 		"no-trivial-indirection": noTrivialIndirection,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deslop/coding-standards",
-  "version": "0.1.785",
+  "version": "0.1.804",
   "repository": {
     "type": "git",
     "url": "https://github.com/MP281X/deslop",

package/skills/design/SKILL.md

@@ -100,7 +100,7 @@ Touch and mouse can coexist; do not infer capabilities from user-agent strings o
 
 ## Prototype
 
-**Try the question.** Build one rough representative screen/interaction in the existing host with realistic data. Inspect enough to make the trial trustworthy, then let the user try it before merge-readiness work. Label stubs and limits; a conceptual sketch is sufficient only when execution is unnecessary, never proof of working software. Set a short first-preview budget; show a partial result/blocker rather than expanding unseen. No production completeness or polished gallery first.
+**Try the question.** Build one rough representative screen or interaction in the existing host with realistic data. Inspect enough to make the trial trustworthy, then show it to the user before merge-readiness work. Label stubs and limits; a conceptual sketch is sufficient only when execution is unnecessary, never proof of working software. Set a short first-preview budget; show a partial result or blocker rather than expanding unseen. No production completeness or polished gallery first.
 
 **Use the findings.** For layout questions, compare hierarchy or interaction, not color-only variants. Add attempts only for unresolved uncertainty, feedback or an explicit request—no fixed count; a style question can compare style. Keep useful comparisons; discard/rebuild freely and combine compatible strengths, not incompatible mechanisms. Test the weakest assumption while it can change the choice. A settled direction needs no manufactured taste question or exploration round.
 
@@ -108,7 +108,7 @@ Touch and mouse can coexist; do not infer capabilities from user-agent strings o
 
 **Inspect retained UI.** Open actual captures at the sizes needed for the task. Compare related edges, columns, baselines and equivalent controls across rows/screens—not just successful clicks. Use realistic long names/URLs, translated labels, Unicode, missing fields and relevant 0/1/many records at the actual container width. Respect schema/API limits; never add a validation limit to make layout pass. Mix cases across rows. Check selected/focus/error states and scrolling; a clean default row can hide misalignment. Inspect hierarchy, density, legibility and clipping. Exercise the relevant keyboard/touch, narrow/wide, zoom and focus-return journeys; run axe where applicable. A clean scan does not prove contrast or usability. Inspect meaningful video frames and sequence; a playable file is not proof of a good composition. Batch relevant inspection/repairs; recheck affected views rather than restart a whole audit after each micro-edit. Visible misalignment, inconsistent controls or redundant elements remain defects even when types/tests pass; fix them before claiming acceptance.
 
-**Show the design.** Use inspected screenshots for layout and short video for behavior. Compare at consistent sizes with states needed for the decision; no variant switcher just to see the options. Prefer the existing app-owned preview/element feedback. A visual must add spatial or interactive information, not reproduce prose, a file list or a fake runtime screenshot. Link useful existing evidence rather than render another explanation page. Use the user's theme and verify the actual browser color preference. Keep temporary source/services in ignored scratch, preserve useful media and retire settled attempts; persistent previews are opt-in.
+**Show the design.** Use inspected screenshots for layout and short video for behavior. Compare at consistent sizes with states needed for the decision; no variant switcher just to see the options. A visual must add spatial or interactive information, not reproduce prose, a file list or a fake runtime screenshot. Link useful existing evidence rather than render another explanation page. Use the user's theme and verify the actual browser color preference. Preserve useful media and retire settled attempts; persistent previews are opt-in.
 
 **Review surfaces.** Open on the outcome the user needs to judge, with technical detail available on demand. Group by changed behavior, not files or agent stages. A selected example, diagram or diff must reveal its scope; never make curated evidence look like complete coverage. Do not build a custom review dashboard when existing captures and the PR can answer the question. A design-skill edit is not a product-screen change.