@systemfsoftware/storybook-gherkin 3.0.4 → 3.0.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @systemfsoftware/storybook-gherkin
 
+## 3.0.6
+
+### Patch Changes
+
+- Bump the stryker catalog to pull in the latest patch releases of the stryker-js ecosystem.
+
+## 3.0.5
+
+### Patch Changes
+
+- Dependencies resolve to Effect 4.0.0-rc.116 and Vitest 5.
+
 ## 3.0.4
 
 ### Patch Changes

package/dist/index.d.ts

@@ -5,7 +5,6 @@ import { screen as screen_2 } from 'storybook/test';
 import { Simplify } from 'type-fest';
 import { UnionToIntersection } from 'type-fest';
 import { UserEventObject } from 'storybook/test';
-import { within } from 'storybook/test';
 import { YieldableError } from 'effect/Cause';
 
 export declare const And: StepCtor;
@@ -19,7 +18,7 @@ declare const BackgroundNotGiven_base: Schema.Class<BackgroundNotGiven, Schema.T
 
 export declare const But: StepCtor;
 
-export declare type Canvas = ReturnType<typeof within>;
+export declare type Canvas = typeof screen_2;
 
 export declare type CapsOf<THoles extends readonly Hole[]> = THoles extends readonly [] ? {} : Simplify<UnionToIntersection<{ [K in keyof THoles]: THoles[K] extends Capture<infer N, infer A> ? { [P in N]: A; } : {}; }[number]>>;
 

package/dist/index.mjs

@@ -3,11 +3,12 @@ import { screen } from "storybook/test";
 //#region src/Capture.ts
 const CaptureTag = { _tag: "Capture" };
 function capture(name, options) {
+	const resolved = options ?? {};
 	return {
 		...CaptureTag,
 		name,
-		schema: options?.schema,
-		default: options?.default
+		schema: resolved.schema,
+		default: resolved.default
 	};
 }
 //#endregion
@@ -67,9 +68,22 @@ var CaptureDecodeFailed = class extends Schema.TaggedError()("CaptureDecodeFaile
 }) {};
 //#endregion
 //#region src/Steps.ts
-const joinStep = (step, renderHole) => [step.parts[0] ?? "", ...step.captures.flatMap((cap, i) => [renderHole(cap), step.parts[i + 1] ?? ""])].join("");
+const emptyIfMissing = (part) => {
+	if (part === void 0) return "";
+	return part;
+};
+const joinStep = (step, renderHole) => [emptyIfMissing(step.parts[0]), ...step.captures.flatMap((cap, i) => [renderHole(cap), emptyIfMissing(step.parts[i + 1])])].join("");
 const displayPattern = (step) => joinStep(step, (cap) => `{${cap.name}}`);
-const renderStepText = (step, values) => joinStep(step, (cap) => values[cap.name] ?? cap.default ?? `{${cap.name}}`);
+const firstString = (left, right) => {
+	if (left !== void 0) return left;
+	return right;
+};
+const holeText = (cap, values) => {
+	const fromValues = values[cap.name];
+	if (fromValues !== void 0) return fromValues;
+	return firstString(cap.default, `{${cap.name}}`);
+};
+const renderStepText = (step, values) => joinStep(step, (cap) => holeText(cap, values));
 const resolveKeyword = (keyword, previous) => Match.value(keyword).pipe(Match.when("Given", () => "Given"), Match.when("When", () => "When"), Match.when("Then", () => "Then"), Match.when("And", () => previous), Match.when("But", () => previous), Match.when("Star", () => previous), Match.exhaustive);
 const resolveKeywords = (steps) => {
 	return Array$1.mapAccum(steps, "Given", (previous, s) => {
@@ -82,44 +96,63 @@ const resolveKeywords = (steps) => {
 };
 const STEP_TAG = "Step";
 const StepTag = { _tag: STEP_TAG };
+const partAt = (statics, index) => emptyIfMissing(statics[index]);
+const appendLiteral = (current, literal, trailing) => current + literal + trailing;
+const consumeNonStringHole = (current, hole, trailing, parts, captures) => {
+	if (typeof hole === "number") return appendLiteral(current, String(hole), trailing);
+	parts.push(current);
+	captures.push({
+		name: hole.name,
+		schema: hole.schema,
+		default: hole.default
+	});
+	return trailing;
+};
+const consumeHole = (current, hole, trailing, parts, captures) => {
+	if (typeof hole === "string") return appendLiteral(current, hole, trailing);
+	return consumeNonStringHole(current, hole, trailing, parts, captures);
+};
+const rememberCapture = (model, seen, cap) => {
+	if (seen.has(cap.name)) throw DuplicateCapture.make({
+		step: displayPattern(model),
+		name: cap.name
+	});
+	seen.add(cap.name);
+};
+const assertUniqueCaptures = (model, captures) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const cap of captures) rememberCapture(model, seen, cap);
+};
 const buildModel = (keyword, statics, holes) => {
 	const parts = [];
 	const captures = [];
-	let current = statics[0] ?? "";
-	for (const [i, hole] of holes.entries()) if (typeof hole === "string") current += hole + (statics[i + 1] ?? "");
-	else if (typeof hole === "number") current += String(hole) + (statics[i + 1] ?? "");
-	else {
-		parts.push(current);
-		current = statics[i + 1] ?? "";
-		captures.push({
-			name: hole.name,
-			schema: hole.schema,
-			default: hole.default
-		});
-	}
+	let current = partAt(statics, 0);
+	for (const [i, hole] of holes.entries()) current = consumeHole(current, hole, partAt(statics, i + 1), parts, captures);
 	parts.push(current);
 	const model = {
 		keyword,
 		parts,
 		captures
 	};
-	const seen = /* @__PURE__ */ new Set();
-	for (const cap of captures) {
-		if (seen.has(cap.name)) throw DuplicateCapture.make({
-			step: displayPattern(model),
-			name: cap.name
-		});
-		seen.add(cap.name);
-	}
+	assertUniqueCaptures(model, captures);
 	return model;
 };
+const captureRaw = (cap, values) => {
+	const fromValues = values[cap.name];
+	if (fromValues !== void 0) return fromValues;
+	return cap.default;
+};
+const rawOrEmpty = (raw) => {
+	if (raw === void 0) return "";
+	return raw;
+};
 const decodeCapture = (cap, values, model) => {
-	const raw = values[cap.name] ?? cap.default;
+	const raw = captureRaw(cap, values);
 	if (cap.schema === void 0) return Effect.succeed(raw);
 	return Schema.decodeEffect(cap.schema)(raw).pipe(Effect.mapError((error) => CaptureDecodeFailed.make({
 		step: displayPattern(model),
 		capture: cap.name,
-		value: raw ?? "",
+		value: rawOrEmpty(raw),
 		cause: error
 	})));
 };
@@ -146,13 +179,28 @@ const Then = makeStepCtor("Then");
 const And = makeStepCtor("And");
 const But = makeStepCtor("But");
 const Star = makeStepCtor("Star");
+const isNonNullObject = (value) => {
+	if (typeof value !== "object") return false;
+	return value !== null;
+};
+const hasModelAndRun = (value) => {
+	if (!("model" in value)) return false;
+	return "run" in value;
+};
+const hasStepFields = (value) => {
+	if (Reflect.get(value, "_tag") !== STEP_TAG) return false;
+	return hasModelAndRun(value);
+};
 const isStep = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	return Reflect.get(value, "_tag") === STEP_TAG && "model" in value && "run" in value;
+	if (!isNonNullObject(value)) return false;
+	return hasStepFields(value);
 };
 //#endregion
 //#region src/Feature.ts
-const displayKeyword = (model) => model.keyword === "Star" ? "*" : model.keyword;
+const displayKeyword = (model) => {
+	if (model.keyword === "Star") return "*";
+	return model.keyword;
+};
 const buildStepContext = (ctx) => ({
 	canvas: ctx.canvas,
 	screen,
@@ -167,12 +215,6 @@ const buildStepContext = (ctx) => ({
 	reporting: ctx.reporting,
 	context: ctx
 });
-/**
-* Total classification of an interpreted program's `Exit`, shared by the play
-* edge and the step bridge: interruption resolves silently, success returns
-* the value, and any other cause is rethrown as the original error instance
-* (`Cause.squash`) so Storybook's panel keeps the matcher diff.
-*/
 const squashExit = (exit) => Exit.match(exit, {
 	onSuccess: (value) => value,
 	onFailure: (cause) => {
@@ -180,17 +222,6 @@ const squashExit = (exit) => Exit.match(exit, {
 		throw Cause.squash(cause);
 	}
 });
-/**
-* One scenario step, composed as an Effect. Storybook's instrumented `step`
-* expects a promise whose settlement tracks the step's work, so the body runs
-* in a child fiber that settles a deferred; the bridge promise given to
-* `stepCtx.step` awaits that deferred and rejects with the step's original error.
-* The bridge interprets only this pure signalling effect; user code runs in
-* the single play-edge interpretation. The `ensuring` finalizer interrupts
-* the child on every parent exit — success (no-op on a joined fiber),
-* failure, and interruption — so an independently failed `stepCtx.step` never
-* orphans a running step body.
-*/
 const runStep = (step, values, stepCtx) => {
 	const label = `${displayKeyword(step.model)} ${renderStepText(step.model, values)}`;
 	return Deferred.make().pipe(Effect.flatMap((done) => {
@@ -202,7 +233,6 @@ const executeSteps = (ordered, values, ctx) => {
 	const stepCtx = buildStepContext(ctx);
 	return Effect.forEach(ordered, (s) => runStep(s, values, stepCtx), { discard: true });
 };
-/** The single interpretation edge of the package. */
 const interpretPlay = (context, program, ctx) => Effect.runPromiseExitWith(context)(program, { signal: ctx.abortSignal }).then(squashExit);
 const rowValuesFor = (row) => Object.fromEntries(Object.entries(row).filter(([k]) => k !== "name"));
 const sortKeys = (keys) => {
@@ -210,41 +240,95 @@ const sortKeys = (keys) => {
 	sorted.sort();
 	return sorted;
 };
-const validateScenarioSteps = (fullName, models, withRecord) => {
+const assertNonEmptyScenario = (fullName, models) => {
 	if (models.length === 0) throw EmptyScenario.make({ scenario: fullName });
-	if (!resolveKeywords(models).some((r) => r.resolved === "Then")) throw MissingThen.make({ scenario: fullName });
-	for (const stepModel of models) for (const cap of stepModel.captures) {
-		const hasDefault = cap.default !== void 0;
-		const hasWith = Object.prototype.hasOwnProperty.call(withRecord, cap.name);
-		if (!hasDefault && !hasWith) throw UnresolvedCapture.make({
-			scenario: fullName,
-			step: displayPattern(stepModel),
-			capture: cap.name
-		});
-	}
+};
+const isThen = (r) => r.resolved === "Then";
+const assertHasThen = (fullName, models) => {
+	if (!resolveKeywords(models).some(isThen)) throw MissingThen.make({ scenario: fullName });
+};
+const captureIsBound = (cap, withRecord) => {
+	if (cap.default !== void 0) return true;
+	return Object.prototype.hasOwnProperty.call(withRecord, cap.name);
+};
+const assertCaptureBound = (fullName, stepModel, cap, withRecord) => {
+	if (captureIsBound(cap, withRecord)) return;
+	throw UnresolvedCapture.make({
+		scenario: fullName,
+		step: displayPattern(stepModel),
+		capture: cap.name
+	});
+};
+const assertCapturesBound = (fullName, stepModel, withRecord) => {
+	for (const cap of stepModel.captures) assertCaptureBound(fullName, stepModel, cap, withRecord);
+};
+const validateScenarioSteps = (fullName, models, withRecord) => {
+	assertNonEmptyScenario(fullName, models);
+	assertHasThen(fullName, models);
+	for (const stepModel of models) assertCapturesBound(fullName, stepModel, withRecord);
 };
 const isScenarioOptions = (value) => !isStep(value) && !Array.isArray(value);
-const parseScenarioArgs = (rest) => {
+const optionsIfPresent = (firstArg) => {
+	if (!isScenarioOptions(firstArg)) return void 0;
+	return firstArg;
+};
+const readOptions = (rest) => {
 	const firstArg = rest[0];
-	const options = firstArg !== void 0 && isScenarioOptions(firstArg) ? firstArg : void 0;
-	const body = options === void 0 ? rest : rest.slice(1);
-	const steps = [];
-	for (const item of body) if (isStep(item)) steps.push(item);
-	else if (Array.isArray(item)) for (const inner of item) {
-		if (!isStep(inner)) throw new TypeError(`Steps group contains a non-step value of type ${typeof inner}`);
-		steps.push(inner);
+	if (firstArg === void 0) return void 0;
+	return optionsIfPresent(firstArg);
+};
+const bodyAfterOptions = (rest, options) => {
+	if (options === void 0) return rest;
+	return rest.slice(1);
+};
+const pushInnerStep = (steps, inner) => {
+	if (!isStep(inner)) throw new TypeError(`Steps group contains a non-step value of type ${typeof inner}`);
+	steps.push(inner);
+};
+const pushStepGroup = (steps, item) => {
+	for (const inner of item) pushInnerStep(steps, inner);
+};
+const pushIfGroup = (steps, item) => {
+	if (Array.isArray(item)) {
+		pushStepGroup(steps, item);
+		return;
+	}
+	throw new TypeError(`Scenario arguments must be steps or step groups; got type ${typeof item}`);
+};
+const pushScenarioItem = (steps, item) => {
+	if (isStep(item)) {
+		steps.push(item);
+		return;
 	}
-	else throw new TypeError(`Scenario arguments must be steps or step groups; got type ${typeof item}`);
+	pushIfGroup(steps, item);
+};
+const parseScenarioArgs = (rest) => {
+	const options = readOptions(rest);
+	const body = bodyAfterOptions(rest, options);
+	const steps = [];
+	for (const item of body) pushScenarioItem(steps, item);
 	return {
 		options,
 		steps
 	};
 };
+const qualifyName = (prefix, name) => {
+	if (prefix === "") return name;
+	return `${prefix}: ${name}`;
+};
+const recordOrEmpty = (value) => {
+	if (value === void 0) return {};
+	return value;
+};
+const withRecordOf = (options) => {
+	if (options === void 0) return {};
+	return recordOrEmpty(options.with);
+};
 const makeScenario = (background, prefix, context) => {
 	function scenario(name, ...rest) {
 		const { options, steps } = parseScenarioArgs(rest);
-		const fullName = prefix === "" ? name : `${prefix}: ${name}`;
-		const withRecord = options?.with ?? {};
+		const fullName = qualifyName(prefix, name);
+		const withRecord = withRecordOf(options);
 		validateScenarioSteps(fullName, steps.map((s) => s.model), withRecord);
 		return {
 			name: fullName,
@@ -253,40 +337,77 @@ const makeScenario = (background, prefix, context) => {
 	}
 	return scenario;
 };
-const validateOutlineRows = (rows, captureNames, fullName) => {
+const assertOutlineNonEmpty = (rows, fullName) => {
 	if (rows.length === 0) throw OutlineEmpty.make({ outline: fullName });
+};
+const isNotName = (k) => k !== "name";
+const keysExceptName = (row) => sortKeys(Object.keys(row).filter(isNotName));
+const firstRowKeys = (rows) => {
+	const first = rows[0];
+	if (first === void 0) return [];
+	return keysExceptName(first);
+};
+const rememberRowName = (seen, row, fullName) => {
+	if (seen.has(row.name)) throw OutlineDuplicateRowName.make({
+		outline: fullName,
+		name: row.name
+	});
+	seen.add(row.name);
+};
+const keyAtMatches = (actual, expected, i) => actual[i] === expected[i];
+const keysMatch = (actual, expected) => {
+	if (actual.length !== expected.length) return false;
+	return actual.every((_, i) => keyAtMatches(actual, expected, i));
+};
+const assertKeysConsistent = (row, firstKeys, fullName) => {
+	const actual = keysExceptName(row);
+	if (keysMatch(actual, firstKeys)) return;
+	throw OutlineInconsistentKeys.make({
+		outline: fullName,
+		row: row.name,
+		expected: [...firstKeys],
+		actual: [...actual]
+	});
+};
+const assertRowHasCapture = (row, cap, fullName) => {
+	if (Object.prototype.hasOwnProperty.call(row, cap)) return;
+	throw OutlineMissingCapture.make({
+		outline: fullName,
+		row: row.name,
+		capture: cap
+	});
+};
+const assertRowCaptures = (row, captureNames, fullName) => {
+	for (const cap of captureNames) assertRowHasCapture(row, cap, fullName);
+};
+const validateOneRow = (seenRowNames, row, firstKeys, captureNames, fullName) => {
+	rememberRowName(seenRowNames, row, fullName);
+	assertKeysConsistent(row, firstKeys, fullName);
+	assertRowCaptures(row, captureNames, fullName);
+};
+const validateOutlineRows = (rows, captureNames, fullName) => {
+	assertOutlineNonEmpty(rows, fullName);
 	const seenRowNames = /* @__PURE__ */ new Set();
-	const firstKeys = sortKeys(Object.keys(rows[0] ?? {}).filter((k) => k !== "name"));
-	for (const row of rows) {
-		if (seenRowNames.has(row.name)) throw OutlineDuplicateRowName.make({
-			outline: fullName,
-			name: row.name
-		});
-		seenRowNames.add(row.name);
-		const actual = sortKeys(Object.keys(row).filter((k) => k !== "name"));
-		if (actual.length !== firstKeys.length || actual.some((k, i) => k !== firstKeys[i])) throw OutlineInconsistentKeys.make({
-			outline: fullName,
-			row: row.name,
-			expected: [...firstKeys],
-			actual: [...actual]
-		});
-		for (const cap of captureNames) if (!Object.prototype.hasOwnProperty.call(row, cap)) throw OutlineMissingCapture.make({
-			outline: fullName,
-			row: row.name,
-			capture: cap
-		});
-	}
+	const firstKeys = firstRowKeys(rows);
+	for (const row of rows) validateOneRow(seenRowNames, row, firstKeys, captureNames, fullName);
+};
+const addModelCaptures = (captureNames, m) => {
+	for (const c of m.captures) captureNames.add(c.name);
+};
+const collectCaptureNames = (models) => {
+	const captureNames = /* @__PURE__ */ new Set();
+	for (const m of models) addModelCaptures(captureNames, m);
+	return captureNames;
 };
 const makeOutline = (background, prefix, context) => {
 	function outline(name, ...rest) {
 		const { options, steps } = parseScenarioArgs(rest);
-		const fullName = prefix === "" ? name : `${prefix}: ${name}`;
-		const withRecord = options?.with ?? {};
+		const fullName = qualifyName(prefix, name);
+		const withRecord = withRecordOf(options);
 		const models = steps.map((s) => s.model);
-		if (models.length === 0) throw EmptyScenario.make({ scenario: fullName });
-		if (!resolveKeywords(models).some((r) => r.resolved === "Then")) throw MissingThen.make({ scenario: fullName });
-		const captureNames = /* @__PURE__ */ new Set();
-		for (const m of models) for (const c of m.captures) captureNames.add(c.name);
+		assertNonEmptyScenario(fullName, models);
+		assertHasThen(fullName, models);
+		const captureNames = collectCaptureNames(models);
 		const buildRowSpec = (row) => {
 			const values = {
 				...withRecord,
@@ -307,17 +428,24 @@ const makeOutline = (background, prefix, context) => {
 	}
 	return outline;
 };
+const assertResolvedGiven = (step, resolved) => {
+	if (resolved === "Given") return;
+	throw BackgroundNotGiven.make({
+		step: displayPattern(step.model),
+		resolved
+	});
+};
+const assertBackgroundResolved = (step, resolvedEntry) => {
+	if (resolvedEntry === void 0) return;
+	assertResolvedGiven(step, resolvedEntry.resolved);
+};
+const assertBackgroundStep = (step, resolvedEntry) => {
+	if (step === void 0) return;
+	assertBackgroundResolved(step, resolvedEntry);
+};
 const makeBackground = (background) => (...steps) => {
 	const resolvedKeywords = resolveKeywords(steps.map((s) => s.model));
-	for (let i = 0; i < steps.length; i++) {
-		const step = steps[i];
-		const resolvedEntry = resolvedKeywords[i];
-		if (step === void 0 || resolvedEntry === void 0) continue;
-		if (resolvedEntry.resolved !== "Given") throw BackgroundNotGiven.make({
-			step: displayPattern(step.model),
-			resolved: resolvedEntry.resolved
-		});
-	}
+	for (let i = 0; i < steps.length; i++) assertBackgroundStep(steps[i], resolvedKeywords[i]);
 	background.push(...steps);
 };
 const makeFeature = (meta, context) => {
@@ -334,13 +462,17 @@ const makeFeature = (meta, context) => {
 		})
 	};
 };
+const contextOf = (options) => {
+	if (options.context === void 0) return Context.empty();
+	return options.context;
+};
 /**
 * Declare a feature: a story set whose scenarios execute as CSF `play`
 * functions. `options.context` (default `Context.empty()`) is the Effect
 * context interpreting each scenario's composed step program exactly once,
 * at the play edge.
 */
-const feature = (meta, options = {}) => makeFeature(meta, options.context ?? Context.empty());
+const feature = (meta, options = {}) => makeFeature(meta, contextOf(options));
 const Steps = (...steps) => [...steps];
 const From = (story) => {
 	const play = story.play;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/storybook-gherkin",
   "license": "Apache-2.0",
-  "version": "3.0.4",
+  "version": "3.0.6",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -36,42 +36,44 @@
     "dist"
   ],
   "dependencies": {
-    "type-fest": "^5.8.0"
+    "type-fest": "^5.10.0"
   },
   "peerDependencies": {
-    "effect": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.116",
     "storybook": ">=10.0.0"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.58.7",
-    "@storybook/addon-vitest": "^10.5.0",
-    "@storybook/react-vite": "^10.5.0",
-    "@systemfsoftware/arethetypeswrong-cli": "^4.1.0",
-    "@types/node": "^24",
-    "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.4",
-    "@vitest/browser": "^4",
-    "@vitest/browser-playwright": "^4",
-    "effect": "4.0.0-rc.112",
-    "oxlint": "^1.77.0",
+    "@microsoft/api-extractor": "^7.59.1",
+    "@storybook/addon-vitest": "^10.6.0",
+    "@storybook/react-vite": "^10.6.0",
+    "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
+    "@types/node": "^26",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitest/browser": "^5",
+    "@vitest/browser-playwright": "^5",
+    "effect": "4.0.0-rc.116",
+    "oxlint": "~1.82.0",
     "playwright": "^1",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
     "rimraf": "^6.1.3",
-    "storybook": "^10.5.0",
-    "tsdown": "^0.22.14",
+    "storybook": "^10.6.0",
+    "tsdown": "^0.23.0",
     "typescript": "^7",
     "vite": "^8",
-    "vitest": "^4",
+    "vitest": "^5",
+    "@systemfsoftware/all": "^2.1.2",
     "@systemfsoftware/oxlint-config": "^0.1.0",
-    "@systemfsoftware/tsconfig": "^1.3.4"
+    "@systemfsoftware/tsdown-config": "^0.1.0",
+    "@systemfsoftware/tsconfig": "^1.3.6"
   },
   "publishConfig": {
     "provenance": true
   },
   "scripts": {
     "clean": "rimraf dist",
-    "build": "tsdown && pnpm dts:check && pnpm api:check",
+    "build": "tsdown -l warn && pnpm dts:check && pnpm api:check",
     "typecheck": "tsc --noEmit --incremental",
     "lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --config oxlint.config.ts --format=${f:-default}",
     "lint:tsgo": "effect-tsgo diagnostics --project tsconfig.json --format ${TSGO_FORMAT:-text}",
@@ -79,7 +81,7 @@
     "dts:check": "node scripts/check-dts.mjs",
     "storybook": "storybook dev -p 6006 --no-open",
     "test:browser": "pnpm build && vitest run",
-    "api:check": "tsdown && api-extractor run",
+    "api:check": "tsdown -l warn && api-extractor-quiet run",
     "api:update": "api-extractor run --local"
   }
 }