@systemfsoftware/vitest 0.0.0 → 0.1.0

package/dist/integration.d.ts

@@ -0,0 +1,37 @@
+
+import { a as Expect, n as AssertedShape, r as Check, t as Asserted } from "./checks-DiuzHhQM.js";
+import * as Effect from "effect/Effect";
+//#region src/integration.d.ts
+/**
+ * A flow that asserts more than once marks each assertion point with this, so the check after it is that
+ * state's one check (KTD5).
+ *
+ * @since 4.0.0
+ */
+export declare const step: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | Asserted>;
+/**
+ * The test's run, as a library hands it to a runtime of its own: `bind` provides what a check reads off the
+ * test's own fiber — the ledger — so the checks the other runtime runs count as this test's assertions, and the
+ * bound effect no longer requires `Asserted`, which is what lets it cross into a runtime that cannot know it.
+ *
+ * A runtime of its own re-runs the bound effect — a kernel explores a baseline and then its seeded replays — and
+ * executing the bound effect opens a new observed state before it runs, so each execution is a run. `bind`
+ * resets nothing on its own: the step runs when the bound effect is executed. A runtime that re-runs a check
+ * without executing the bound effect has opened no state, so its second check is refused, as any two checks on
+ * one state are. One check per execution, and two checks inside one execution are still refused.
+ *
+ * @since 4.0.0
+ */
+export interface RunBinding {
+  readonly bind: <A, E, R>(self: Effect.Effect<A, E, R | Asserted>) => Effect.Effect<A, E, R>;
+}
+/**
+ * The run binding of the test the caller is executing in: the ledger its checks count on, and the running task
+ * context. Capture it from inside a test — the capture requires `Asserted`, so a library cannot mistake a run
+ * binding for something the outside has — and bind the effect before handing it to a runtime of its own.
+ *
+ * @since 4.0.0
+ */
+export declare const captureRunBinding: Effect.Effect<RunBinding, never, Asserted>;
+//#endregion
+export type { Asserted, AssertedShape, Check, Expect };

package/dist/integration.mjs

@@ -0,0 +1,38 @@
+
+import { r as Asserted, t as VitestTestContext } from "./test-context-hvSoKLtw.mjs";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+//#region src/integration.ts
+/**
+* The integration entry (KTD5): the types a library writes its verdicts with, the marker it calls between the
+* observations of one flow, and the binding it carries onto a runtime of its own.
+*
+* @since 4.0.0
+*/
+/**
+* A flow that asserts more than once marks each assertion point with this, so the check after it is that
+* state's one check (KTD5).
+*
+* @since 4.0.0
+*/
+const step = (self) => Effect.flatMap(Asserted, (asserted) => Effect.andThen(Effect.sync(() => asserted.step()), self));
+const boundContext = (self, ctx) => Option.match(Option.fromNullishOr(ctx), {
+	onNone: () => self,
+	onSome: (value) => Effect.provideService(self, VitestTestContext, value)
+});
+const openedRun = (self, asserted) => Effect.andThen(Effect.sync(() => asserted.step()), self);
+const bindingOf = (asserted, ctx) => ({ bind: (self) => boundContext(Effect.provideService(openedRun(self, asserted), Asserted, asserted), ctx) });
+/**
+* The run binding of the test the caller is executing in: the ledger its checks count on, and the running task
+* context. Capture it from inside a test — the capture requires `Asserted`, so a library cannot mistake a run
+* binding for something the outside has — and bind the effect before handing it to a runtime of its own.
+*
+* @since 4.0.0
+*/
+const captureRunBinding = Effect.gen(function* () {
+	const asserted = yield* Asserted;
+	const ctx = Option.getOrUndefined(yield* Effect.serviceOption(VitestTestContext));
+	return bindingOf(asserted, ctx);
+});
+//#endregion
+export { captureRunBinding, step };

package/dist/test-context-hvSoKLtw.mjs

@@ -0,0 +1,206 @@
+
+import { a as booleanRefusal, b as refusedText, c as negatedText, m as refusePiecewise, s as neededText, t as authorize, u as refusalOf } from "./guard-BocOhXt2.mjs";
+import * as V from "vitest";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Context from "effect/Context";
+//#region src/internal/checks.ts
+/**
+* The checks a test receives as its callback parameter. There is no importable `expect`: the only one in reach is
+* the one the runner hands this test, so it is bound to this test by construction, not by a lookup.
+*
+* Every matcher returns a `Check`: an Effect that needs `Asserted`, a service only the runner provides.
+* - A check that is not yielded is a floating Effect: `@effect/language-service` `floatingEffect` fails the build.
+* - A body that yields no check has no `Asserted` in its requirements: the test signature refuses it.
+* - A check run outside a test has nothing providing `Asserted`: a type error.
+*
+* @since 4.0.0
+*/
+/** @internal */
+var Asserted = class extends Context.Service()("@systemfsoftware/vitest/Asserted") {};
+const branded = /* @__PURE__ */ new WeakSet();
+const isObject = (value) => typeof value === "object" && value !== null;
+/** @internal */
+const isCheck = (value) => isObject(value) && branded.has(value);
+const makeCheck = (judgement, written) => {
+	written(judgement);
+	const check = Effect.gen(function* () {
+		(yield* Asserted).judge(judgement);
+	});
+	branded.add(check);
+	return check;
+};
+const has = (table, key) => Object.hasOwn(table, key);
+const isPlainObject = (value) => isObject(value) && Object.getPrototypeOf(value) === Object.prototype;
+const isEmptyShape = (value) => isPlainObject(value) && Object.keys(value).length === 0;
+/** A thunk that refuses with `text`: thrown when a matcher is called, or when a static is read. */
+const refusing = (text) => () => {
+	throw refusalOf(text);
+};
+const forView = (view, negated) => ({
+	...view,
+	negated
+});
+const notView = (view) => forView(view, !view.negated);
+const viewFor = (written, actual, message) => ({
+	actual,
+	message,
+	negated: false,
+	written
+});
+const messageOf = (argument) => typeof argument === "string" ? argument : void 0;
+const refuseBooleanActual = (actual) => typeof actual === "boolean";
+const refusedTextOf = (property) => has(refusedText, property) ? refusedText[property] : void 0;
+const negatedTextOf = (property) => has(negatedText, property) ? negatedText[property] : void 0;
+const textRefusalOf = (view, property) => view.negated ? negatedTextOf(property) : refusedTextOf(property);
+const readRefusals = {
+	resolves: refusedText.resolves,
+	rejects: refusedText.rejects
+};
+const readRefusal = (property) => readRefusals[property];
+const neededArity = {
+	toThrow: 1,
+	toThrowError: 1,
+	toSatisfy: 2,
+	toMatchObject: 1
+};
+const tooFewArguments = (property, args) => args.length < neededArity[property];
+const vacuousMatchObject = (property, args) => property === "toMatchObject" && isEmptyShape(args[0]);
+const missingArgument = (property, args) => tooFewArguments(property, args) || vacuousMatchObject(property, args);
+const memberAt = (target, property) => Reflect.get(target, property, target);
+const isCallable = (value) => typeof value === "function";
+const invokeMember = (target, property, args) => {
+	const member = memberAt(target, property);
+	if (isCallable(member)) Reflect.apply(member, target, args);
+};
+const judgementOf = (view, property, args) => (make) => {
+	const assertion = make(view.actual, view.message);
+	const target = view.negated ? assertion.not : assertion;
+	invokeMember(target, property, args);
+};
+const judgedCheck = (view, property, args) => makeCheck(judgementOf(view, property, args), view.written);
+const genericMember = (view, property) => (...args) => judgedCheck(view, property, args);
+const neededMember = (view, property) => (...args) => {
+	if (missingArgument(property, args)) throw refusalOf(neededText[property]);
+	return judgedCheck(view, property, args);
+};
+const absent = { found: false };
+const present = (value) => ({
+	found: true,
+	value
+});
+const valueOf = (member) => member.found ? member.value : void 0;
+const fallbackMember = (view, property) => has(neededText, property) ? present(neededMember(view, property)) : present(genericMember(view, property));
+const refusedMember = (view, property) => {
+	const text = textRefusalOf(view, property);
+	if (text === void 0) return absent;
+	return present(refusing(text));
+};
+const afterRefusal = (view, property) => {
+	const refused = refusedMember(view, property);
+	if (refused.found) return refused;
+	return fallbackMember(view, property);
+};
+const negationMember = (view, property) => property === "not" ? present(matcherView(notView(view))) : absent;
+const viewMember = (view, property) => {
+	const negation = negationMember(view, property);
+	if (negation.found) return negation;
+	return afterRefusal(view, property);
+};
+const memberOf = (view, property) => {
+	const read = readRefusal(property);
+	if (read !== void 0) throw refusalOf(read);
+	return valueOf(viewMember(view, property));
+};
+const memberFor = (view, property) => typeof property === "string" ? memberOf(view, property) : void 0;
+const viewHandler = (view) => ({ get: (_target, property) => memberFor(view, property) });
+const matcherView = (view) => new Proxy({}, viewHandler(view));
+const assertionView = (written, args) => {
+	if (refuseBooleanActual(args[0])) throw refusalOf(booleanRefusal);
+	return matcherView(viewFor(written, args[0], messageOf(args[1])));
+};
+const isDecodingSchema = (value) => Schema.isSchema(value);
+const asMatcher = (value) => {
+	if (isObject(value) === false) throw new Error("vitest returned no asymmetric matcher");
+	return value;
+};
+const toStandardSchema = (schema) => isDecodingSchema(schema) ? Schema.toStandardSchemaV1(schema) : schema;
+const standardSchemaOf = (schema) => asMatcher(V.expect.schemaMatching(toStandardSchema(schema)));
+const notShapes = {
+	stringContaining: V.expect.not.stringContaining,
+	objectContaining: V.expect.not.objectContaining,
+	arrayContaining: V.expect.not.arrayContaining,
+	stringMatching: V.expect.not.stringMatching
+};
+const shapes = {
+	objectContaining: V.expect.objectContaining,
+	arrayContaining: V.expect.arrayContaining,
+	stringContaining: V.expect.stringContaining,
+	stringMatching: V.expect.stringMatching,
+	closeTo: V.expect.closeTo,
+	any: V.expect.any,
+	schemaMatching: standardSchemaOf,
+	not: notShapes,
+	anything: refusing(refusedText.anything),
+	poll: refusing(refusedText.poll),
+	soft: refusing(refusedText.soft)
+};
+const refusalGetters = [
+	["anything", refusedText.anything],
+	["poll", refusedText.poll],
+	["soft", refusedText.soft]
+];
+const defineRefusalGetters = (target) => {
+	for (const [name, text] of refusalGetters) Object.defineProperty(target, name, { get: refusing(text) });
+};
+const unreachableTarget = () => () => {
+	throw new Error("the expect proxy answers every call");
+};
+const expectHandler = (written) => ({ apply: (_target, _thisArgument, argumentList) => assertionView(written, argumentList) });
+const expectFor = (written) => {
+	const base = Object.assign(unreachableTarget(), shapes);
+	defineRefusalGetters(base);
+	return new Proxy(base, expectHandler(written));
+};
+/** @internal */
+const makeLedger = (ctx) => {
+	const pending = /* @__PURE__ */ new Set();
+	const counter = {
+		judged: 0,
+		since: 0
+	};
+	const hard = (actual, message) => ctx.expect(actual, message);
+	return {
+		asserted: {
+			judge: (judgement) => {
+				pending.delete(judgement);
+				counter.judged += 1;
+				counter.since += 1;
+				if (counter.since > 1) throw refusalOf(refusePiecewise);
+				authorize(() => judgement(hard));
+			},
+			step: () => {
+				counter.since = 0;
+			}
+		},
+		written: (judgement) => {
+			pending.add(judgement);
+		},
+		unyielded: () => pending.size,
+		judged: () => counter.judged
+	};
+};
+/** @internal */
+const checksFor = (ledger) => ({ expect: expectFor(ledger.written) });
+//#endregion
+//#region src/internal/test-context.ts
+/** @internal */
+const vitestTestContextKey = "@systemfsoftware/vitest/TestContext";
+/**
+* The running Vitest test, or `null` outside a run; provided on every test the fork runs.
+*
+* @internal
+*/
+const VitestTestContext = Context.Reference(vitestTestContextKey, { defaultValue: () => null });
+//#endregion
+export { isCheck as a, checksFor as i, vitestTestContextKey as n, makeLedger as o, Asserted as r, VitestTestContext as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/vitest",
   "license": "MIT",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -10,7 +10,7 @@
   },
   "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/vitest#readme",
   "bugs": "https://github.com/systemfsoftware/systemfsoftware/issues",
-  "description": "A fork of @effect/vitest whose defaults make the lazy test a good test: fresh layers, a second run that catches leaked state, virtual time, soft checks that stop at the next step, and properties refuted against a constant impostor.",
+  "description": "A fork of @effect/vitest whose defaults make the lazy test a good test: expect bound to the test's own callback, one check per observed state, fresh layers, a second run that catches leaked state, virtual time, and properties refuted against a constant impostor.",
   "keywords": [
     "effect",
     "effect-ts",
@@ -25,18 +25,18 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.mjs"
     },
-    "./refusals": {
-      "types": "./dist/refusals.d.ts",
-      "default": "./dist/refusals.mjs"
+    "./guard": {
+      "types": "./dist/guard.d.ts",
+      "default": "./dist/guard.mjs"
+    },
+    "./integration": {
+      "types": "./dist/integration.d.ts",
+      "default": "./dist/integration.mjs"
     },
     "./TestClock": {
       "types": "./dist/TestClock.d.ts",
       "default": "./dist/TestClock.mjs"
     },
-    "./utils": {
-      "types": "./dist/utils.d.ts",
-      "default": "./dist/utils.mjs"
-    },
     "./package.json": "./package.json"
   },
   "files": [

package/dist/refusals-BQtDszyU.mjs

@@ -1,32 +0,0 @@
-
-//#region src/internal/refusals.ts
-/** @internal */
-const refuseHook = "✗ hooks share state between tests. Build what a test needs inside it; services come fresh per test from layer(Service.layer)((it) => { ... }).";
-/** @internal */
-const refuseNoAssertion = "✗ this test ran no assertion, so it cannot fail. Assert on what the code returned: expect(actual).toEqual(expected).";
-/** @internal */
-const refuseAsync = "✗ an async test runs Effects outside the test runtime: no virtual time, no fresh services, no leak check. Return the Effect instead: it.effect(name, () => Effect.gen(function* () { ... })).";
-/** @internal */
-const refuseBareEffect = "✗ a bare test body that returns an Effect never runs it, so nothing in the test was checked. Register it on the Effect lane: it.effect(name, () => Effect.gen(function* () { ... })).";
-/** @internal */
-const refuseUnprovided = "✗ the test needs a service that nothing provides. Pipe the body through Effect.provide(Service.layer), or write the tests inside layer(Service.layer)((it) => { ... }); every test gets its own fresh build.";
-/** @internal */
-const refuseBoolean = "✗ expect(<boolean>) can only report 'expected false to be true'. Pass the two values instead: expect(Equal.equals(a, b)).toBe(true) becomes expect(a).toEqual(b). A predicate: expect(value).toSatisfy(predicate).";
-/** @internal */
-const refusePositionalProp = "✗ it.prop(name, [arbitraries], predicate) is removed. Name the function under test and pass a budget: it.prop(name, { of, subject, runs }, holds).";
-/** @internal */
-const presenceMessage = (name) => `✗ ${name} passes for almost any value the code returns. Assert the value: toEqual(expected); for a key that must exist: toHaveProperty(key).`;
-/** @internal */
-const narrowVacuous = [
-	"toBeDefined",
-	"toBeTruthy",
-	"toBeFalsy"
-];
-/** @internal */
-const narrowNegated = [
-	...narrowVacuous,
-	"toBeNull",
-	"toBeUndefined"
-];
-//#endregion
-export { refuseBareEffect as a, refuseNoAssertion as c, refuseAsync as i, refusePositionalProp as l, narrowVacuous as n, refuseBoolean as o, presenceMessage as r, refuseHook as s, narrowNegated as t, refuseUnprovided as u };

package/dist/refusals-_6e3GzVK.d.ts

@@ -1,37 +0,0 @@
-
-//#region src/internal/refusals.d.ts
-/** @internal */
-declare const refuseHook = "✗ hooks share state between tests. Build what a test needs inside it; services come fresh per test from layer(Service.layer)((it) => { ... }).";
-/** @internal */
-declare const refuseNoAssertion = "✗ this test ran no assertion, so it cannot fail. Assert on what the code returned: expect(actual).toEqual(expected).";
-/** @internal */
-declare const refuseAsync = "✗ an async test runs Effects outside the test runtime: no virtual time, no fresh services, no leak check. Return the Effect instead: it.effect(name, () => Effect.gen(function* () { ... })).";
-/** @internal */
-declare const refuseBareEffect = "✗ a bare test body that returns an Effect never runs it, so nothing in the test was checked. Register it on the Effect lane: it.effect(name, () => Effect.gen(function* () { ... })).";
-/** @internal */
-declare const refuseUnprovided = "✗ the test needs a service that nothing provides. Pipe the body through Effect.provide(Service.layer), or write the tests inside layer(Service.layer)((it) => { ... }); every test gets its own fresh build.";
-/** @internal */
-declare const refuseBoolean = "✗ expect(<boolean>) can only report 'expected false to be true'. Pass the two values instead: expect(Equal.equals(a, b)).toBe(true) becomes expect(a).toEqual(b). A predicate: expect(value).toSatisfy(predicate).";
-/** @internal */
-declare const refusePositionalProp = "✗ it.prop(name, [arbitraries], predicate) is removed. Name the function under test and pass a budget: it.prop(name, { of, subject, runs }, holds).";
-/** @internal */
-type PresenceMessage<N extends string = string> = `✗ ${N} passes for almost any value the code returns. Assert the value: toEqual(expected); for a key that must exist: toHaveProperty(key).`;
-/**
- * The narrowed matcher as the type sees it: a call whose `this` is not the assertion cannot compile, and the
- * refused text is the compiler error (KTD9). The run time throws the same text.
- *
- * @internal
- */
-type PresenceRefusal<N extends string = string> = (this: PresenceMessage<N>, ...args: Array<never>) => void;
-/** @internal */
-declare const presenceMessage: <N extends string>(name: N) => PresenceMessage<N>;
-/** @internal */
-declare const narrowVacuous: readonly ['toBeDefined', 'toBeTruthy', 'toBeFalsy'];
-/** @internal */
-type NarrowVacuousName = (typeof narrowVacuous)[number];
-/** @internal */
-declare const narrowNegated: readonly ["toBeDefined", "toBeTruthy", "toBeFalsy", "toBeNull", "toBeUndefined"];
-/** @internal */
-type NarrowNegatedName = (typeof narrowNegated)[number];
-//#endregion
-export { narrowVacuous as a, refuseBareEffect as c, refuseNoAssertion as d, refusePositionalProp as f, narrowNegated as i, refuseBoolean as l, NarrowVacuousName as n, presenceMessage as o, refuseUnprovided as p, PresenceRefusal as r, refuseAsync as s, NarrowNegatedName as t, refuseHook as u };

package/dist/refusals.d.ts

@@ -1,3 +0,0 @@
-
-import { a as narrowVacuous, c as refuseBareEffect, d as refuseNoAssertion, f as refusePositionalProp, i as narrowNegated, l as refuseBoolean, o as presenceMessage, p as refuseUnprovided, s as refuseAsync, u as refuseHook } from "./refusals-_6e3GzVK.js";
-export { narrowNegated, narrowVacuous, presenceMessage, refuseAsync, refuseBareEffect, refuseBoolean, refuseHook, refuseNoAssertion, refusePositionalProp, refuseUnprovided };

package/dist/refusals.mjs

@@ -1,3 +0,0 @@
-
-import { a as refuseBareEffect, c as refuseNoAssertion, i as refuseAsync, l as refusePositionalProp, n as narrowVacuous, o as refuseBoolean, r as presenceMessage, s as refuseHook, t as narrowNegated, u as refuseUnprovided } from "./refusals-BQtDszyU.mjs";
-export { narrowNegated, narrowVacuous, presenceMessage, refuseAsync, refuseBareEffect, refuseBoolean, refuseHook, refuseNoAssertion, refusePositionalProp, refuseUnprovided };

package/dist/utils.d.ts

@@ -1,197 +0,0 @@
-
-import * as Cause from "effect/Cause";
-import * as Exit from "effect/Exit";
-import * as Option from "effect/Option";
-import * as Result from "effect/Result";
-//#region src/utils.d.ts
-/**
- * Inspects the value a thunk threw. `A` defaults to `unknown` so a caller passes any inspection function.
- */
-type ThrownValidator = <A = unknown>(thrown: A) => undefined;
-/**
- * Any class, abstract ones included: what `assertInstanceOf` accepts and what `instanceof` takes.
- */
-type AnyConstructor = abstract new (...args: never[]) => object;
-/**
- * Fails the current test with the provided error message.
- *
- * @since 4.0.0
- */
-export declare function fail(message: string): void;
-/**
- * Asserts that `actual` is deeply strictly equal to `expected`.
- *
- * @since 4.0.0
- */
-export declare const deepStrictEqual: {
-  <A>(actual: A, expected: A, message?: undefined): void;
-  <A>(expected: A, message?: undefined): (actual: A) => void;
-};
-/**
- * Asserts that `actual` is not deeply strictly equal to `expected`.
- *
- * Chai names the negation of its deep comparison `notDeepEqual`; there, `deepStrictEqual` and `deepEqual` are
- * one function.
- *
- * @since 4.0.0
- */
-export declare const notDeepStrictEqual: {
-  <A>(actual: A, expected: A, message?: undefined): void;
-  <A>(expected: A, message?: undefined): (actual: A) => void;
-};
-/**
- * Asserts that `actual` is strictly equal to `expected`.
- *
- * @since 4.0.0
- */
-export declare const strictEqual: {
-  <A>(actual: A, expected: A, message?: undefined): void;
-  <A>(expected: A, message?: undefined): (actual: A) => void;
-};
-/**
- * Asserts that `actual` is equal to `expected` using the `Equal.equals` trait.
- *
- * @since 4.0.0
- */
-export declare const assertEquals: {
-  <A>(actual: A, expected: A, message?: undefined): void;
-  <A>(expected: A, message?: undefined): (actual: A) => void;
-};
-/**
- * Asserts that `thunk` does not throw an error.
- *
- * @since 4.0.0
- */
-export declare const doesNotThrow: {
-  (thunk: () => void, message?: string): void;
-  (message?: string): (thunk: () => void) => void;
-};
-/**
- * Asserts that `value` is an instance of `constructor`.
- *
- * @since 4.0.0
- */
-export declare const assertInstanceOf: {
-  <C extends AnyConstructor>(value: unknown, ctor: C, message?: string): asserts value is InstanceType<C>;
-  <C extends AnyConstructor>(ctor: C, message?: string): (value: unknown) => asserts value is InstanceType<C>;
-};
-/**
- * Asserts that `self` is `true`.
- *
- * @since 4.0.0
- */
-export declare const assertTrue: {
-  (self: boolean, message?: string): asserts self;
-  (message?: string): (self: boolean) => asserts self;
-};
-/**
- * Asserts that `self` is `false`.
- *
- * @since 4.0.0
- */
-export declare const assertFalse: {
-  (self: boolean, message?: string): void;
-  (message?: string): (self: boolean) => void;
-};
-/**
- * Asserts that `actual` includes `expected`.
- *
- * @since 4.0.0
- */
-export declare const assertInclude: {
-  (actual: string | undefined, expected: string): void;
-  (expected: string): (actual: string | undefined) => void;
-};
-/**
- * Asserts that `actual` matches `regExp`.
- *
- * @since 4.0.0
- */
-export declare const assertMatch: {
-  (actual: string, regExp: RegExp): void;
-  (regExp: RegExp): (actual: string) => void;
-};
-/**
- * Asserts that `thunk` throws, optionally checking the thrown value against an expected `Error` or validation
- * function.
- *
- * @since 4.0.0
- */
-export declare const throws: {
-  (thunk: () => void, error?: Error | ThrownValidator): void;
-  (error?: Error | ThrownValidator): (thunk: () => void) => void;
-};
-/**
- * Asserts that `thunk` throws or returns a rejected promise, optionally checking the failure value against an
- * expected `Error` or validation function.
- *
- * @since 4.0.0
- */
-export declare const throwsAsync: {
-  (thunk: () => Promise<void>, error?: Error | ThrownValidator): Promise<void>;
-  (error?: Error | ThrownValidator): (thunk: () => Promise<void>) => Promise<void>;
-};
-/**
- * Asserts that `option` is `None`.
- *
- * @since 4.0.0
- */
-export declare function assertNone<A>(option: Option.Option<A>): asserts option is Option.None<never>;
-/**
- * Asserts that `a` is not `undefined`.
- *
- * @since 4.0.0
- */
-export declare function assertDefined<A>(a: A | undefined): asserts a is Exclude<A, undefined>;
-/**
- * Asserts that `a` is `undefined`.
- *
- * @since 4.0.0
- */
-export declare function assertUndefined<A>(a: A | undefined): asserts a is undefined;
-/**
- * Asserts that `option` is `Some` and contains a value equal to `expected`.
- *
- * @since 4.0.0
- */
-export declare const assertSome: {
-  <A>(option: Option.Option<A>, expected: A): asserts option is Option.Some<A>;
-  <A>(expected: A): (option: Option.Option<A>) => asserts option is Option.Some<A>;
-};
-/**
- * Asserts that `result` is `Success` and contains a value equal to `expected`.
- *
- * @since 4.0.0
- */
-export declare const assertSuccess: {
-  <A, E>(result: Result.Result<A, E>, expected: A): asserts result is Result.Success<A, never>;
-  <A, E>(expected: A): (result: Result.Result<A, E>) => asserts result is Result.Success<A, never>;
-};
-/**
- * Asserts that `result` is `Failure` and contains an error equal to `expected`.
- *
- * @since 4.0.0
- */
-export declare const assertFailure: {
-  <A, E>(result: Result.Result<A, E>, expected: E): asserts result is Result.Failure<never, E>;
-  <A, E>(expected: E): (result: Result.Result<A, E>) => asserts result is Result.Failure<never, E>;
-};
-/**
- * Asserts that `exit` is a failure with a cause equal to `expected`.
- *
- * @since 4.0.0
- */
-export declare const assertExitFailure: {
-  <A, E>(exit: Exit.Exit<A, E>, expected: Cause.Cause<E>): asserts exit is Exit.Failure<never, E>;
-  <A, E>(expected: Cause.Cause<E>): (exit: Exit.Exit<A, E>) => asserts exit is Exit.Failure<never, E>;
-};
-/**
- * Asserts that `exit` is a success with a value equal to `expected`.
- *
- * @since 4.0.0
- */
-export declare const assertExitSuccess: {
-  <A, E>(exit: Exit.Exit<A, E>, expected: A): asserts exit is Exit.Success<A, never>;
-  <A, E>(expected: A): (exit: Exit.Exit<A, E>) => asserts exit is Exit.Success<A, never>;
-};
-//#endregion