@deslop/coding-standards 0.1.1082 → 0.1.1083

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-Cpkiw3Cl.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,36 @@ const take$1 = /*#__PURE__*/ dual(2, (self, n) => {
 	return input.slice(0, clampCount(n, input.length));
 });
 /**
+* 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 +6241,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 +6352,28 @@ globalThis.String;
 */
 const Order = String$2;
 /**
+* 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 +6484,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 +6502,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 +6995,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 { makeEquivalence as $, formatDate as $n, isLessThanOrEqualTo as $t, dedupeWith as A, evaluate as An, isObject as Ar, flatMap$2 as At, flatMap as B, isFailReason as Bn, constTrue as Br, match$4 as Bt, TaggedError as C, causeFail as Cn, isFunction as Cr, succeed as Ct, contains as D, contAll as Dn, isNotUndefined as Dr, exists as Dt, appendAll as E, contA as En, isNotNullish as Er, contains$1 as Et, filter as F, isCause as Fn, isString as Fr, getOrUndefined as Ft, getSomes as G, assignProperty as Gn, identity as Gr, zipWith as Gt, forEach as H, makePrimitive as Hn, constVoid as Hr, orElse as Ht, filterMap as I, isDieReason as In, isTagged as Ir, isNone as It, isArrayNonEmpty as J, setStackTraceLimit as Jn, pipe as Jr, Number$2 as Jt, head as K, internalCall as Kn, memoize as Kr, BigInt$1 as Kt, findFirst as L, isDone as Ln, isUndefined as Lr, isSome as Lt, empty as M, exitFail as Mn, isPropertyKey as Mr, fromNullishOr as Mt, ensure as N, exitFailCause as Nn, isReadonlyObject as Nr, fromUndefinedOr as Nt, containsWith as O, contE as On, isNullish as Or, filter$1 as Ot, every as P, exitSucceed as Pn, isRegExp as Pr, getOrElse as Pt, last as Q, format as Qn, isLessThan as Qt, findFirstIndex as R, isEffect as Rn, isUnknown as Rr, liftThrowable as Rt, Error$1 as S, causeEmpty as Sn, isError as Sr, match$3 as St, append$1 as T, constEmptyAnnotations as Tn, isNotNull as Tr, all as Tt, fromIterable as U, makePrimitiveProto as Un, constant as Ur, some$1 as Ut, flatten as V, isInterruptReason as Vn, constUndefined as Vr, none as Vt, get$1 as W, withFiber as Wn, dual as Wr, toArray$1 as Wt, isReadonlyArrayNonEmpty as X, NodeInspectSymbol as Xn, Prototype as Xr, isGreaterThan as Xt, isCanonicalArrayIndex as Y, BaseProto as Yn, Class$1 as Yr, String$2 as Yt, join as Z, toStringUnknown as Zn, pipeArguments as Zr, isGreaterThanOrEqualTo as Zt, startsWith as _, args as _n, structureKeys as _r, fromOption as _t, takeN as a, CauseImpl as an, symbolRedactable as ar, reduce as at, parse as b, causeCombine as bn, isBigInt as br, isSuccess as bt, make$1 as c, Error$2 as cn, equals as cr, take$1 as ct, Order as d, InterruptorStackTrace as dn, combine as dr, makeEquivalence$1 as dt, make$2 as en, formatJson as er, map as et, includes as f, PipeInspectableProto as fn, hash as fr, map$1 as ft, split as g, Yield as gn, structure as gr, flatMap$1 as gt, replaceAll as h, TaggedError$1 as hn, string as hr, fail as ht, take as i, strictEqual as in, redact as ir, prepend as it, dropRight as j, exitDie as jn, isObjectKeyword as jr, flatten$1 as jt, dedupe as k, done as kn, isNumber as kr, firstSomeOf as kt, update as l, ExitTypeId as ln, symbol as lr, fromEntries as lt, replace as m, StackTraceKey as mn, optimize as mr, values as mt, clear as n, Tuple as nn, formatPropertyKey as nr, matchRight as nt, toArray as o, Die as on, asEquivalence as or, some as ot, match$1 as p, ReasonBase as pn, number as pr, remove as pt, isArrayEmpty as q, getStackTraceLimit as qn, memoizeIdempotent as qr, Date$1 as qt, make as r, make$3 as rn, currentFiberTypeId as rr, of as rt, get as s, Done as sn, byReferenceUnsafe as sr, sort as st, append as t, mapInput as tn, formatPath as tr, match$2 as tt, match as u, Fail as un, array as ur, get$2 as ut, trim as v, causeAddInterrupts as vn, symbol$1 as vr, getOrThrow as vt, taggedEnum as w, causeFromReasons as wn, isIterable as wr, normalize as wt, round as x, causeDie as xn, isBoolean as xr, map$2 as xt, trimEnd as y, causeAnnotate as yn, hasProperty as yr, isFailure as yt, findLast as z, isExit as zn, constFalse as zr, map$3 as zt };