@deslop/coding-standards 0.1.1082 → 0.1.1085

package/README.md

@@ -1,6 +1,6 @@
 # Coding standards
 
-A strict Oxlint preset and an installer for the architecture, engineering, design, testing and review skills. Requires Node 26+.
+A strict Oxlint preset and an installer for the engineering, design and review skills. Requires Node 26+.
 
 ## Install the skills
 
@@ -10,9 +10,9 @@ Run inside a Git repository, including a linked worktree:
 vpx @deslop/coding-standards@latest
 ```
 
-It copies all package-owned skills into the repository's existing `.agents`, `.claude` and `.codex` directories, including their `EVALS.md`. It always writes `.claude`, which Claude Code reads, and writes `.agents` when no `.codex` exists. A refresh replaces only those names; destinations outside the repository or inside global agent configuration are rejected. Other skills, sign-ins, manifests, lockfiles and lint configuration stay unchanged. Edit package sources, then refresh installed copies with the CLI.
+It copies all package-owned skills into the repository's existing `.agents`, `.claude` and `.codex` directories. It always writes `.claude`, which Claude Code reads, and writes `.agents` when no `.codex` exists. A refresh replaces only those names; destinations outside the repository or inside global agent configuration are rejected. Other skills, sign-ins, manifests, lockfiles and lint configuration stay unchanged. Edit package sources, then refresh installed copies with the CLI.
 
-Use architecture for mechanisms and ownership, engineering for code, design for visible behavior, testing for useful proof and review for independent critique and cleanup. Refer to another skill by name, not its installation path. Personal orchestration, delivery, machine commands and reply preferences stay outside this package.
+Use engineering for mechanisms, code, tests and proof, design for visible behavior and review for independent critique and cleanup. Refer to another skill by name, not its installation path. Personal orchestration, delivery, machine commands and reply preferences stay outside this package.
 
 ## Use the lint preset
 
@@ -39,9 +39,9 @@ The preset needs Effect-tsgo's patched Oxlint, so keep the patch command in the
 | Owner      | Decision                                                                                                                                                                                                                                                                                                                                                                      |
 | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `src/`     | Flat package structure; rules in `src/rules`, no separate plugin or install-test harness                                                                                                                                                                                                                                                                                      |
-| `skills/`  | Maintained architecture, engineering, design, testing and review sources; refresh repository copies from the TypeScript CLI, no build needed                                                                                                                                                                                                                                  |
+| `skills/`  | Maintained engineering, design and review 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                                                                                                                                                                                                                                                                |
+| Rule proof | Public CLI cases with accepted and rejected inputs; no severity or exclusion workaround                                                                                                                                                                                                                                                                                       |
 
 With workspace dependencies installed, from the repository root:
 
@@ -66,7 +66,7 @@ node tools/coding-standards/src/install.ts
 | [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) and [Vercel design guidelines](https://vercel.com/design/guidelines)                                                                                                                                                                                                                              | Task-led composition, copy and interaction contracts (targets, focus, URL state, forms); creative mode keeps grounding and the generated-default list, not a studio persona                       |
+| [Anthropic frontend-design](https://github.com/anthropics/skills/tree/main/skills/frontend-design) and [Vercel design guidelines](https://vercel.com/design/guidelines)                                                                                                                                                                                                                              | Task-led composition, copy and interaction contracts (targets, focus, URL state, forms); Critique keeps the generated-default list, not a studio persona                                          |
 | [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                                                                                                         |
 | [Interface Craft](https://www.interfacecraft.dev/library), the user's licensed library                                                                                                                                                                                                                                                                                                               | Before-the-first-draft steps, range and depth, agent-run tuning, the four-pass critique, optical, color, type and motion values; ideas adapted in our words, no files copied                      |
@@ -74,7 +74,7 @@ node tools/coding-standards/src/install.ts
 
 Additional sources for this refinement:
 
-- [OpenClaw test audit](https://github.com/openclaw/openclaw/blob/main/.agents/skills/test-audit/SKILL.md): distinct regression protection and deletion of tautological tests; retain independent boundary contracts.
+- [OpenClaw test audit](https://github.com/openclaw/openclaw/blob/main/.agents/skills/test-audit/SKILL.md): deletion of tautological tests; retain independent boundary contracts.
 - [Trail of Bits](https://github.com/trailofbits/skills): reproduce the strongest reachable counterexample and inspect variants of a known root cause; no routine security-audit machinery.
 - [Bret Victor](https://worrydream.com/ExplorableExplanations/) and [Nicky Case](https://blog.ncase.me/how-i-make-an-explorable-explanation/): concrete cause and consequence, with optional exploration rather than mandatory navigation.
 - [Taste skill](https://github.com/Leonxlnx/taste-skill/tree/a60a36dc2bb3bb77ccf17f2f62041f5ca8a458b9): real subject inventory and screenshot critique; no mandatory image, motion or component quotas.
@@ -83,6 +83,10 @@ Additional sources for this refinement:
 - [Animated sprites](https://github.com/elithrar/dotfiles/tree/main/.agents/skills/animated-sprites): separate structural validity from perceptual motion and actual timing; no character assets required.
 - [pstack correct](https://github.com/cursor/plugins/blob/e5136d82418d2db3165ea1050d17577cd618cc05/pstack/skills/correct/SKILL.md), [caller migration](https://github.com/cursor/plugins/blob/e5136d82418d2db3165ea1050d17577cd618cc05/pstack/skills/principle-migrate-callers-then-delete-legacy-apis/SKILL.md) and [design red flags](https://github.com/cursor/plugins/blob/e5136d82418d2db3165ea1050d17577cd618cc05/pstack/skills/architect/references/design-red-flags.md): engineering's Patterns, with a canonical example per shape, whole-repository pattern changes and enforcement of repeated corrections above prose; no rule table beside the Patterns rows, no expiry dates on exceptions.
 
-These are selectively adapted ideas, not imported frameworks. Concrete behavior, existing stack and settled user decisions govern the maintained skills. Source inspection and drafted evaluation criteria do not establish a model-quality improvement.
+- [obra/superpowers](https://github.com/obra/superpowers/tree/bb92a77741419a4ab5f06e711a283343f1ada0c3), [Matt Pocock](https://github.com/mattpocock/skills/tree/49dd158d1076134a641b33efb035946536778336) and [pstack](https://github.com/cursor/plugins/tree/09d06eb4b97a1020ab31e84030e38baf1099c7dc/pstack): recipes over prohibitions, requirement-to-proof mapping, domain-concept search, shrunk reproductions, the shared premise after two failed fixes, a behavior capture before refactors and three similar lines over an abstraction; no approval gates, test-first rituals or verification quotas.
+- [Felix Rieseberg, How to be more ambitious](https://felixrieseberg.com/how-to-be-more-ambitious-a-tutorial-for-humans-with-models/): adversarial review by activity, never persona, from raw evidence, and the expert's unrequested check.
+- [Emil Kowalski's animate skill](https://github.com/emilkowalski/skills/tree/2d228630ba1446365f614a108cb8252f1feda202/skills/animate) and [Taste v2](https://github.com/Leonxlnx/taste-skill/tree/f624f37a8c650b9cc550253104925efe4c8de246): a slower pace for explanatory motion and measured overflow, clipping and font checks before visual critique.
+
+These are selectively adapted ideas, not imported frameworks. Concrete behavior, existing stack and settled user decisions govern the maintained skills. Source inspection does not establish a model-quality improvement.
 
 </details>

package/dist/{MutableList-BCF17jPH.mjs → MutableList-NTBI6AHW.mjs}

@@ -3283,7 +3283,7 @@ const String$2 = /*#__PURE__*/ make$2((self, that) => self < that ? -1 : 1);
 * @category instances
 * @since 4.0.0
 */
-const Number$1 = /*#__PURE__*/ make$2((self, that) => {
+const Number$2 = /*#__PURE__*/ make$2((self, that) => {
 	if (globalThis.Number.isNaN(self) && globalThis.Number.isNaN(that)) return 0;
 	if (globalThis.Number.isNaN(self)) return -1;
 	if (globalThis.Number.isNaN(that)) return 1;
@@ -3317,7 +3317,7 @@ const Number$1 = /*#__PURE__*/ make$2((self, that) => {
 * @category instances
 * @since 4.0.0
 */
-const BigInt = /*#__PURE__*/ make$2((self, that) => self < that ? -1 : 1);
+const BigInt$1 = /*#__PURE__*/ make$2((self, that) => self < that ? -1 : 1);
 /**
 * Transforms an `Order` on type `A` into an `Order` on type `B` by providing a function that
 * maps values of type `B` to values of type `A`.
@@ -3383,7 +3383,7 @@ const mapInput = /*#__PURE__*/ dual(2, (self, f) => make$2((b1, b2) => self(f(b1
 * @category instances
 * @since 2.0.0
 */
-const Date$1 = /*#__PURE__*/ mapInput(Number$1, (date) => date.getTime());
+const Date$1 = /*#__PURE__*/ mapInput(Number$2, (date) => date.getTime());
 /**
 * Checks whether one value is strictly less than another according to the given order.
 *
@@ -3656,7 +3656,7 @@ const isSome = isSome$1;
 * @category pattern matching
 * @since 2.0.0
 */
-const match$3 = /*#__PURE__*/ dual(2, (self, { onNone, onSome }) => isNone(self) ? onNone() : onSome(self.value));
+const match$4 = /*#__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`.
 *
@@ -4544,7 +4544,7 @@ const map$2 = /*#__PURE__*/ dual(2, (self, f) => isSuccess(self) ? succeed(f(sel
 * @category pattern matching
 * @since 2.0.0
 */
-const match$2 = /*#__PURE__*/ dual(2, (self, { onFailure, onSuccess }) => isFailure(self) ? onFailure(self.failure) : onSuccess(self.success));
+const match$3 = /*#__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`.
 *
@@ -5023,7 +5023,7 @@ const ensure = (self) => Array$1.isArray(self) ? self : [self];
 * @category pattern matching
 * @since 2.0.0
 */
-const match$1 = /*#__PURE__*/ dual(2, (self, { onEmpty, onNonEmpty }) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(self) : onEmpty());
+const match$2 = /*#__PURE__*/ dual(2, (self, { onEmpty, onNonEmpty }) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(self) : onEmpty());
 /**
 * Pattern-matches on an array from the right, providing all elements except the
 * last and the last element separately.
@@ -5408,6 +5408,76 @@ const take$1 = /*#__PURE__*/ dual(2, (self, n) => {
 	return input.slice(0, clampCount(n, input.length));
 });
 /**
+* Takes elements from the start while the predicate holds, stopping at the
+* first element that fails.
+*
+* **When to use**
+*
+* Use to keep the leading elements of an iterable while each element satisfies
+* a predicate, returning the retained prefix as an array.
+*
+* **Details**
+*
+* Supports refinements for type narrowing. The predicate receives
+* `(element, index)`.
+*
+* **Example** (Taking while condition holds)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.takeWhile([1, 3, 2, 4, 1, 2], (x) => x < 4) // => [1, 3, 2]
+* ```
+*
+* @see {@link take} for keeping a fixed number of leading elements
+* @see {@link dropWhile} for removing the matching prefix and keeping the rest
+* @see {@link span} for splitting the matching prefix from the remaining elements
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const takeWhile = /*#__PURE__*/ dual(2, (self, predicate) => {
+	let i = 0;
+	const out = [];
+	for (const a of self) {
+		if (!predicate(a, i)) break;
+		out.push(a);
+		i++;
+	}
+	return out;
+});
+/**
+* Removes the last `n` elements, creating a new array.
+*
+* **When to use**
+*
+* Use to remove the last `n` elements from an iterable.
+*
+* **Details**
+*
+* `n` is rounded down and clamped to `[0, length]`. `NaN` is treated as `0`.
+*
+* **Example** (Dropping from the end)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.dropRight([1, 2, 3, 4, 5], 2) // => [1, 2, 3]
+* ```
+*
+* @see {@link drop} — remove from the start
+* @see {@link takeRight} — keep from the end
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const dropRight = /*#__PURE__*/ dual(2, (self, n) => {
+	const input = fromIterable(self);
+	return input.slice(0, input.length - clampCount(n, input.length));
+});
+/**
 * Returns the index of the first element matching the predicate, wrapped in an
 * `Option`.
 *
@@ -6211,6 +6281,96 @@ const Error$1 = Error$2;
 * @since 2.0.0
 */
 const TaggedError = TaggedError$1;
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Number.js
+/**
+* Exposes the global number constructor.
+*
+* **When to use**
+*
+* Use to access native JavaScript numeric coercion from the Effect module
+* namespace.
+*
+* **Gotchas**
+*
+* This follows native `Number` coercion rules, including empty strings
+* becoming `0` and invalid numeric strings becoming `NaN`.
+*
+* @see {@link parse} for parsing strings into an `Option`
+*
+* **Example** (Coercing values to numbers)
+*
+* ```ts import.meta.vitest
+* import { Number as N } from "effect"
+*
+* N.Number("42") // => 42
+* N.Number("3.14") // => 3.14
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const Number$1 = globalThis.Number;
+/**
+* Parses a `number` from a `string` safely using the `Number()` function.
+* The following special string values are supported: "NaN", "Infinity", "-Infinity".
+*
+* **When to use**
+*
+* Use to parse numeric text without throwing on invalid input.
+*
+* **Example** (Parsing numbers from strings)
+*
+* ```ts import.meta.vitest
+* import { Number, Option } from "effect"
+*
+* Number.parse("42") // => Option.some(42)
+* Number.parse("3.14") // => Option.some(3.14)
+* Number.parse("NaN") // => Option.some(NaN)
+* Number.parse("Infinity") // => Option.some(Infinity)
+* Number.parse("-Infinity") // => Option.some(-Infinity)
+* Number.parse("not a number") // => Option.none()
+* ```
+*
+* @see {@link Number} for native constructor coercion
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const parse = (s) => {
+	if (s === "NaN") return some$1(NaN);
+	if (s === "Infinity") return some$1(Infinity);
+	if (s === "-Infinity") return some$1(-Infinity);
+	if (s.trim() === "") return none();
+	const n = Number$1(s);
+	return Number$1.isNaN(n) ? none() : some$1(n);
+};
+/**
+* Returns the number rounded with the given precision.
+*
+* **When to use**
+*
+* Use to round a number to a fixed number of decimal places.
+*
+* **Example** (Rounding with precision)
+*
+* ```ts import.meta.vitest
+* import { Number } from "effect"
+*
+* Number.round(1.1234, 2) // => 1.12
+* Number.round(1.567, 2) // => 1.57
+* ```
+*
+* @stability stable
+* @category math
+* @since 3.8.0
+*/
+const round = /*#__PURE__*/ dual(2, (self, precision) => {
+	const factor = Math.pow(10, precision);
+	return Math.round(self * factor) / factor;
+});
 globalThis.String;
 /**
 * Provides an `Order` instance for comparing strings using lexicographic
@@ -6232,6 +6392,45 @@ globalThis.String;
 */
 const Order = String$2;
 /**
+* Converts a string to uppercase.
+*
+* **Example** (Converting strings to uppercase)
+*
+* ```ts import.meta.vitest
+* import { pipe, String } from "effect"
+*
+* pipe("a", String.toUpperCase) // => "A"
+* String.toUpperCase("hello") // => "HELLO"
+* ```
+*
+* @stability stable
+* @category transforming
+* @since 2.0.0
+*/
+const toUpperCase = (self) => self.toUpperCase();
+/**
+* Replaces matches in a string using `String.prototype.replace`.
+*
+* **Details**
+*
+* String search values and non-global regular expressions replace the first
+* match; global regular expressions replace every match.
+*
+* **Example** (Replacing a substring)
+*
+* ```ts import.meta.vitest
+* import { pipe, String } from "effect"
+*
+* pipe("abc", String.replace("b", "d")) // => "adc"
+* pipe("hello world", String.replace("world", "Effect")) // => "hello Effect"
+* ```
+*
+* @stability stable
+* @category transforming
+* @since 2.0.0
+*/
+const replace = (searchValue, replaceValue) => (self) => self.replace(searchValue, replaceValue);
+/**
 * Removes whitespace from both ends of a string.
 *
 * **Example** (Trimming whitespace)
@@ -6342,7 +6541,7 @@ const startsWith = (searchString, position) => (self) => self.startsWith(searchS
 * @category searching
 * @since 2.0.0
 */
-const match = (regExp) => (self) => fromNullOr(self.match(regExp));
+const match$1 = (regExp) => (self) => fromNullOr(self.match(regExp));
 /**
 * Replaces all occurrences of a substring or pattern in a string.
 *
@@ -6360,6 +6559,30 @@ const match = (regExp) => (self) => fromNullOr(self.match(regExp));
 * @since 2.0.0
 */
 const replaceAll = (searchValue, replaceValue) => (self) => self.replaceAll(searchValue, replaceValue);
+globalThis.Boolean;
+/**
+* Chooses between two lazy branches based on a boolean value.
+*
+* **When to use**
+*
+* Use to choose between two lazy branches based on a boolean value.
+*
+* **Example** (Pattern matching on booleans)
+*
+* ```ts import.meta.vitest
+* import { Boolean } from "effect"
+*
+* Boolean.match(true, {
+*   onFalse: () => "It's false!",
+*   onTrue: () => "It's true!"
+* }) // => "It's true!"
+* ```
+*
+* @stability stable
+* @category pattern matching
+* @since 2.0.0
+*/
+const match = /*#__PURE__*/ dual(2, (value, options) => value ? options.onTrue() : options.onFalse());
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/MutableRef.js
 const TypeId = "~effect/MutableRef";
@@ -6829,4 +7052,4 @@ const toArrayN = (self, n) => {
 */
 const toArray = (self) => toArrayN(self, self.length);
 //#endregion
-export { prepend as $, redact as $n, strictEqual as $t, filter as A, isCause as An, isString as Ar, getOrUndefined as At, getSomes as B, assignProperty as Bn, identity as Br, zipWith as Bt, contains as C, contE as Cn, isNullish as Cr, filter$1 as Ct, empty as D, exitFail as Dn, isPropertyKey as Dr, fromNullishOr as Dt, dedupeWith as E, exitDie as En, isObjectKeyword as Er, flatten$1 as Et, flatMap as F, isFailReason as Fn, constTrue as Fr, match$3 as Ft, isReadonlyArrayNonEmpty as G, NodeInspectSymbol as Gn, Prototype as Gr, isGreaterThan as Gt, isArrayEmpty as H, getStackTraceLimit as Hn, memoizeIdempotent as Hr, Date$1 as Ht, flatten as I, isInterruptReason as In, constUndefined as Ir, none as It, makeEquivalence as J, formatDate as Jn, isLessThanOrEqualTo as Jt, join as K, toStringUnknown as Kn, pipeArguments as Kr, isGreaterThanOrEqualTo as Kt, forEach as L, makePrimitive as Ln, constVoid as Lr, orElse as Lt, findFirst as M, isDone as Mn, isUndefined as Mr, isSome as Mt, findFirstIndex as N, isEffect as Nn, isUnknown as Nr, liftThrowable as Nt, ensure as O, exitFailCause as On, isReadonlyObject as Or, fromUndefinedOr as Ot, findLast as P, isExit as Pn, constFalse as Pr, map$3 as Pt, of as Q, currentFiberTypeId as Qn, make$3 as Qt, fromIterable as R, makePrimitiveProto as Rn, constant as Rr, some$1 as Rt, appendAll as S, contAll as Sn, isNotUndefined as Sr, exists as St, dedupe as T, evaluate as Tn, isObject as Tr, flatMap$2 as Tt, isArrayNonEmpty as U, setStackTraceLimit as Un, pipe as Ur, Number$1 as Ut, head as V, internalCall as Vn, memoize as Vr, BigInt as Vt, isCanonicalArrayIndex as W, BaseProto as Wn, Class$1 as Wr, String$2 as Wt, match$1 as X, formatPath as Xn, mapInput as Xt, map as Y, formatJson as Yn, make$2 as Yt, matchRight as Z, formatPropertyKey as Zn, Tuple as Zt, trimEnd as _, causeEmpty as _n, isError as _r, match$2 as _t, takeN as a, Fail as an, array as ar, get$2 as at, taggedEnum as b, constEmptyAnnotations as bn, isNotNull as br, all as bt, make$1 as c, ReasonBase as cn, number as cr, remove as ct, includes as d, Yield as dn, structure as dr, flatMap$1 as dt, CauseImpl as en, symbolRedactable as er, reduce as et, match as f, args as fn, structureKeys as fr, fromOption as ft, trim as g, causeDie as gn, isBoolean as gr, map$2 as gt, startsWith as h, causeCombine as hn, isBigInt as hr, isSuccess as ht, take as i, ExitTypeId as in, symbol as ir, fromEntries as it, filterMap as j, isDieReason as jn, isTagged as jr, isNone as jt, every as k, exitSucceed as kn, isRegExp as kr, getOrElse as kt, update as l, StackTraceKey as ln, optimize as lr, values as lt, split as m, causeAnnotate as mn, hasProperty as mr, isFailure as mt, clear as n, Done as nn, byReferenceUnsafe as nr, sort as nt, toArray as o, InterruptorStackTrace as on, combine as or, makeEquivalence$1 as ot, replaceAll as p, causeAddInterrupts as pn, symbol$1 as pr, getOrThrow as pt, last as q, format as qn, isLessThan as qt, make as r, Error$2 as rn, equals as rr, take$1 as rt, get as s, PipeInspectableProto as sn, hash as sr, map$1 as st, append as t, Die as tn, asEquivalence as tr, some as tt, Order as u, TaggedError$1 as un, string as ur, fail as ut, Error$1 as v, causeFail as vn, isFunction as vr, succeed as vt, containsWith as w, done as wn, isNumber as wr, firstSomeOf as wt, append$1 as x, contA as xn, isNotNullish as xr, contains$1 as xt, TaggedError as y, causeFromReasons as yn, isIterable as yr, normalize as yt, get$1 as z, withFiber as zn, dual as zr, toArray$1 as zt };
+export { last as $, toStringUnknown as $n, pipeArguments as $r, isGreaterThanOrEqualTo as $t, dedupe as A, contE as An, isNullish as Ar, filter$1 as At, findLast as B, isEffect as Bn, isUnknown as Br, liftThrowable as Bt, Error$1 as C, causeDie as Cn, isBoolean as Cr, map$2 as Ct, appendAll as D, constEmptyAnnotations as Dn, isNotNull as Dr, all as Dt, append$1 as E, causeFromReasons as En, isIterable as Er, normalize as Et, every as F, exitFailCause as Fn, isReadonlyObject as Fr, fromUndefinedOr as Ft, get$1 as G, makePrimitiveProto as Gn, constant as Gr, some$1 as Gt, flatten as H, isFailReason as Hn, constTrue as Hr, match$4 as Ht, filter as I, exitSucceed as In, isRegExp as Ir, getOrElse as It, isArrayEmpty as J, internalCall as Jn, memoize as Jr, BigInt$1 as Jt, getSomes as K, withFiber as Kn, dual as Kr, toArray$1 as Kt, filterMap as L, isCause as Ln, isString as Lr, getOrUndefined as Lt, dropRight as M, evaluate as Mn, isObject as Mr, flatMap$2 as Mt, empty as N, exitDie as Nn, isObjectKeyword as Nr, flatten$1 as Nt, contains as O, contA as On, isNotNullish as Or, contains$1 as Ot, ensure as P, exitFail as Pn, isPropertyKey as Pr, fromNullishOr as Pt, join as Q, NodeInspectSymbol as Qn, Prototype as Qr, isGreaterThan as Qt, findFirst as R, isDieReason as Rn, isTagged as Rr, isNone as Rt, round as S, causeCombine as Sn, isBigInt as Sr, isSuccess as St, taggedEnum as T, causeFail as Tn, isFunction as Tr, succeed as Tt, forEach as U, isInterruptReason as Un, constUndefined as Ur, none as Ut, flatMap as V, isExit as Vn, constFalse as Vr, map$3 as Vt, fromIterable as W, makePrimitive as Wn, constVoid as Wr, orElse as Wt, isCanonicalArrayIndex as X, setStackTraceLimit as Xn, pipe as Xr, Number$2 as Xt, isArrayNonEmpty as Y, getStackTraceLimit as Yn, memoizeIdempotent as Yr, Date$1 as Yt, isReadonlyArrayNonEmpty as Z, BaseProto as Zn, Class$1 as Zr, String$2 as Zt, startsWith as _, TaggedError$1 as _n, string as _r, fail as _t, takeN as a, make$3 as an, currentFiberTypeId as ar, prepend as at, trimEnd as b, causeAddInterrupts as bn, symbol$1 as br, getOrThrow as bt, make$1 as c, Die as cn, asEquivalence as cr, sort as ct, Order as d, ExitTypeId as dn, symbol as dr, fromEntries as dt, isLessThan as en, format as er, makeEquivalence as et, includes as f, Fail as fn, array as fr, get$2 as ft, split as g, StackTraceKey as gn, optimize as gr, values as gt, replaceAll as h, ReasonBase as hn, number as hr, remove as ht, take as i, Tuple as in, formatPropertyKey as ir, of as it, dedupeWith as j, done as jn, isNumber as jr, firstSomeOf as jt, containsWith as k, contAll as kn, isNotUndefined as kr, exists as kt, update as l, Done as ln, byReferenceUnsafe as lr, take$1 as lt, replace as m, PipeInspectableProto as mn, hash as mr, map$1 as mt, clear as n, make$2 as nn, formatJson as nr, match$2 as nt, toArray as o, strictEqual as on, redact as or, reduce as ot, match$1 as p, InterruptorStackTrace as pn, combine as pr, makeEquivalence$1 as pt, head as q, assignProperty as qn, identity as qr, zipWith as qt, make as r, mapInput as rn, formatPath as rr, matchRight as rt, get as s, CauseImpl as sn, symbolRedactable as sr, some as st, append as t, isLessThanOrEqualTo as tn, formatDate as tr, map as tt, match as u, Error$2 as un, equals as ur, takeWhile as ut, toUpperCase as v, Yield as vn, structure as vr, flatMap$1 as vt, TaggedError as w, causeEmpty as wn, isError as wr, match$3 as wt, parse as x, causeAnnotate as xn, hasProperty as xr, isFailure as xt, trim as y, args as yn, structureKeys as yr, fromOption as yt, findFirstIndex as z, isDone as zn, isUndefined as zr, isSome as zt };