@systemfsoftware/vitest 0.0.0 → 0.2.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-Cq9of-Lx.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-ChvjVyCo.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-ChvjVyCo.mjs

@@ -0,0 +1,328 @@
+
+import { a as booleanRefusal, c as negatedText, m as refusePiecewise, s as neededText, t as authorize, u as refusalOf, x as refusedText } from "./guard-p_8ARgPm.mjs";
+import * as V from "vitest";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+import * as Context from "effect/Context";
+//#region src/internal/call-site.ts
+/**
+* The one rule that reads a frame out of a stack: which frame a failure is raised from, and which frame an author
+* wrote the thing that raised it on (R2, KTD6).
+*
+* A deferred check and a declared property both fail inside the fork, where the stack holds only the fork's frames
+* and the author's line is long gone. Each captures its call site while the author's frame is still on the stack
+* and hands it to the failure as its first frame, so the renderer's R2 walk leads with the author's line.
+*
+* The rule is the same everywhere it applies: the first frame outside the vendored install, node internals, and
+* every spec library's own `src` and `dist` — {@link LIBRARY_DIRS}. A caller may name its own extra frames with a
+* {@link RegExp}, and a value that captured a raw stack records it whole, resolved here rather than by a second
+* copy of the rule. `effect-spec-runtime`, `effect-cell-types`, `effect-gherkin-spec` and `trace-spec` read it from
+* here.
+*
+* @since 4.0.0
+*/
+const FRAME = /\(?((?:file:\/\/)?[^()\s]+):(\d+):(\d+)\)?\s*$/u;
+const FILE_PROTOCOL = "file://";
+const FRAME_AT = "at ";
+const FRAME_PAREN = " (";
+const and = (left, right) => left && right;
+const not = (value) => !value;
+const LIBRARY_DIRS = [
+	"runner/vitest",
+	"effect-spec-runtime",
+	"effect-cell-types",
+	"effect-gherkin-spec",
+	"storybook-gherkin",
+	"conformance-spec",
+	"differential-spec",
+	"trace-spec",
+	"effect-daemon-spec"
+];
+const isVendoredPath = (path) => path.includes("node_modules") || path.startsWith("node:");
+const inOwnDir = (path) => (dir) => path.includes(`/${dir}/src/`) || path.includes(`/${dir}/dist/`);
+const isLibraryPath = (path) => LIBRARY_DIRS.some(inOwnDir(path));
+/** @internal */
+const isUserPath = (path) => and(not(isVendoredPath(path)), not(isLibraryPath(path)));
+const stripProtocol = (path) => path.startsWith(FILE_PROTOCOL) ? path.slice(7) : path;
+const isFrame = (frame) => frame !== void 0;
+const partsOf = (match) => Option.flatMap(Option.fromNullishOr(match), (found) => Option.map(Option.all([
+	Option.fromNullishOr(found[1]),
+	Option.fromNullishOr(found[2]),
+	Option.fromNullishOr(found[3])
+]), ([path, line, column]) => ({
+	path: stripProtocol(path),
+	line,
+	column
+})));
+const beforeParen = (rest) => Option.flatMap(Option.fromNullishOr(rest.indexOf(FRAME_PAREN)), (paren) => Option.some(rest.slice(0, paren)));
+const afterAt = (line) => line.startsWith(FRAME_AT) ? Option.some(line.slice(3)) : Option.none();
+const nonEmpty = (text) => text.length > 0;
+const fnIn = (line) => Option.getOrUndefined(Option.flatMap(afterAt(line), (rest) => Option.filter(beforeParen(rest), nonEmpty)));
+const frameOfLine = (line) => {
+	const raw = line.trim();
+	return Option.match(partsOf(FRAME.exec(raw)), {
+		onNone: () => void 0,
+		onSome: (parts) => ({
+			...parts,
+			fn: fnIn(raw),
+			raw
+		})
+	});
+};
+/** @internal */
+const framesOf = (stack) => stack.split("\n").map(frameOfLine).filter(isFrame);
+const frameSiteOf = (frame) => `${frame.path}:${frame.line}:${frame.column}`;
+const isUserFrame = (frame) => isUserPath(frame.path);
+const firstUserFrameOf = (stack) => framesOf(stack).find(isUserFrame);
+/** @internal */
+const firstUserSiteOf = (stack) => {
+	const frame = firstUserFrameOf(stack);
+	return frame === void 0 ? void 0 : frameSiteOf(frame);
+};
+const NO_LIBRARY = /$^/u;
+const currentStack = () => (/* @__PURE__ */ new Error()).stack ?? "";
+const isSiteOf = (library) => (frame) => and(isUserPath(frame.path), not(library.test(frame.raw)));
+const firstFrameOf = (stack, library) => framesOf(stack).find(isSiteOf(library));
+/** @internal */
+const callFrameOutside = (library) => {
+	const frame = firstFrameOf(currentStack(), library);
+	return frame === void 0 ? void 0 : frame.raw;
+};
+/** @internal */
+const callFrame = () => callFrameOutside(NO_LIBRARY);
+const callSiteOutside = (library) => {
+	const frame = firstFrameOf(currentStack(), library);
+	return frame === void 0 ? void 0 : frameSiteOf(frame);
+};
+/** @internal */
+const callSite = () => callSiteOutside(NO_LIBRARY);
+const firstLineOf = (lines) => lines[0] ?? "";
+const stackOf = (error) => error.stack ?? "";
+const withRaisingFrameImpl = (error, frame) => {
+	if (frame === void 0) return error;
+	const lines = stackOf(error).split("\n");
+	error.stack = [
+		firstLineOf(lines),
+		frame,
+		...lines.slice(1)
+	].join("\n");
+	return error;
+};
+/** @internal */
+const withRaisingFrame = Function.dual(2, withRaisingFrameImpl);
+//#endregion
+//#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, site) => ({
+	actual,
+	message,
+	negated: false,
+	written,
+	site
+});
+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 judgedBy = (view, property, args, make) => {
+	const assertion = make(view.actual, view.message);
+	const target = view.negated ? assertion.not : assertion;
+	invokeMember(target, property, args);
+};
+const raisedFailure = (thrown, site) => thrown instanceof Error ? withRaisingFrame(thrown, site) : thrown;
+/**
+* A failed judgement is a failure the fork raised: by now the stack holds only the fork's frames, so the site the
+* body called `expect` from is prepended to the error's stack (R2, KTD6).
+*/
+const judgementOf = (view, property, args) => (make) => {
+	try {
+		judgedBy(view, property, args, make);
+	} catch (thrown) {
+		throw raisedFailure(thrown, view.site);
+	}
+};
+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]), callFrame()));
+};
+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, callFrameOutside as c, framesOf as d, isUserPath as f, checksFor as i, callSite as l, vitestTestContextKey as n, makeLedger as o, withRaisingFrame as p, Asserted as r, callFrame as s, VitestTestContext as t, firstUserSiteOf as u };

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@systemfsoftware/vitest",
   "license": "MIT",
-  "version": "0.0.0",
+  "version": "0.2.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
-    "directory": "packages/vitest"
+    "directory": "packages/runner/vitest"
   },
-  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/vitest#readme",
+  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/runner/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,22 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.mjs"
     },
-    "./refusals": {
-      "types": "./dist/refusals.d.ts",
-      "default": "./dist/refusals.mjs"
+    "./failure": {
+      "types": "./dist/failure.d.ts",
+      "default": "./dist/failure.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": [
@@ -44,7 +48,7 @@
   ],
   "devDependencies": {
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
-    "@systemfsoftware/oxlint-config-recommended": "^3.1.0",
+    "@systemfsoftware/oxlint-config-recommended": "^3.2.0",
     "@systemfsoftware/tsconfig": "^2.0.1",
     "@systemfsoftware/tsdown-config": "^0.1.0",
     "@systemfsoftware/vitest-config": "^0.1.0",
@@ -61,6 +65,7 @@
     "vitest": "^5"
   },
   "publishConfig": {
+    "access": "public",
     "provenance": true
   },
   "scripts": {

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 };