@systemfsoftware/vitest 0.1.0 → 0.2.0

package/dist/{test-context-hvSoKLtw.mjs → test-context-ChvjVyCo.mjs}

@@ -1,9 +1,118 @@
 
-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 { 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
@@ -42,11 +151,12 @@ const forView = (view, negated) => ({
 	negated
 });
 const notView = (view) => forView(view, !view.negated);
-const viewFor = (written, actual, message) => ({
+const viewFor = (written, actual, message, site) => ({
 	actual,
 	message,
 	negated: false,
-	written
+	written,
+	site
 });
 const messageOf = (argument) => typeof argument === "string" ? argument : void 0;
 const refuseBooleanActual = (actual) => typeof actual === "boolean";
@@ -73,11 +183,23 @@ 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 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) => {
@@ -117,7 +239,7 @@ const viewHandler = (view) => ({ get: (_target, property) => memberFor(view, pro
 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])));
+	return matcherView(viewFor(written, args[0], messageOf(args[1]), callFrame()));
 };
 const isDecodingSchema = (value) => Schema.isSchema(value);
 const asMatcher = (value) => {
@@ -203,4 +325,4 @@ const vitestTestContextKey = "@systemfsoftware/vitest/TestContext";
 */
 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 };
+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,14 +1,14 @@
 {
   "name": "@systemfsoftware/vitest",
   "license": "MIT",
-  "version": "0.1.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: 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": [
@@ -25,6 +25,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.mjs"
     },
+    "./failure": {
+      "types": "./dist/failure.d.ts",
+      "default": "./dist/failure.mjs"
+    },
     "./guard": {
       "types": "./dist/guard.d.ts",
       "default": "./dist/guard.mjs"
@@ -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": {