breakage 0.8.5 → 0.9.1

package/dist/release-BsdIDT4g.js

@@ -0,0 +1,69 @@
+import semver from "semver";
+import { type } from "arktype";
+// src/release.ts
+const releaseSchema = type({
+	"+": `reject`,
+	"resolveDelta?": type(`Function`).as(),
+	"policy?": type(`Function`).as()
+});
+/** Choose which version increments permit breaking changes. Prerelease-only increments do not. */
+function semverPolicy({ beforeV1 = `major` } = {}) {
+	if (![
+		`major`,
+		`minor`,
+		`patch`
+	].includes(beforeV1)) throw new Error(`Invalid beforeV1 policy.`);
+	return ({ previousVersion, version }) => {
+		const previous = new semver.SemVer(previousVersion);
+		const next = new semver.SemVer(version);
+		if (next.major > previous.major) return true;
+		if (previous.major !== 0 || beforeV1 === `major`) return false;
+		return next.minor > previous.minor || beforeV1 === `patch` && next.patch > previous.patch;
+	};
+}
+/** Describe a version transition without deciding whether it permits breakage. */
+function versionTransition(previousVersion, version) {
+	if (!semver.valid(previousVersion) || !semver.valid(version)) throw new Error(`Expected exact semantic versions.`);
+	return {
+		previousVersion,
+		version,
+		delta: semver.diff(previousVersion, version) ?? `none`
+	};
+}
+/** Pure comparison; equal and older versions never permit breaking changes. */
+function versionDelta(previousVersion, version, policy = semverPolicy()) {
+	const evidence = versionTransition(previousVersion, version);
+	const breaking = semver.gt(version, previousVersion) ? policy(evidence) : false;
+	if (typeof breaking !== `boolean`) throw new Error(`Release policy must return a boolean.`);
+	return {
+		...evidence,
+		breaking
+	};
+}
+function validateRelease(value) {
+	if (typeof value !== `object` || value === null || Array.isArray(value)) throw new Error(`release must be an object.`);
+	if (`version` in value) throw new Error(`release.version was removed. Use release.resolveDelta to return a version transition.`);
+	releaseSchema.assert(value);
+}
+/** Resolve and validate release evidence; policy is applied separately. */
+async function resolveReleaseDelta(config, context) {
+	validateRelease(config);
+	const transition = config.resolveDelta ? await config.resolveDelta(context) : versionTransition(context.baseline?.version ?? context.currentVersion, context.currentVersion);
+	if (transition === void 0) return void 0;
+	if (typeof transition !== `object` || transition === null || Array.isArray(transition) || typeof transition.previousVersion !== `string` || !semver.valid(transition.previousVersion) || typeof transition.version !== `string` || !semver.valid(transition.version) || !semver.valid(context.currentVersion) || semver.lt(transition.version, context.currentVersion)) throw new Error(`Invalid release transition for ${context.packageName}; expected exact versions and a current/newer target.`);
+	if (context.baseline && transition.previousVersion !== context.baseline.version) throw new Error(`Release transition for ${context.packageName} does not match the selected baseline.`);
+	const evidence = versionTransition(transition.previousVersion, transition.version);
+	if (transition.delta !== evidence.delta) throw new Error(`Release transition for ${context.packageName} has an inconsistent semver delta.`);
+	return evidence;
+}
+/** Removed hooks must fail explicitly, including in untyped configurations. */
+function rejectCertificationOptions(value) {
+	for (const key of [
+		`certifyCommand`,
+		`releaseIntent`,
+		`certifyBreaking`
+	]) if (key in value) throw new Error(`${key} was removed. Use release.resolveDelta and release.policy instead.`);
+}
+export { validateRelease as a, semverPolicy as i, releaseSchema as n, versionDelta as o, resolveReleaseDelta as r, versionTransition as s, rejectCertificationOptions as t };
+
+//# sourceMappingURL=release-BsdIDT4g.js.map

package/dist/release-BsdIDT4g.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-BsdIDT4g.js","names":[],"sources":["../src/release.ts"],"sourcesContent":["// cspell:words premajor preminor prepatch\nimport semver from \"semver\"\nimport { type } from \"arktype\"\n\nexport type ReleaseDeltaContext = {\n\tpackageName: string\n\tpackageDirectory: string\n\tcurrentVersion: string\n\t/** The selected historical release, when checking compatibility. */\n\tbaseline?: { version: string; ref?: string; commit?: string }\n}\nexport type VersionTransition = {\n\tpreviousVersion: string\n\tversion: string\n\tdelta:\n\t\t| `major`\n\t\t| `premajor`\n\t\t| `minor`\n\t\t| `preminor`\n\t\t| `patch`\n\t\t| `prepatch`\n\t\t| `prerelease`\n\t\t| `release`\n\t\t| `none`\n}\nexport type ReleaseDeltaResolver = (\n\tcontext: ReleaseDeltaContext,\n) => VersionTransition | undefined | Promise<VersionTransition | undefined>\nexport type VersionDelta = VersionTransition & { breaking: boolean }\nexport type SemverPolicyOptions = { beforeV1?: `major` | `minor` | `patch` }\nexport type ReleasePolicyFunction = (delta: VersionTransition) => boolean\nexport type ReleasePolicy = ReleasePolicyFunction\nexport const releaseSchema = type({\n\t\"+\": `reject`,\n\t\"resolveDelta?\": type(`Function`).as<ReleaseDeltaResolver>(),\n\t\"policy?\": type(`Function`).as<ReleasePolicy>(),\n})\nexport type ReleaseConfig = typeof releaseSchema.infer\n\n/** Choose which version increments permit breaking changes. Prerelease-only increments do not. */\nexport function semverPolicy({\n\tbeforeV1 = `major`,\n}: SemverPolicyOptions = {}): ReleasePolicyFunction {\n\tif (![`major`, `minor`, `patch`].includes(beforeV1))\n\t\tthrow new Error(`Invalid beforeV1 policy.`)\n\treturn ({ previousVersion, version }) => {\n\t\tconst previous = new semver.SemVer(previousVersion)\n\t\tconst next = new semver.SemVer(version)\n\t\tif (next.major > previous.major) return true\n\t\tif (previous.major !== 0 || beforeV1 === `major`) return false\n\t\treturn (\n\t\t\tnext.minor > previous.minor ||\n\t\t\t(beforeV1 === `patch` && next.patch > previous.patch)\n\t\t)\n\t}\n}\n\n/** Describe a version transition without deciding whether it permits breakage. */\nexport function versionTransition(\n\tpreviousVersion: string,\n\tversion: string,\n): VersionTransition {\n\tif (!semver.valid(previousVersion) || !semver.valid(version))\n\t\tthrow new Error(`Expected exact semantic versions.`)\n\treturn {\n\t\tpreviousVersion,\n\t\tversion,\n\t\tdelta: semver.diff(previousVersion, version) ?? `none`,\n\t}\n}\n\n/** Pure comparison; equal and older versions never permit breaking changes. */\nexport function versionDelta(\n\tpreviousVersion: string,\n\tversion: string,\n\tpolicy: ReleasePolicy = semverPolicy(),\n): VersionDelta {\n\tconst evidence = versionTransition(previousVersion, version)\n\tconst breaking = semver.gt(version, previousVersion)\n\t\t? policy(evidence)\n\t\t: false\n\tif (typeof breaking !== `boolean`)\n\t\tthrow new Error(`Release policy must return a boolean.`)\n\treturn { ...evidence, breaking }\n}\n\nexport function validateRelease(\n\tvalue: unknown,\n): asserts value is ReleaseConfig {\n\tif (typeof value !== `object` || value === null || Array.isArray(value))\n\t\tthrow new Error(`release must be an object.`)\n\tif (`version` in value)\n\t\tthrow new Error(\n\t\t\t`release.version was removed. Use release.resolveDelta to return a version transition.`,\n\t\t)\n\treleaseSchema.assert(value)\n}\n\n/** Resolve and validate release evidence; policy is applied separately. */\nexport async function resolveReleaseDelta(\n\tconfig: ReleaseConfig,\n\tcontext: ReleaseDeltaContext,\n): Promise<VersionTransition | undefined> {\n\tvalidateRelease(config)\n\tconst transition = config.resolveDelta\n\t\t? await config.resolveDelta(context)\n\t\t: versionTransition(\n\t\t\t\tcontext.baseline?.version ?? context.currentVersion,\n\t\t\t\tcontext.currentVersion,\n\t\t\t)\n\tif (transition === undefined) return undefined\n\tif (\n\t\ttypeof transition !== `object` ||\n\t\ttransition === null ||\n\t\tArray.isArray(transition) ||\n\t\ttypeof transition.previousVersion !== `string` ||\n\t\t!semver.valid(transition.previousVersion) ||\n\t\ttypeof transition.version !== `string` ||\n\t\t!semver.valid(transition.version) ||\n\t\t!semver.valid(context.currentVersion) ||\n\t\tsemver.lt(transition.version, context.currentVersion)\n\t)\n\t\tthrow new Error(\n\t\t\t`Invalid release transition for ${context.packageName}; expected exact versions and a current/newer target.`,\n\t\t)\n\tif (\n\t\tcontext.baseline &&\n\t\ttransition.previousVersion !== context.baseline.version\n\t)\n\t\tthrow new Error(\n\t\t\t`Release transition for ${context.packageName} does not match the selected baseline.`,\n\t\t)\n\tconst evidence = versionTransition(\n\t\ttransition.previousVersion,\n\t\ttransition.version,\n\t)\n\tif (transition.delta !== evidence.delta)\n\t\tthrow new Error(\n\t\t\t`Release transition for ${context.packageName} has an inconsistent semver delta.`,\n\t\t)\n\t// Only evidence crosses this boundary; resolver-supplied policy decisions are ignored.\n\treturn evidence\n}\n\n/** Removed hooks must fail explicitly, including in untyped configurations. */\nexport function rejectCertificationOptions(value: object): void {\n\tfor (const key of [`certifyCommand`, `releaseIntent`, `certifyBreaking`]) {\n\t\tif (key in value)\n\t\t\tthrow new Error(\n\t\t\t\t`${key} was removed. Use release.resolveDelta and release.policy instead.`,\n\t\t\t)\n\t}\n}\n"],"mappings":";;;AAgCA,MAAa,gBAAgB,KAAK;CACjC,KAAK;CACL,iBAAiB,KAAK,UAAU,CAAC,CAAC,GAAyB;CAC3D,WAAW,KAAK,UAAU,CAAC,CAAC,GAAkB;AAC/C,CAAC;;AAID,SAAgB,aAAa,EAC5B,WAAW,YACa,CAAC,GAA0B;CACnD,IAAI,CAAC;EAAC;EAAS;EAAS;CAAO,CAAC,CAAC,SAAS,QAAQ,GACjD,MAAM,IAAI,MAAM,0BAA0B;CAC3C,QAAQ,EAAE,iBAAiB,cAAc;EACxC,MAAM,WAAW,IAAI,OAAO,OAAO,eAAe;EAClD,MAAM,OAAO,IAAI,OAAO,OAAO,OAAO;EACtC,IAAI,KAAK,QAAQ,SAAS,OAAO,OAAO;EACxC,IAAI,SAAS,UAAU,KAAK,aAAa,SAAS,OAAO;EACzD,OACC,KAAK,QAAQ,SAAS,SACrB,aAAa,WAAW,KAAK,QAAQ,SAAS;CAEjD;AACD;;AAGA,SAAgB,kBACf,iBACA,SACoB;CACpB,IAAI,CAAC,OAAO,MAAM,eAAe,KAAK,CAAC,OAAO,MAAM,OAAO,GAC1D,MAAM,IAAI,MAAM,mCAAmC;CACpD,OAAO;EACN;EACA;EACA,OAAO,OAAO,KAAK,iBAAiB,OAAO,KAAK;CACjD;AACD;;AAGA,SAAgB,aACf,iBACA,SACA,SAAwB,aAAa,GACtB;CACf,MAAM,WAAW,kBAAkB,iBAAiB,OAAO;CAC3D,MAAM,WAAW,OAAO,GAAG,SAAS,eAAe,IAChD,OAAO,QAAQ,IACf;CACH,IAAI,OAAO,aAAa,WACvB,MAAM,IAAI,MAAM,uCAAuC;CACxD,OAAO;EAAE,GAAG;EAAU;CAAS;AAChC;AAEA,SAAgB,gBACf,OACiC;CACjC,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GACrE,MAAM,IAAI,MAAM,4BAA4B;CAC7C,IAAI,aAAa,OAChB,MAAM,IAAI,MACT,uFACD;CACD,cAAc,OAAO,KAAK;AAC3B;;AAGA,eAAsB,oBACrB,QACA,SACyC;CACzC,gBAAgB,MAAM;CACtB,MAAM,aAAa,OAAO,eACvB,MAAM,OAAO,aAAa,OAAO,IACjC,kBACA,QAAQ,UAAU,WAAW,QAAQ,gBACrC,QAAQ,cACT;CACF,IAAI,eAAe,KAAA,GAAW,OAAO,KAAA;CACrC,IACC,OAAO,eAAe,YACtB,eAAe,QACf,MAAM,QAAQ,UAAU,KACxB,OAAO,WAAW,oBAAoB,YACtC,CAAC,OAAO,MAAM,WAAW,eAAe,KACxC,OAAO,WAAW,YAAY,YAC9B,CAAC,OAAO,MAAM,WAAW,OAAO,KAChC,CAAC,OAAO,MAAM,QAAQ,cAAc,KACpC,OAAO,GAAG,WAAW,SAAS,QAAQ,cAAc,GAEpD,MAAM,IAAI,MACT,kCAAkC,QAAQ,YAAY,sDACvD;CACD,IACC,QAAQ,YACR,WAAW,oBAAoB,QAAQ,SAAS,SAEhD,MAAM,IAAI,MACT,0BAA0B,QAAQ,YAAY,uCAC/C;CACD,MAAM,WAAW,kBAChB,WAAW,iBACX,WAAW,OACZ;CACA,IAAI,WAAW,UAAU,SAAS,OACjC,MAAM,IAAI,MACT,0BAA0B,QAAQ,YAAY,mCAC/C;CAED,OAAO;AACR;;AAGA,SAAgB,2BAA2B,OAAqB;CAC/D,KAAK,MAAM,OAAO;EAAC;EAAkB;EAAiB;CAAiB,GACtE,IAAI,OAAO,OACV,MAAM,IAAI,MACT,GAAG,IAAI,mEACR;AAEH"}

package/dist/release-D47BqRuB.d.ts

@@ -0,0 +1,40 @@
+type ReleaseDeltaContext = {
+  packageName: string;
+  packageDirectory: string;
+  currentVersion: string;
+  /** The selected historical release, when checking compatibility. */
+  baseline?: {
+    version: string;
+    ref?: string;
+    commit?: string;
+  };
+};
+type VersionTransition = {
+  previousVersion: string;
+  version: string;
+  delta: `major` | `premajor` | `minor` | `preminor` | `patch` | `prepatch` | `prerelease` | `release` | `none`;
+};
+type ReleaseDeltaResolver = (context: ReleaseDeltaContext) => VersionTransition | undefined | Promise<VersionTransition | undefined>;
+type VersionDelta = VersionTransition & {
+  breaking: boolean;
+};
+type SemverPolicyOptions = {
+  beforeV1?: `major` | `minor` | `patch`;
+};
+type ReleasePolicyFunction = (delta: VersionTransition) => boolean;
+type ReleasePolicy = ReleasePolicyFunction;
+declare const releaseSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+  resolveDelta?: ReleaseDeltaResolver;
+  policy?: ReleasePolicyFunction;
+}, {}>;
+type ReleaseConfig = typeof releaseSchema.infer;
+/** Choose which version increments permit breaking changes. Prerelease-only increments do not. */
+declare function semverPolicy({ beforeV1 }?: SemverPolicyOptions): ReleasePolicyFunction;
+/** Describe a version transition without deciding whether it permits breakage. */
+declare function versionTransition(previousVersion: string, version: string): VersionTransition;
+/** Pure comparison; equal and older versions never permit breaking changes. */
+declare function versionDelta(previousVersion: string, version: string, policy?: ReleasePolicy): VersionDelta;
+/** Resolve and validate release evidence; policy is applied separately. */
+declare function resolveReleaseDelta(config: ReleaseConfig, context: ReleaseDeltaContext): Promise<VersionTransition | undefined>;
+export { ReleasePolicyFunction as a, VersionTransition as c, versionDelta as d, versionTransition as f, ReleasePolicy as i, resolveReleaseDelta as l, ReleaseDeltaContext as n, SemverPolicyOptions as o, ReleaseDeltaResolver as r, VersionDelta as s, ReleaseConfig as t, semverPolicy as u };
+//# sourceMappingURL=release-D47BqRuB.d.ts.map

package/dist/release-D47BqRuB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-D47BqRuB.d.ts","names":[],"sources":["../src/release.ts"],"mappings":"A,KAIY;EACX;EACA;EACA;;EAEA;IAAa;IAAiB;IAAc;;;KAEjC;EACX;EACA;EACA;;KAWW,wBACX,SAAS,wBACL,gCAAgC,QAAQ;KACjC,eAAe;EAAsB;;KACrC;EAAwB;;KACxB,yBAAyB,OAAO;KAChC,gBAAgB;cACf,6DAAa;;;;KAKd,uBAAuB,cAAc;;iBAGjC,eACf,aACE,sBAA2B;;iBAgBd,kBACf,yBACA,kBACE;;iBAWa,aACf,yBACA,iBACA,SAAQ,gBACN;;iBAuBmB,oBACrB,QAAQ,eACR,SAAS,sBACP,QAAQ"}

package/npm.md

@@ -2,7 +2,7 @@
 
 Use `breakage npm` to test a packed package against the peer versions you declare. This is an optional npm-specific feature. The ordinary public check and its four adoption conditions remain the same; keep that check required alongside peer compatibility.
 
-Consider an integration with `"atom.io": "^1 || ^2"`. Its current workspace tests may pass against an edited core, even if only the integration will ship. Representative environments let it prove compatibility with actual released versions. An explicitly registered candidate environment can additionally prove conditional compatibility with a core release your release plan certifies.
+Consider an integration with `"atom.io": "^1 || ^2"`. Its current workspace tests may pass against an edited core, even if only the integration will ship. Representative environments let it prove compatibility with actual released versions. An explicitly registered candidate environment can additionally prove conditional compatibility with a core release your release plan identifies.
 
 The npm commands require Node 22.18 or newer (including native erasable TypeScript for `.ts` configuration), Git, and your installation/test tools. They run on the filesystem, inside complete representative directories. They do not publish packages.
 
@@ -30,7 +30,7 @@ In the integration package, create complete environments for the peer formulatio
 }
 ```
 
-Pin every dependency in an environment manifest to an exact version: `"host": "1.0.0"` and `"host": "2.1.4"` are valid; `"host": "^1"` and `"host": "^1 || ^2"` are setup errors. This applies to all entries in `dependencies`, `devDependencies`, `optionalDependencies`, and `peerDependencies`, including test runners and helpers. Exact prerelease and build versions are allowed. Ranges, wildcards, tags, aliases, workspace protocols, and file or URL specifiers are rejected before installation. The integration's own `peerDependencies` still express its supported eras with ranges. Enroll coordinated local releases through `breakage.candidates`; their certified intended versions supply the exact identities, and any accompanying dependency pins must match those versions.
+Pin every dependency in an environment manifest to an exact version: `"host": "1.0.0"` and `"host": "2.1.4"` are valid; `"host": "^1"` and `"host": "^1 || ^2"` are setup errors. This applies to all entries in `dependencies`, `devDependencies`, `optionalDependencies`, and `peerDependencies`, including test runners and helpers. Exact prerelease and build versions are allowed. Ranges, wildcards, tags, aliases, workspace protocols, and file or URL specifiers are rejected before installation. The integration's own `peerDependencies` still express its supported eras with ranges. Enroll coordinated local releases through `breakage.candidates`; their resolved intended versions supply the exact identities, and any accompanying dependency pins must match those versions.
 
 Choose real published versions appropriate for your package. Install once and commit this directory's manifest and lock file. Add any test runner and helpers it needs to its own development dependencies with exact pins. Give each additional formulation its own directory and lock file. Every required peer of the integration must be present; several coupled peers share one environment. Include all intended representatives in the glob, including multiple representatives of the same era.
 
@@ -89,7 +89,7 @@ export default {
 }
 ```
 
-Every file glob must select at least one regular file. Remove the fixture glob if you have no fixtures. `packageDirectory` defaults to the config file's directory; all npm paths resolve from that package directory. Glob discovery uses paths as labels and installed versions as evidence. Register local peer directories in `localPeers`; each declared local peer must have a suite, and its certified upcoming releases must be supported and exercised by a coordinated representative. External peer suites are an explicit opt-in. No matrix is inferred from registry metadata.
+Every file glob must select at least one regular file. Remove the fixture glob if you have no fixtures. `packageDirectory` defaults to the config file's directory; all npm paths resolve from that package directory. Glob discovery uses paths as labels and installed versions as evidence. Register local peer directories in `localPeers`; each declared local peer must have a suite, and its planned upcoming releases must be supported and exercised by a coordinated representative. External peer suites are an explicit opt-in. No matrix is inferred from registry metadata.
 
 The previous manifest comes from the newest matching release tag. An existing core `baselineFile` may pin a fetched release. For a package's first publication, explicitly use `baseline: { firstRelease: true }` and remove that exception after publishing; missing baseline evidence never silently passes.
 
@@ -103,9 +103,9 @@ breakage npm test --representative peer-environments/core-1
 breakage npm check --config ./breakage.config.ts --json
 ```
 
-All matching representatives run. Every explicit `||` era needs coverage. Preview versions cover only an exact preview alternative, not stable ranges or other previews. Build metadata does not affect range matching, including exact preview selection; installed versions must still match their complete environment pins. Released representatives outside declared support warn; excluding a planned local release fails the release check. Focused requests can intentionally explore versions outside declared support. An audit reports declarations and release-policy findings without claiming assertions passed. Exit statuses are 0 for successful requested work, 1 for compatibility or uncertified support failures, and 2 for setup or coverage errors.
+All matching representatives run. Every explicit `||` era needs coverage. Preview versions cover only an exact preview alternative, not stable ranges or other previews. Build metadata does not affect range matching, including exact preview selection; installed versions must still match their complete environment pins. Released representatives outside declared support warn; excluding a planned local release fails the release check. Focused requests can intentionally explore versions outside declared support. An audit reports declarations and release-policy findings without claiming assertions passed. Exit statuses are 0 for successful requested work, 1 for compatibility or unapproved support failures, and 2 for setup or coverage errors.
 
-Focused peer/range requests validate manifest pins and skip versions outside the requested range before acquiring stages or preparing dependencies. Coordinated candidates are selected by their certified intended versions, and exact-preview selection follows the same rules as coverage. Excluded environments need no lockfile or available stage. Disjoint requests for the same peer can run independently in one checkout without parsing lock files. Requests that select the same environment still contend for its stage, including requests for different peers in a coupled environment. Selected installations retain all frozen-input, identity, and compatibility checks.
+Focused peer/range requests validate manifest pins and skip versions outside the requested range before acquiring stages or preparing dependencies. Coordinated candidates are selected by their resolved intended versions, and exact-preview selection follows the same rules as coverage. Excluded environments need no lockfile or available stage. Disjoint requests for the same peer can run independently in one checkout without parsing lock files. Requests that select the same environment still contend for its stage, including requests for different peers in a coupled environment. Selected installations retain all frozen-input, identity, and compatibility checks.
 
 ## Coordinated releases
 
@@ -122,54 +122,76 @@ Create a separate representative that explicitly names candidate peers. Leave an
 }
 ```
 
-Add a typed `releaseIntent` callback to the npm configuration. This example reads a repository-owned JSON release plan; adapt it to Changesets or your release process. The function receives `packageName`, `packageDirectory`, and `currentVersion`, and may return synchronously or asynchronously:
+Set `release.resolveDelta` to a synchronous/asynchronous resolver receiving `packageName`, `packageDirectory`, and `currentVersion`. For Changesets, use the optional helper:
 
 ```ts
-import { readFile } from "node:fs/promises"
-import type { NpmConfig } from "breakage"
+import { changesetsReleaseDelta } from "breakage/changesets"
+import { semverPolicy } from "breakage"
 
-const releaseIntent: NonNullable<NpmConfig["releaseIntent"]> = async ({
-	packageName,
-}) => {
-	const plan = JSON.parse(
-		await readFile(new URL("./release-plan.json", import.meta.url), "utf8"),
-	)
-	const version = plan[packageName]
-	return version ? { status: "release", version } : { status: "none" }
+const release = {
+	resolveDelta: changesetsReleaseDelta(),
+	policy: semverPolicy({ beforeV1: "minor" }),
 }
 ```
 
-Missing intent blocks that candidate environment. Inspection errors and invalid evidence are setup errors, not absent intent. Intended versions must be exact and at least the current workspace version. The candidate archive may have its workspace version or the intended version. Breakage reports both versions. If they differ, it substitutes the intended version in the installed peer's disposable manifest using a fresh file and atomic replacement, preserving shared cache files, other environments, the archive, and the workspace. Archives already carrying their intended version need no substitution.
+Assign this object to `npm.release`, or share it at the top level with `defineConfig`. A custom resolver returns `{ previousVersion, version, delta }` or `undefined`; errors must throw. Missing intent blocks that candidate environment. Inspection errors and invalid evidence are setup errors, not absent intent. Both transition versions must be exact, the target must be at least the current workspace version, and the delta must match the versions. Candidate identity uses the transition's `version`; no breaking-change policy is applied to candidate enrollment. The candidate archive may have its workspace version or the intended version. Breakage reports both versions. If they differ, it substitutes the intended version in the installed peer's disposable manifest using a fresh file and atomic replacement, preserving shared cache files, other environments, the archive, and the workspace. Archives already carrying their intended version need no substitution.
 
-That substitution simulates release metadata; it does not rebuild the package or change version constants embedded in executable code. Your build owns those constants. To exercise the final version metadata directly, supply a peer archive already built with the certified intended version.
+That substitution simulates release metadata; it does not rebuild the package or change version constants embedded in executable code. Your build owns those constants. To exercise the final version metadata directly, supply a peer archive already built with the resolved intended version.
 
-Both `npm check` and its coverage-only audit inspect each currently declared `localPeers` package's release intent, even if you omitted its candidate environment. A certified intended version must be included in the integration's peer range and covered by a coordinated representative. Missing either fails with exit 2; an installed peer at the same version does not substitute for testing the local candidate. Optional local peers have the same obligation when declared. Hook errors and invalid evidence fail setup. Hooks are evaluated once per package per invocation, and must return that package's own release intent.
+Both `npm check` and its coverage-only audit inspect each currently declared `localPeers` package's release intent, even if you omitted its candidate environment. A resolved intended version must be included in the integration's peer range and covered by a coordinated representative. Missing either fails with exit 2; an installed peer at the same version does not substitute for testing the local candidate. Optional local peers have the same obligation when declared. Resolver errors and invalid evidence fail setup. Resolvers are evaluated once per package and baseline context per invocation, and must return that package's own release intent.
 
-For a core still labeled `0.53.3` with a planned `0.54.0` release, an integration declaring only `^0.53.3` fails. Adding `|| ^0.54.0` is recommended when retaining the older era. Admission uses version membership: `0.54.0`, `*`, and other ranges containing that version qualify too. Exact-preview enrollment, coverage of other declared eras, and certification for dropping old support still apply. Your release hook supplies the intended version before a versioning PR is merged; Breakage does not infer it from an open PR.
+For a core still labeled `0.53.3` with a planned `0.54.0` release, an integration declaring only `^0.53.3` fails. Adding `|| ^0.54.0` is recommended when retaining the older era. Admission uses version membership: `0.54.0`, `*`, and other ranges containing that version qualify too. Exact-preview enrollment, coverage of other declared eras, and breaking release evidence for dropping old support still apply. Your delta resolver supplies the intended transition before a versioning PR is merged; Breakage does not infer it from an open PR.
 
 Candidate results are conditional on publication. They can cover a new era, but cannot excuse an incompatible released version that the integration still advertises. Unreleased local edits with no release intent create no new coordination obligation. Registering a currently declared local peer means the integration must accommodate its planned releases. Registrations retained only for historical resolution do not impose this obligation after the peer declaration is removed. The repository owns publication order.
 
-Every coordinated candidate must also accept the representative's peer versions in its own normalized `peerDependencies`. For example, a candidate declaring `minimatch: ^8` cannot be approved alongside Minimatch 9, even if the integration declares `^9` and its assertions pass. Both full checks and coverage audits reject that conflict before candidate installation with exit 2, identifying the candidate, required range, and observed version. The representative must supply required peers needed only by a coordinated candidate too; these additional identities do not require separate integration suites. Absent optional peers are allowed, but present optional peers must satisfy their ranges. Another coordinated peer contributes its certified intended version; a peer on the integration itself uses the integration's current archive version.
+Every coordinated candidate must also accept the representative's peer versions in its own normalized `peerDependencies`. For example, a candidate declaring `minimatch: ^8` cannot be approved alongside Minimatch 9, even if the integration declares `^9` and its assertions pass. Both full checks and coverage audits reject that conflict before candidate installation with exit 2, identifying the candidate, required range, and observed version. The representative must supply required peers needed only by a coordinated candidate too; these additional identities do not require separate integration suites. Absent optional peers are allowed, but present optional peers must satisfy their ranges. Another coordinated peer contributes its resolved intended version; a peer on the integration itself uses the integration's current archive version.
 
 Focused `npm test` commands remain available for exploration before advertising an upcoming version. They warn about coordinated candidates' incompatible peer ranges and still execute, while missing required peers remain setup errors. They check release intent for the selected candidate environments but do not audit every planned local release; require the full check or coverage audit as part of the release gate.
 
-## Removing support
+## Shared release configuration
 
-`npm check` compares semantic version sets with the previous release. Narrowing a supported range, adding a new required peer, or making an optional peer required produces an end-of-support finding. Equivalent range rewrites do not. Removing a peer requirement entirely relaxes consumer constraints. Preview support is compared too. Optional-peer absence testing is deferred; making an existing optional peer required is still detected as an installation-contract change.
-
-To accept intentional support changes, provide both release intent for the integration and an explicit breaking-release policy:
+Use `defineConfig` to share a release resolver and policy with public checks:
 
 ```ts
-const certifyBreaking: NonNullable<NpmConfig["certifyBreaking"]> = ({
-	previousVersion,
-	release,
-}) =>
-	previousVersion.startsWith("0.")
-		? release.delta === "minor" || release.delta === "major"
-		: release.delta === "major"
+import { defineConfig, semverPolicy } from "breakage"
+import { changesetsReleaseDelta } from "breakage/changesets"
+
+export default defineConfig({
+	testPattern: "tests/public/**/*",
+	test: "npm run test:public",
+	release: {
+		resolveDelta: changesetsReleaseDelta(),
+		policy: semverPolicy({ beforeV1: "minor" }),
+	},
+	npm: {
+		artifact: "artifacts/integration.tgz",
+		representatives: "peer-environments/*",
+		lockfile: "package-lock.json",
+		prepareCommand: "npm ci --ignore-scripts --workspaces=false",
+		suites: {
+			"atom.io": {
+				files: ["contracts/core/**/*.ts"],
+				command: "node --test contracts/core/*.test.ts",
+			},
+		},
+		baseline: { tagPattern: "refs/tags/my-integration@" },
+	},
+})
 ```
 
-This callback also receives `changes`, with each peer's previous and current declaration. It must return a boolean; throwing fails setup. Public breakage is still handled by the ordinary public command's certification. Compatibility failures against still-declared peers cannot be certified away.
+`defineConfig` inherits the top-level `release` into `npm.release`; an explicit `npm.release` overrides it. Programmatic callers can pass the resulting `config.npm` to `npmCheck` or `npmTest`. Both npm and public CLI commands use the same config loader. npm paths remain relative to the config file's directory, or to `npm.packageDirectory` resolved from it.
+
+`npm.release.resolveDelta` replaces `releaseIntent` and returns `{ previousVersion, version, delta }` or `undefined`. Resolution is cached per package and baseline context for each npm invocation. Support checks supply `baseline: { version }` from the integration's historical manifest; Breakage rejects a transition whose `previousVersion` disagrees with that baseline. Local-peer candidate checks have no historical baseline and use the transition's target version for candidate identity and coordination obligations. `changesetsReleaseDelta()` is a factory that returns the resolver, comparing the supplied baseline (or current manifest) with the planned version before Changesets versioning and the manifest version afterward. Because the manifest fallback also supplies a target for an unchanged registered local peer, using it opts those peers into candidate coverage too. A custom resolver can return `undefined` for packages that should have no local release intent. See the [release configuration guide](README.md#typescript-configuration-and-release-intent) for optional Changesets dependencies and standalone helpers.
+
+`npm.release.policy` replaces `certifyBreaking`. The default requires a major increment; `semverPolicy({ beforeV1: "minor" })` permits pre-1.0 minor increments too. Missing evidence or a compatible version delta leaves a support drop unapproved. Invalid evidence and resolver/policy errors fail setup. Compatibility failures against still-declared peers remain failures even when the integration has a breaking release. The old `releaseIntent` and `certifyBreaking` hooks are removed and fail with migration guidance. Policies must be functions and receive `{ previousVersion, version, delta }`.
+
+`prepareCommand`, `installCommand`, and each suite's `command` are nonempty shell strings. Preparation runs in the representative directory; installation and suites run in its disposable `test/` directory. Breakage captures stdout and stderr for reporting. All nonzero preparation/installation results fail setup; suite exit 1 denotes incompatibility and other nonzero exits denote setup failure. Release-delta resolvers and policies are functions; the optional matrix's archive preparation accepts a command or function.
+
+## Removing support
+
+`npm check` compares semantic version sets with the previous release. Narrowing a supported range, adding a new required peer, or making an optional peer required produces an end-of-support finding. Equivalent range rewrites do not. Removing a peer requirement entirely relaxes consumer constraints. Preview support is compared too. Optional-peer absence testing is deferred; making an existing optional peer required is still detected as an installation-contract change.
+
+The shared `release` model accepts intentional support changes when the integration has a breaking version delta against its previous release. Reports use support status `breaking-release` and include `{ previousVersion, version, delta, breaking }` in `support.release`. Missing intent or a compatible delta leaves support changes unapproved. Resolver or policy exceptions fail setup. Public checks use the same release model; compatibility failures against still-declared peers always remain failures.
 
 ## Installation, isolation, and recovery
 
@@ -189,26 +211,158 @@ Tests, candidate packages, and their runtime dependencies must resolve the same
 
 ## CI and caching
 
-Keep the existing public check as `test:breakage` and add the npm check to that release gate, or use `test:breakage:npm` for a separate required job. Preparation must build and pack every participating candidate. A developer-owned matrix can run one configured representative per job, plus an audit job:
+Keep the existing public check as `test:breakage` and add the npm check to that release gate, or use `test:breakage:npm` for a separate required job. For a local package, `npm check` still performs the complete check without a matrix plan. For a repository with several packages or distributed runners, use the optional plan → execute → verify protocol below. CI owns scheduling and artifact transport; Breakage owns discovery, audits, candidate identity, and receipt verification.
+
+### Configure and plan a matrix
+
+Keep each package's existing `npm` configuration, representative manifests/lock files, and contracts. Add this to the root `breakage.config.ts`:
+
+```ts
+import { defineConfig } from "breakage"
+
+export default defineConfig({
+	npmMatrix: {
+		configs: ["packages/*/breakage.config.ts"],
+		prepare: "pnpm exec turbo run pack:breakage",
+		label: ({ packageName, description, representative }) =>
+			`${packageName}: ${description ?? representative}`,
+	},
+})
+```
+
+`configs` is a root-relative glob or list of globs. Only matched configs with an `npm` section participate; a package is discovered once even when patterns overlap. Package names must be unique. Root matrix configuration does not implicitly supply release hooks to package configs: share `release` through a TypeScript module and `defineConfig` as usual. Each required peer needs a relationship suite, each declared era needs coverage, and every selected representative must have executable audited suites. Keep exploratory environments outside the matrix's configured representative globs.
+
+`prepare` runs once after the coverage/support audits. Use your existing build/pack task to create the exact `artifact` paths in the package configs, including registered local peers. It must not alter tracked sources, manifests, lock files, contracts, or release evidence. Tool choice and dependency build order remain yours. Alternatively, provide an async function receiving `{ rootDirectory, archives }`; each deduplicated archive request contains `{ packageName, directory, artifact }`, with both paths relative to the root. Its return value is ignored, and throwing fails planning. `label` is optional and receives package name, representative path, optional manifest description, and audited peers; the default is `packageName: representative`.
+
+Use a clean Git checkout and ignore generated archives, `.breakage/npm-plan/`, `.breakage/receipts/`, and each representative's `test/` directory. Commit the intended source/config changes before planning. All package inputs and configured archive paths must stay within the checkout. The root must be the Git checkout root; the default is the current directory. Planning requires baseline tags or pinned baseline files and the same Changesets/tool dependencies as the package checks. With `changesetsReleaseDelta()`, both pending changesets and versioned manifests supply the existing release evidence; no matrix-specific release script is needed.
+
+```sh
+breakage npm plan --config breakage.config.ts --out .breakage/npm-plan
+# stdout is one JSON object: {"include":[{"id":"...","label":"...",...}]}
+# Copy an id from that output; execute every id before verifying.
+breakage npm execute <id> --plan .breakage/npm-plan/plan.json --receipt .breakage/receipts/<id>.json
+breakage npm verify --plan .breakage/npm-plan/plan.json --receipts '.breakage/receipts/*.json'
+```
+
+`plan` writes `plan.json` and content-addressed archives into the bundle directory, defaulting to `.breakage/npm-plan`. `--root` changes the checkout root for all three commands; config, output, plan, and receipt paths resolve from it. Quoting the receipt glob lets Breakage collect all matching files, including duplicates from different runners. Empty discovery, uncovered eras, unapproved support changes, and preparation failures are errors. A failed re-plan removes the previous `plan.json` in that output directory. After cancellation, discard the incomplete bundle and inspect/remove its `.lock` directory before retrying.
+
+The plan has `formatVersion: 1`, a fresh run identity, source commit, configuration and input fingerprints, release evidence, coverage/support audits, expected environments/suites/peer identities, and archive SHA-256 digests. Its `id` binds the complete payload. Execution consumes the bundled archives directly; workers do not repack or restore archives over workspace outputs. Each receipt has `formatVersion: 1`, `planId`, environment `id`, `exitCode`, and a report or setup error. Environment IDs remain stable for a config/representative path, while plan IDs change on every planning run.
+
+Execution rechecks the source, configuration, representative discovery, contract/manifests/lockfile inputs, release evidence, and archive digests before and after running the shared npm test engine with exactly the planned suites. A representative can contain a peer outside its declared support range while covering another peer; matrix execution omits that unsupported relationship's suite, matching the audit. Full peer identity and configuration validation still apply. Explicit `npm test --representative` exploration continues to run every configured suite whose peer is present. A valid plan produces a failure receipt on ordinary setup or compatibility failure. An invalid/unreadable plan or killed process may produce no receipt; that cannot satisfy verification. Assertions retain exit 1, setup failures exit 2, and successful execution exits 0. Planning and aggregate verification return 0 on success and 2 on any failure.
+
+### Use the same protocol from TypeScript
+
+```ts
+import { readFile } from "node:fs/promises"
+import { npmPlan, npmMatrix, npmExecute, npmVerify } from "breakage"
+import config from "./breakage.config.ts"
+
+const location = { rootDirectory: process.cwd() }
+if (!config.npmMatrix) throw new Error("Configure npmMatrix first.")
+const plan = await npmPlan(config.npmMatrix, location)
+const receipts = []
+for (const { id } of npmMatrix(plan).include) {
+	receipts.push(await npmExecute(plan, id, location))
+}
+const result = await npmVerify(plan, receipts, location)
+process.exitCode = result.exitCode
+
+// Another runner can load the transported bundle without depending on its old path.
+const transportedPlan: unknown = JSON.parse(
+	await readFile(".breakage/npm-plan/plan.json", "utf8"),
+)
+```
+
+The exported types are `NpmMatrixConfig`, `NpmPrepareContext`, `NpmArchiveRequest`, `NpmMatrixLabelContext`, `NpmMatrixLocation`, `NpmPlan`, `NpmReceipt`, and `NpmVerification`. `npmVerify` validates the checkout and bundle as well as receipts. `verifyNpmReceipts(plan, receipts)` provides pure structural/audit/receipt verification for custom orchestrators that independently validate source/config/archive identity. It does not inspect the filesystem. Receipt order and runner-local installed paths do not affect either verifier.
+
+### Distribute the matrix in CI
+
+This GitHub Actions example assumes your existing `./.github/actions/setup` installs pinned Node/package-manager versions and frozen workspace dependencies. Keep the plan bundle and receipts specific to the current workflow run; fetch release history in every checkout. The verify job must require successful planning and execution jobs as well as complete receipts, so cancellation or skipped jobs cannot reuse old success. Keep the ordinary public check required separately.
 
 ```yaml
+name: Peer compatibility
+on: [pull_request]
+permissions:
+  contents: read
 jobs:
-  npm-audit:
+  plan:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.plan.outputs.matrix }}
     steps:
-      # Checkout, install tools/dependencies, and prepare release evidence first.
-      - run: breakage npm check --coverage-only
-  npm-contracts:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/setup
+      - id: plan
+        run: |
+          matrix=$(pnpm exec breakage npm plan)
+          echo "matrix=$matrix" >> "$GITHUB_OUTPUT"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: peer-plan
+          path: .breakage/npm-plan/
+          include-hidden-files: true
+          if-no-files-found: error
+  execute:
+    needs: plan
+    runs-on: ubuntu-latest
+    name: ${{ matrix.label }}
     strategy:
       fail-fast: false
-      matrix:
-        representative: [peer-environments/core-1, peer-environments/core-2]
+      matrix: ${{ fromJSON(needs.plan.outputs.matrix) }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/setup
+      - uses: actions/download-artifact@v4
+        with:
+          name: peer-plan
+          path: .breakage/npm-plan/
+      - env:
+          ENVIRONMENT_ID: ${{ matrix.id }}
+        run: pnpm exec breakage npm execute "$ENVIRONMENT_ID" --plan .breakage/npm-plan/plan.json --receipt ".breakage/receipts/$ENVIRONMENT_ID.json"
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: peer-receipt-${{ matrix.id }}
+          path: .breakage/receipts/
+          include-hidden-files: true
+          if-no-files-found: error
+  verify:
+    name: Peer compatibility
+    if: always()
+    needs: [plan, execute]
+    runs-on: ubuntu-latest
     steps:
-      # Checkout, install tools/dependencies, and build/pack candidates first.
-      - run: breakage npm test --representative "${{ matrix.representative }}"
+      - env:
+          PLAN_RESULT: ${{ needs.plan.result }}
+          EXECUTION_RESULT: ${{ needs.execute.result }}
+        run: test "$PLAN_RESULT" = success && test "$EXECUTION_RESULT" = success
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/setup
+      - uses: actions/download-artifact@v4
+        with:
+          name: peer-plan
+          path: .breakage/npm-plan/
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: peer-receipt-*
+          path: .breakage/receipts/
+      - run: pnpm exec breakage npm verify --plan .breakage/npm-plan/plan.json --receipts '.breakage/receipts/**/*.json'
 ```
 
-This is a job excerpt: add your runner, checkout, setup, and working directory. Require the audit, all matrix jobs, and the public check before release. Updating the authored representative list requires updating the required matrix. Breakage neither generates workflows nor aggregates cross-job receipts.
+Keep downloaded receipt artifacts in separate subdirectories: merging them could overwrite duplicate filenames before the verifier sees them. Require the stable aggregate `Peer compatibility` job. Pin action references according to your repository policy. Other CI systems can transport the same JSON and archive bundle, schedule `npmMatrix(plan).include`, and run the same commands.
+
+### Remove repository-specific orchestration
+
+For atom.io-style scripts, replace discovery/coverage commands with `npm plan`, archive collection and copying with its bundle, per-environment wrappers with `npm execute`, and custom receipt validation with `npm verify`. Delete the custom plan/receipt types, hashing, suite enumeration, and aggregate verifier tests once the repository uses the protocol. Keep package configs/shared release helpers, authored peer environments/contracts, the build/pack task, tool setup, and CI artifact transport. No workspace manager, task runner, Changesets versioning, or CI provider is invoked implicitly.
+
+Verification rejects missing, duplicate, unexpected, malformed, stale, failed, or skipped receipts; wrong package/peer identities; audit reports substituted for execution; and missing, duplicate, unexecuted, or failing suites. It validates coverage/support audits as well as executions. The protocol checks consistency within trusted CI, not cryptographic attestation of an untrusted worker: a worker able to fabricate both plans and receipts can fabricate success. Commands, hooks, environment variables, and external services remain repository-owned inputs; use identical toolchains and deterministic hooks across jobs.
 
-Start uncached. A correct cache key includes candidate/peer archives, suite files, representative manifests and lock files, observed installation identities, configuration and imported helpers, baseline, release-plan inputs, and command/environment/toolchain inputs. Unknown dynamic input means the check stays uncached. There is no new npm prelude or mandatory execution plan.
+Start uncached. A correct cache key includes candidate/peer archives, suite files, representative manifests and lock files, observed installation identities, configuration and imported helpers, baseline, release-plan inputs, and command/environment/toolchain inputs. Unknown dynamic input means the check stays uncached. Do not reuse execution receipts across planning runs. There is no new npm prelude, and the matrix protocol is optional.
 
 Programmatic consumers can import `npmCheck`, `npmTest`, `formatNpmReport`, and their exported types from `breakage`. Both check functions return a structured `NpmReport` with `exitCode`, coverage, support findings, and independent representative/suite results; `mode` distinguishes audit from execution.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breakage",
-  "version": "0.8.5",
+  "version": "0.9.1",
   "description": "Run yesterday’s tests against tomorrow’s release.",
   "homepage": "https://github.com/jeremybanka/breakage#readme",
   "bugs": "https://github.com/jeremybanka/breakage/issues",
@@ -15,6 +15,17 @@
     "email": "hello@jeremybanka.com"
   },
   "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/breakage.d.ts",
+      "default": "./dist/breakage.js"
+    },
+    "./changesets": {
+      "types": "./dist/changesets.d.ts",
+      "default": "./dist/changesets.js"
+    },
+    "./*": "./*"
+  },
   "main": "dist/breakage.js",
   "types": "dist/breakage.d.ts",
   "bin": {
@@ -26,26 +37,54 @@
     "src"
   ],
   "dependencies": {
-    "arktype": "2.2.8",
-    "comline": "0.9.0",
+    "arktype": "2.2.9",
+    "comline": "0.9.3",
     "minimatch": "10.2.6",
     "semver": "7.8.5",
     "simple-git": "4.0.2",
     "takua": "0.2.3"
   },
   "devDependencies": {
-    "@types/bun": "npm:bun-types@1.4.3",
+    "@changesets/assemble-release-plan": "7.0.0",
+    "@changesets/config": "4.0.1",
+    "@changesets/pre": "3.0.0",
+    "@changesets/read": "1.0.1",
+    "@manypkg/get-packages": "3.1.0",
+    "@types/bun": "npm:bun-types@1.4.4",
     "@types/semver": "7.8.0",
     "typescript": "7.0.2"
   },
+  "peerDependencies": {
+    "@changesets/assemble-release-plan": "^7.0.0",
+    "@changesets/config": "^4.0.1",
+    "@changesets/pre": "^3.0.0",
+    "@changesets/read": "^1.0.1",
+    "@manypkg/get-packages": "^3.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@changesets/assemble-release-plan": {
+      "optional": true
+    },
+    "@changesets/config": {
+      "optional": true
+    },
+    "@changesets/pre": {
+      "optional": true
+    },
+    "@changesets/read": {
+      "optional": true
+    },
+    "@manypkg/get-packages": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "vp pack && vp run schema",
+    "build": "vp pack",
     "check": "vp run -w check",
     "postversion": "dprint fmt package.json",
-    "schema": "bun src/breakage.x.ts --outdir=dist -- schema",
     "test": "vp run test:run",
     "test:public": "BREAKAGE_CLI_ENTRYPOINT=./src/breakage.x.ts bun test -- ./tests/public",
     "test:watch": "vp run test:run --watch"