@deslop/coding-standards 0.1.1083 → 0.1.1086

package/README.md

@@ -1,24 +1,11 @@
-# Coding standards
+# @deslop/coding-standards
 
-A strict Oxlint preset and an installer for the engineering, design and review skills. Requires Node 26+.
-
-## Install the skills
-
-Run inside a Git repository, including a linked worktree:
-
-```bash
-vpx @deslop/coding-standards@latest
-```
-
-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 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
+A strict Oxlint preset, and the engineering, design and review skills for Claude Code and Codex.
 
 ```bash
+vpx @deslop/coding-standards@latest                   # copy the skills into the repository's .claude, .codex or .agents
 vp add -D @deslop/coding-standards @effect/tsgo
-vp exec effect-tsgo patch --no-typescript --oxlint
+vp exec effect-tsgo patch --no-typescript --oxlint    # the preset needs the patched Oxlint; keep this in `prepare`
 ```
 
 ```ts
@@ -29,64 +16,4 @@ import {oxlint} from '@deslop/coding-standards'
 export default defineConfig({lint: {extends: [oxlint]}})
 ```
 
-The preset needs Effect-tsgo's patched Oxlint, so keep the patch command in the project's `prepare` script. Its fixes leave redundant parentheses and blank lines for the formatter, so the project's fix script runs `vp fmt` after `vp check --fix`, even when diagnostics remain, and exits with the status of the check.
-
-<details>
-<summary>For agents</summary>
-
-### Decisions
-
-| Owner      | Decision                                                                                                                                                                                                                                                                                                                                                                      |
-| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `src/`     | Flat package structure; rules in `src/rules`, no separate plugin or install-test harness                                                                                                                                                                                                                                                                                      |
-| `skills/`  | Maintained engineering, design and 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 | Public CLI cases with accepted and rejected inputs; no severity or exclusion workaround                                                                                                                                                                                                                                                                                       |
-
-With workspace dependencies installed, from the repository root:
-
-```bash
-vp test run tools/coding-standards/src/rules/rules.test.ts
-node tools/coding-standards/src/install.ts
-```
-
-### Rejected shortcuts
-
-| Candidate                                                | Reason                                                                                                              |
-| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
-| Blanket `unknown` type ban                               | Opaque SDK and framework contracts legitimately need it; narrow or decode before use instead of fabricating a shape |
-| Functional preset or dependency just to replace `no-let` | The preset conflicts; a selective plugin adds dependencies for a tiny rule                                          |
-| Syntax-only generator-failure rule                       | Factory-call syntax does not establish yieldability; the existing type-aware Effect rule owns that check            |
-
-### Skill sources
-
-| Source                                                                                                                                                                                                                                                                                                                                                                                               | Used and boundary                                                                                                                                                                                 |
-| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [Matt Pocock's engineering skills](https://github.com/mattpocock/skills/tree/d81f3a183412e71a5b1e84ca21bc1a35eea03a60/skills/engineering)                                                                                                                                                                                                                                                            | Caller-first contracts, causal debugging and one uncertain behavior at a time; no universal TDD                                                                                                   |
-| [Cursor / pstack](https://github.com/cursor/plugins/tree/e43c7ee26e0038c6c1fa8380dd34ce86ff94cb2a/pstack)                                                                                                                                                                                                                                                                                            | Interface rationale, focused bug replay and defensible benchmarks; no playbook-stage machinery                                                                                                    |
-| [Kit Langton's Effect skill](https://github.com/kitlangton/skills/tree/71195e36024ebd2e66c5beac946e81eafd5abc43/skills/effect)                                                                                                                                                                                                                                                                       | Schema construction/optionality, checked against actual [Effect 4 source](https://github.com/Effect-TS/effect/tree/67ba4e46a11ccda0b6761578bfd22c04ae00167d/packages/effect/src)                  |
-| [Vercel's agent skills](https://github.com/vercel-labs/agent-skills/tree/063bee94c3f4df8453406c830b0a7df0f2860278/skills)                                                                                                                                                                                                                                                                            | Independent I/O and narrow subscriptions, translated to Effect/atoms; no manual React memoization                                                                                                 |
-| [Anthropic frontend-design](https://github.com/anthropics/skills/tree/main/skills/frontend-design) 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                      |
-| [Apple HIG](https://developer.apple.com/design/human-interface-guidelines), [Linear](https://linear.app/now/how-we-redesigned-the-linear-ui), [Rauno Freiberg](https://rauno.me/craft/interaction-design), [Geist](https://vercel.com/geist), [Radix](https://www.radix-ui.com/primitives/docs/overview/accessibility) and [WCAG](https://www.w3.org/WAI/WCAG22/Understanding/contrast-minimum.html) | The quality bar, platform conventions, semantic type and glass, gesture behavior, border and shadow roles, dialog contracts and contrast ratios                                                   |
-
-Additional sources for this refinement:
-
-- [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.
-- [Anatomy](https://github.com/wheresryan22/anatomy): physical and isometric explanations when their relationships are the concept; no mandatory dense machine or separate card frame.
-- [Antfu design](https://github.com/antfu/design): native token hierarchy, density and affordance; no Vue or UnoCSS dependency added.
-- [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.
-
-- [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>
+The preset's fixes leave work for the formatter, so run `vp fmt` after `vp check --fix`. Your own `ignorePatterns` replace the preset's, so repeat `**/*.gen.ts`.

package/dist/{MutableList-Cpkiw3Cl.mjs → MutableList-CnvD7fcZ.mjs}

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

package/dist/install.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { An as evaluate, Ar as isObject, At as flatMap$4, Bn as isFailReason$1, Br as constTrue, Bt as match$4, C as TaggedError$1, Cn as causeFail, Cr as isFunction, Ct as succeed$6, D as contains, Dn as contAll, Dr as isNotUndefined, Dt as exists, En as contA, Er as isNotNullish, F as filter, Fn as isCause, Fr as isString$1, Ft as getOrUndefined$1, Gn as assignProperty, Gr as identity, Hn as makePrimitive$1, Hr as constVoid, Ht as orElse, In as isDieReason$1, Ir as isTagged, It as isNone, J as isArrayNonEmpty, Jn as setStackTraceLimit, Jr as pipe, Jt as Number$5, Kn as internalCall, Kr as memoize, L as findFirst, Ln as isDone$2, Lr as isUndefined, Lt as isSome, M as empty$3, Mn as exitFail, Mt as fromNullishOr, Nn as exitFailCause, Nt as fromUndefinedOr, On as contE, Or as isNullish, Pn as exitSucceed, Pt as getOrElse, Qn as format$1, R as findFirstIndex, Rn as isEffect$1, Rr as isUnknown, S as Error$2, Sn as causeEmpty, Sr as isError, St as match$3, T as append, Tn as constEmptyAnnotations, Tr as isNotNull, U as fromIterable$1, Un as makePrimitiveProto, Ur as constant, Ut as some, Vn as isInterruptReason, Vr as constUndefined, Vt as none, Wn as withFiber$1, Wr as dual, X as isReadonlyArrayNonEmpty, Xn as NodeInspectSymbol, Xr as Prototype$1, Xt as isGreaterThan$1, Y as isCanonicalArrayIndex, Yn as BaseProto, Yr as Class, Yt as String$6, Z as join$1, Zn as toStringUnknown, Zr as pipeArguments, _ as startsWith, _n as args, a as takeN, an as CauseImpl, at as reduce, bn as causeCombine, c as make$30, cn as Error$3, cr as equals$1, dn as InterruptorStackTrace, dr as combine$1, er as formatJson, et as map$8, fn as PipeInspectableProto, fr as hash, gn as Yield, gr as structure, hn as TaggedError$2, hr as string$1, ht as fail$5, i as take$1, jn as exitDie, jr as isObjectKeyword, k as dedupe, kn as done$1, kr as isNumber, ln as ExitTypeId, lr as symbol, mn as StackTraceKey, n as clear, nr as formatPropertyKey, on as Die, ot as some$1, pn as ReasonBase, pr as number$1, qn as getStackTraceLimit, qr as memoizeIdempotent, r as make$29, rr as currentFiberTypeId, rt as of, sn as Done$1, t as append$1, tn as mapInput, tr as formatPath, tt as match$5, u as match$6, un as Fail, vn as causeAddInterrupts, vr as symbol$1, w as taggedEnum, wn as causeFromReasons, wr as isIterable, wt as normalize$1, x as round, xn as causeDie, xr as isBoolean$1, y as trimEnd, yn as causeAnnotate, yr as hasProperty, yt as isFailure$1, z as findLast, zn as isExit, zr as constFalse, zt as map$10 } from "./MutableList-Cpkiw3Cl.mjs";
+import { $n as format$1, An as done$1, Ar as isNumber, Bn as isExit, Br as constFalse, Bt as map$10, C as TaggedError$1, Cn as causeEmpty, Cr as isError, Ct as match$3, D as contains, Dn as contA, Dr as isNotNullish, En as constEmptyAnnotations, Er as isNotNull, F as filter, Fn as exitSucceed, Ft as getOrElse, Gn as withFiber$1, Gr as dual, Hn as isInterruptReason, Hr as constUndefined, Ht as none, In as isCause, Ir as isString$1, It as getOrUndefined$1, J as isArrayNonEmpty, Jn as getStackTraceLimit, Jr as memoizeIdempotent, Kn as assignProperty, Kr as identity, L as findFirst, Ln as isDieReason$1, Lr as isTagged, Lt as isNone, M as empty$3, Mn as exitDie, Mr as isObjectKeyword, Nn as exitFail, Nt as fromNullishOr, On as contAll, Or as isNotUndefined, Ot as exists, Pn as exitFailCause, Pt as fromUndefinedOr, Qn as toStringUnknown, Qr as pipeArguments, R as findFirstIndex, Rn as isDone$2, Rr as isUndefined, Rt as isSome, S as Error$2, Sn as causeDie, Sr as isBoolean$1, T as append, Tn as causeFromReasons, Tr as isIterable, Tt as normalize$1, U as fromIterable$1, Un as makePrimitive$1, Ur as constVoid, Ut as orElse, Vn as isFailReason$1, Vr as constTrue, Vt as match$4, Wn as makePrimitiveProto, Wr as constant, Wt as some, X as isReadonlyArrayNonEmpty, Xn as BaseProto, Xr as Class, Xt as String$6, Y as isCanonicalArrayIndex, Yn as setStackTraceLimit, Yr as pipe, Yt as Number$5, Z as join$1, Zn as NodeInspectSymbol, Zr as Prototype$1, Zt as isGreaterThan$1, _n as Yield, _r as structure, a as takeN, at as reduce, bn as causeAnnotate, br as hasProperty, bt as isFailure$1, c as make$30, cn as Done$1, dn as Fail, et as map$8, fn as InterruptorStackTrace, fr as combine$1, g as startsWith, gn as TaggedError$2, gr as string$1, gt as fail$5, hn as StackTraceKey, i as take$1, ir as currentFiberTypeId, jn as evaluate, jr as isObject, jt as flatMap$4, k as dedupe, kn as contE, kr as isNullish, ln as Error$3, lr as equals$1, mn as ReasonBase, mr as number$1, n as clear, nn as mapInput, nr as formatPath, on as CauseImpl, ot as some$1, pn as PipeInspectableProto, pr as hash, qn as internalCall, qr as memoize, r as make$29, rr as formatPropertyKey, rt as of, sn as Die, t as append$1, tr as formatJson, tt as match$5, u as match$6, un as ExitTypeId, ur as symbol, vn as args, w as taggedEnum, wn as causeFail, wr as isFunction, wt as succeed$6, x as round, xn as causeCombine, y as trimEnd, yn as causeAddInterrupts, yr as symbol$1, z as findLast, zn as isEffect$1, zr as isUnknown } from "./MutableList-CnvD7fcZ.mjs";
 import * as OS from "node:os";
 import * as NodeChildProcess from "node:child_process";
 import { PassThrough } from "node:stream";
@@ -1835,7 +1835,7 @@ var FiberImpl = class {
 				current = cache.tracerContext ? cache.tracerContext(current, this) : current[evaluate](this);
 				if (current === Yield) {
 					const yielded = this._yielded;
-					if (ExitTypeId in yielded) {
+					if ("~effect/Exit" in yielded) {
 						this._deferredInterrupt = false;
 						this._yielded = void 0;
 						return yielded;
@@ -1847,7 +1847,7 @@ var FiberImpl = class {
 					return Yield;
 				}
 			} catch (error) {
-				if (!hasProperty(current, evaluate)) return exitDie(`Fiber.runLoop: Not a valid effect: ${String(current)}`);
+				if (!hasProperty(current, "~effect/Effect/evaluate")) return exitDie(`Fiber.runLoop: Not a valid effect: ${String(current)}`);
 				current = exitDie(error);
 			}
 		} finally {
@@ -2031,7 +2031,7 @@ const yieldNow = /*#__PURE__*/ (/* @__PURE__ */ makePrimitive$1({
 		fiber.currentDispatcher.scheduleTask(() => {
 			if (resumed) return;
 			fiber.evaluate(exitVoid);
-		}, this[args] ?? 0);
+		}, this["~effect/Effect/args"] ?? 0);
 		return fiber.yieldWith(() => {
 			resumed = true;
 		});
@@ -2816,14 +2816,14 @@ const whileLoop$1 = /*#__PURE__*/ makePrimitive$1({
 	op: "While",
 	[contA](value, fiber) {
 		this[args].step(value);
-		if (this[args].while()) {
+		if (this["~effect/Effect/args"].while()) {
 			fiber._stack.push(this);
 			return this[args].body();
 		}
 		return exitVoid;
 	},
 	[evaluate](fiber) {
-		if (this[args].while()) {
+		if (this["~effect/Effect/args"].while()) {
 			fiber._stack.push(this);
 			return this[args].body();
 		}
@@ -11985,7 +11985,7 @@ function run$4(ast) {
 function parserResult(result, input) {
 	if (result === sameExit) return succeed$2(input);
 	if (!effectIsExit(result)) return flatMapEager(result, getValue);
-	return result[args] === missing ? getValue(missing) : result;
+	return result["~effect/Effect/args"] === missing ? getValue(missing) : result;
 }
 function runWithCompiler(compiler, ast) {
 	let parser;
@@ -11993,7 +11993,7 @@ function runWithCompiler(compiler, ast) {
 		const result = (parser ??= compiler(ast))(input, options ?? defaultParseOptions);
 		if (result === sameExit) return succeed$2(input);
 		if (!effectIsExit(result)) return flatMapEager(result, getValue);
-		return result[args] === missing ? getValue(missing) : result;
+		return result["~effect/Effect/args"] === missing ? getValue(missing) : result;
 	};
 }
 function asExit(parser) {
@@ -19948,18 +19948,6 @@ const cursorHide = `${ESC}?25l`;
 /**
 * @internal
 */
-const cursorLeft = `${ESC}G`;
-/**
-* @internal
-*/
-const cursorSavePosition = `${ESC}s`;
-/**
-* @internal
-*/
-const cursorRestorePosition = `${ESC}u`;
-/**
-* @internal
-*/
 const eraseLine = `${ESC}2K`;
 /**
 * @internal
@@ -20544,7 +20532,7 @@ const handleConfirmClear = (options) => {
 		const figures = yield* getTheme(options);
 		const confirmMessage = state.value ? options.placeholder.defaultConfirm : options.placeholder.defaultDeny;
 		const promptText = renderPrompt(confirmMessage, options.message, figures.prefix, figures.pointerSmall, figures, { plain: true });
-		return eraseText(promptText, columns) + (eraseLine + cursorLeft);
+		return eraseText(promptText, columns) + (eraseLine + "\x1B[G");
 	});
 };
 const renderConfirmNextFrame = /*#__PURE__*/ fnUntraced(function* (state, options) {
@@ -20585,7 +20573,7 @@ const handleDateClear = (options) => {
 	return fnUntraced(function* (state, _) {
 		const columns = yield* (yield* Terminal).columns;
 		const figures = yield* getTheme(options);
-		const resetCurrentLine = eraseLine + cursorLeft;
+		const resetCurrentLine = eraseLine + "\x1B[G";
 		const parts = reduce(state.dateParts, "", (doc, part) => doc + part.toString());
 		const promptText = renderPrompt(parts, options.message, figures.prefix, figures.pointerSmall, figures, { plain: true });
 		const errorText = isSome(state.error) ? match$5(state.error.value.split(NEWLINE_REGEXP), {
@@ -20601,7 +20589,7 @@ const renderDateError = (state, pointer, theme) => {
 		if (isReadonlyArrayNonEmpty(errorLines)) {
 			const prefix = annotateSymbol(theme, pointer, theme.errorColor);
 			const lines = map$8(errorLines, (str) => annotateErrorLine(theme, str));
-			return cursorSavePosition + "\n" + separateSymbol(prefix, lines.join("\n")) + cursorRestorePosition;
+			return "\x1B[s\n" + separateSymbol(prefix, lines.join("\n")) + "\x1B[u";
 		}
 	}
 	return "";
@@ -21028,7 +21016,7 @@ const handleNumberClear = (options) => {
 	return fnUntraced(function* (state, _) {
 		const columns = yield* (yield* Terminal).columns;
 		const figures = yield* getTheme(options);
-		const resetCurrentLine = eraseLine + cursorLeft;
+		const resetCurrentLine = eraseLine + "\x1B[G";
 		const errorText = renderNumberError(state, figures.pointerSmall, figures, { plain: true });
 		const promptText = renderNumberOutput(state, figures.prefix, figures.pointerSmall, options, figures, { plain: true });
 		return clearOutputWithError(promptText, columns, errorText) + resetCurrentLine;
@@ -21047,7 +21035,7 @@ const renderNumberError = (state, pointer, theme, renderOptions) => {
 			if (renderOptions?.plain === true) return separateSymbol(pointer, errorLines.join("\n"));
 			const prefix = annotateSymbol(theme, pointer, theme.errorColor);
 			const lines = map$8(errorLines, (str) => annotateErrorLine(theme, str));
-			return cursorSavePosition + "\n" + separateSymbol(prefix, lines.join("\n")) + cursorRestorePosition;
+			return "\x1B[s\n" + separateSymbol(prefix, lines.join("\n")) + "\x1B[u";
 		}
 	});
 	return "";
@@ -21272,7 +21260,7 @@ const handleSelectRender = (options) => {
 const handleSelectClear = (options) => fnUntraced(function* (state, _) {
 	const columns = yield* (yield* Terminal).columns;
 	const figures = yield* getTheme(options);
-	const clearPrompt = eraseLine + cursorLeft;
+	const clearPrompt = eraseLine + "\x1B[G";
 	const promptText = renderSelectOutput(figures.prefix, figures.pointerSmall, options, figures, { plain: true });
 	const choicesText = renderSelectChoices(state, options, figures, { plain: true });
 	return eraseText(withSelectHeader(promptText, choicesText), columns) + clearPrompt;
@@ -21298,7 +21286,7 @@ const handleSelectProcess = (options) => {
 const renderClearScreen = /*#__PURE__*/ fnUntraced(function* (state, options) {
 	const columns = yield* (yield* Terminal).columns;
 	const figures = yield* getTheme(options);
-	const resetCurrentLine = eraseLine + cursorLeft;
+	const resetCurrentLine = eraseLine + "\x1B[G";
 	const errorText = renderTextError(state, figures.pointerSmall, figures, { plain: true });
 	return clearOutputWithError(renderTextOutput(state, figures.prefix, figures.pointerSmall, options, figures, { plain: true }), columns, errorText) + resetCurrentLine;
 });
@@ -21324,7 +21312,7 @@ const renderTextError = (nextState, pointer, theme, renderOptions) => {
 			if (renderOptions?.plain === true) return separateSymbol(pointer, errorLines.join("\n"));
 			const prefix = annotateSymbol(theme, pointer, theme.errorColor);
 			const lines = map$8(errorLines, (str) => annotateErrorLine(theme, str));
-			return cursorSavePosition + "\n" + separateSymbol(prefix, lines.join("\n")) + cursorRestorePosition;
+			return "\x1B[s\n" + separateSymbol(prefix, lines.join("\n")) + "\x1B[u";
 		}
 	});
 	return "";
@@ -21482,7 +21470,7 @@ const basePrompt = (options, type) => {
 const handleToggleClear = /*#__PURE__*/ fnUntraced(function* (options) {
 	const columns = yield* (yield* Terminal).columns;
 	const figures = yield* getTheme(options);
-	const clearPrompt = eraseLine + cursorLeft;
+	const clearPrompt = eraseLine + "\x1B[G";
 	const toggleText = options.active + " " + separateSymbol(figures.toggleSeparator, options.inactive);
 	const promptText = renderPrompt(toggleText, options.message, figures.prefix, figures.pointerSmall, figures, { plain: true });
 	return eraseText(promptText, columns) + clearPrompt;
@@ -25497,7 +25485,7 @@ const runWith = (command, config) => {
 };
 //#endregion
 //#region package.json
-var version = "0.1.1083";
+var version = "0.1.1086";
 //#endregion
 //#region src/install.ts
 const cli = pipe(make("deslop-coding-standards", {}, fnUntraced(function* () {