@systemfsoftware/vitest-config 0.0.0-bootstrap.0 → 0.1.3

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# @systemfsoftware/vitest-config
+
+# @systemfsoftware/vitest-config@0.1.3
+
+Lists @systemfsoftware/vitest/property-defaults beside the guard in every package's setupFiles, so direct Arbitrary checks take the configured run count.

package/LICENSE

@@ -0,0 +1,203 @@
+Copyright (c) 2026 Ryan Lee (systemfsoftware)
+
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Ryan Lee (systemfsoftware)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,41 @@
 # @systemfsoftware/vitest-config
 
-Published from https://github.com/systemfsoftware/systemfsoftware.
+The Vitest configuration System F Software packages share: CI-aware timeouts and reporters, coverage settings, source-condition resolution, and a `defineConfig` that adds the `@systemfsoftware/vitest` guard to every block that runs tests.
+
+## Install
+
+Add it as a devDependency together with its peers and the guard's package. It is distributed as a workspace tarball of the [systemfsoftware flake](https://github.com/systemfsoftware/systemfsoftware) (`packages.<system>.vitest-config`), which `lib.mkConsumerStore` serves to an offline pnpm install.
+
+| Package                   | Range                        |
+| ------------------------- | ---------------------------- |
+| `vitest` (peer)           | `^5`                         |
+| `vite` (peer)             | `^8`                         |
+| `@systemfsoftware/vitest` | the flake's `vitest` tarball |
+
+`@systemfsoftware/vitest` must be a direct devDependency of the package whose tests run: `defineConfig` looks for it in that package's own `node_modules`.
+
+## Usage
+
+```ts
+// vitest.config.ts
+import { defineConfig } from '@systemfsoftware/vitest-config'
+
+export default defineConfig({ test: { include: ['tests/**/*.test.ts'] } })
+```
+
+`defineConfig` returns a promise, because finding the guard reads the file system. Vitest accepts a promised config.
+
+When the guard is missing, config load fails instead of running the tests unguarded, and the error names the `package.json` to fix.
+
+## Exports
+
+| Export                    | What it is                                                                              |
+| ------------------------- | --------------------------------------------------------------------------------------- |
+| `defineConfig`            | Vitest's `defineConfig` with the guard setup file and the fork's provided context added |
+| `sharedConfig`            | the shared `test` settings, for a config that does not use `defineConfig`               |
+| `sourceResolveConditions` | resolve conditions that read a workspace sibling's source instead of its build          |
+| `isCI`                    | whether the run is classified as CI                                                     |
+
+## License
+
+[Apache-2.0](./LICENSE)

package/lib/base.d.ts

@@ -0,0 +1,13 @@
+import type { ViteUserConfig } from 'vitest/config'
+
+declare const sourceResolveConditions: ViteUserConfig
+declare const sharedConfig: ViteUserConfig
+declare const isCI: boolean
+/**
+ * Vitest's `defineConfig` with the guard and the fork's provided context added to every block that runs
+ * tests. Resolving the guard reads the file system, so the config it returns is a promise.
+ */
+declare const defineConfig: (config: ViteUserConfig) => Promise<ViteUserConfig>
+
+export { defineConfig, isCI, sharedConfig, sourceResolveConditions }
+export type { ViteUserConfig }

package/lib/base.js

@@ -0,0 +1,308 @@
+import { realpath } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { defaultClientConditions, defaultServerConditions } from 'vite'
+import { defineConfig as defineVitestConfig } from 'vitest/config'
+
+import { exists, firstExisting, readJson } from './files.js'
+
+/** @typedef {import('vitest/config').ViteUserConfig} ViteUserConfig */
+/** @typedef {NonNullable<ViteUserConfig['test']>} TestConfig */
+/** @typedef {NonNullable<TestConfig['projects']>} Projects */
+/**
+ * What one config load reads from disk about its own package: the exemption table entry that decides
+ * where the guard applies, the fork setup files (guard and property defaults) its projects take, and the name and workspace root the
+ * fork's provided context carries.
+ *
+ * @typedef {{
+ *   readonly exemption: { readonly projects: readonly string[] | '*', readonly registrar: string } | undefined,
+ *   readonly forkSetupFiles: ReadonlyArray<string>,
+ *   readonly name: string,
+ *   readonly root: string,
+ * }} PackageFacts
+ */
+
+/**
+ * @param {unknown} value
+ * @param {string} key
+ * @returns {string}
+ */
+const stringField = (value, key) => {
+  const field = typeof value === 'object' && value !== null ? Reflect.get(value, key) : undefined
+  return typeof field === 'string' ? field : ''
+}
+
+// Workspace packages expose their source under this condition in `exports`, so a
+// test resolves a sibling's `src/` instead of a `dist/` this run may not have built.
+// Both pipelines need it: node-environment tests resolve through the SSR resolver,
+// while browser tests use the client one. Vite replaces the default conditions when
+// they are set, so the defaults are spread back in rather than dropped.
+const sourceCondition = '@systemfsoftware/source'
+
+// The fork's package. Its own tests load its guard from source, since it holds no dependency on itself.
+const forkPackage = '@systemfsoftware/vitest'
+
+/**
+ * The one table that takes a package's tests out from under the guard. A package is exempt only by being
+ * listed here, together with the runner that registers its tests: vitest's own `it` is what the guard
+ * refuses, so every test another runner registers must not load it. `projects` is `'*'` when the whole
+ * package is exempt, otherwise the names of the exempt inline test projects.
+ *
+ * @type {Readonly<Record<string, { readonly projects: readonly string[] | '*', readonly registrar: string }>>}
+ */
+const guardExemptions = {
+  '@systemfsoftware/oxlint-plugin-cell-architecture': {
+    projects: '*',
+    registrar: "oxlint's RuleTester registers every case with vitest's it",
+  },
+  '@systemfsoftware/oxlint-plugin-dmmf-workflow': {
+    projects: '*',
+    registrar: "oxlint's RuleTester registers every case with vitest's it",
+  },
+  '@systemfsoftware/oxlint-plugin-effect-platform': {
+    projects: '*',
+    registrar: "oxlint's RuleTester registers every case with vitest's it",
+  },
+  '@systemfsoftware/oxlint-plugin-effect-schema': {
+    projects: '*',
+    registrar: "oxlint's RuleTester registers every case with vitest's it",
+  },
+  '@systemfsoftware/oxlint-plugin-test-discipline': {
+    projects: '*',
+    registrar: "oxlint's RuleTester registers every case with vitest's it",
+  },
+  '@systemfsoftware/storybook-gherkin': {
+    projects: ['storybook'],
+    registrar: "Storybook's vitest plugin registers every story",
+  },
+}
+
+/**
+ * A setup file the fork exports (`./guard`, `./property-defaults`), as an absolute path. The fork is looked up only where pnpm
+ * links a package's declared dependencies, `<package>/node_modules/<fork>`: Node resolution is not
+ * used because pnpm's bin shims put the whole virtual store on `NODE_PATH`, so it finds the fork from
+ * a package that never declared it. Vitest reads a setup-file specifier without the project's resolve
+ * conditions, so the fork's `./guard` export is resolved here: its source entry when that file exists,
+ * so an unbuilt fork still guards, otherwise its built entry. A package that has not declared the fork,
+ * or whose fork has no guard on disk, fails config load instead of running unguarded. Resolving it
+ * reads the file system, so the config a package exports is a promise.
+ *
+ * @param {string} cwd
+ * @param {string} name
+ * @param {string} subpath the fork export, `./guard` or `./property-defaults`
+ * @returns {Promise<string>}
+ */
+const forkSetupFile = async (cwd, name, subpath) => {
+  if (name === forkPackage) return join(cwd, 'src', `${subpath.slice(2)}.ts`)
+  const refuse = (/** @type {string} */ what) =>
+    new Error(
+      `[@systemfsoftware/vitest-config] ${name} ${what}, so its tests would run without the KTD8 guard. ` +
+        `Add "${forkPackage}" to devDependencies of ${join(cwd, 'package.json')} ` +
+        `(as "workspace:^" inside the systemfsoftware monorepo, otherwise the flake tarball or a version range), ` +
+        `or name the exempt test project in vitest-config's guard exemption table.`,
+    )
+  const forkDir = join(cwd, 'node_modules', forkPackage)
+  const manifestPath = join(forkDir, 'package.json')
+  if (!(await exists(manifestPath))) throw refuse(`has no "${forkPackage}" linked in its own node_modules`)
+  const exportsField = Reflect.get(Object(await readJson(manifestPath)), 'exports')
+  const entry = Reflect.get(Object(exportsField), subpath)
+  const found = await firstExisting(
+    [stringField(entry, sourceCondition), stringField(entry, 'default')]
+      .filter((file) => file.length > 0)
+      .map((file) => join(forkDir, file)),
+  )
+  if (found === undefined) throw refuse(`links a "${forkPackage}" whose "${subpath}" export has no file on disk`)
+  return realpath(found)
+}
+
+// A package config is evaluated with the package directory as the working directory (`pnpm --filter <pkg>
+// test`, and turbo's per-package task), so `<cwd>/package.json` is the package this config belongs to.
+/**
+ * The facts about the package this config belongs to, read from disk once.
+ *
+ * @param {string} cwd
+ * @returns {Promise<PackageFacts>}
+ */
+const packageFacts = async (cwd) => {
+  const name = stringField(await readJson(join(cwd, 'package.json')), 'name')
+  const exemption = guardExemptions[name]
+  const forkFiles = exemption?.projects === '*'
+    ? []
+    : [await forkSetupFile(cwd, name, './guard'), await forkSetupFile(cwd, name, './property-defaults')]
+  const root = await workspaceRoot(cwd)
+  return { exemption, forkSetupFiles: forkFiles, name, root }
+}
+
+/**
+ * The workspace root: the nearest ancestor of `cwd` that holds `pnpm-workspace.yaml`, or `cwd` when none does.
+ *
+ * @param {string} cwd
+ * @returns {Promise<string>}
+ */
+const workspaceRoot = async (cwd) => {
+  let dir = cwd
+  while (!(await exists(join(dir, 'pnpm-workspace.yaml')))) {
+    const parent = dirname(dir)
+    if (parent === dir) return cwd
+    dir = parent
+  }
+  return dir
+}
+
+/**
+ * The facts a run's provided context carries for the fork: this package's npm name and the workspace root every
+ * rendered path is relativized against. The runner reads them with Vitest's `inject`, so a rerun line names the
+ * package without the fork ever reading a built-in.
+ *
+ * @param {PackageFacts} facts
+ * @returns {Record<string, string>}
+ */
+const packageProvide = (facts) => {
+  /** @type {Record<string, string>} */
+  const provided = {}
+  if (facts.name.length > 0) provided['@systemfsoftware/vitest:package'] = facts.name
+  if (facts.root.length > 0) provided['@systemfsoftware/vitest:workspace-root'] = facts.root
+  return provided
+}
+
+/**
+ * A test block with the package's own provided values merged over whatever it already provides.
+ *
+ * @param {TestConfig | undefined} test
+ * @param {PackageFacts} facts
+ * @returns {TestConfig}
+ */
+const withProvide = (test, facts) => ({ ...test, provide: { ...test?.provide, ...packageProvide(facts) } })
+
+/**
+ * A test block with the package's guard setup files added on top of its own, each at most once.
+ * `guard` true adds them; false leaves them out, which an exempt project — one whose tests another
+ * runner registers — must not carry.
+ *
+ * @param {TestConfig | undefined} test
+ * @param {boolean} guard
+ * @param {PackageFacts} facts
+ * @returns {TestConfig}
+ */
+const withSetupFiles = (test, guard, facts) => {
+  const own = (test?.setupFiles === undefined ? [] : [test.setupFiles].flat())
+    .filter((file) => guard || !facts.forkSetupFiles.includes(file))
+  return {
+    ...test,
+    setupFiles: [...new Set([...own, ...(guard ? facts.forkSetupFiles : [])])],
+  }
+}
+
+/**
+ * Whether a project's tests are registered by a runner the guard does not apply to.
+ *
+ * @param {TestConfig | undefined} test
+ * @param {PackageFacts} facts
+ * @returns {boolean}
+ */
+const isExemptProject = (test, facts) => {
+  const names = facts.exemption?.projects
+  if (names === undefined || names === '*') return false
+  const name = test?.name
+  return typeof name === 'string' && names.includes(name)
+}
+
+/**
+ * Whether a value is an inline project with a test block.
+ *
+ * @param {unknown} value
+ * @returns {value is { readonly test?: TestConfig }}
+ */
+const isTestProject = (value) => typeof value === 'object' && value !== null && 'test' in value
+
+/**
+ * An inline project gets the setup files itself. A project the exemption table names is the one
+ * exception: the runner that registers its tests is not vitest's, so it takes the handoff without the
+ * guard.
+ *
+ * @param {unknown} project
+ * @param {PackageFacts} facts
+ * @returns {unknown}
+ */
+const projectWithSetup = (project, facts) => {
+  if (!isTestProject(project)) return project
+  const test = project.test
+  return { ...project, test: withProvide(withSetupFiles(test, !isExemptProject(test, facts), facts), facts) }
+}
+
+/**
+ * Vitest's `defineConfig` with the guard and the fork's provided context added to every block that runs
+ * tests: the root when the config declares no projects, otherwise each inline project. The root of a
+ * config with projects runs no tests of its own, and a project with `extends: true` inherits the root's
+ * setup files, so a guard on that root would reach an exempt project. The config it builds is a promise,
+ * because resolving the guard reads the file system.
+ *
+ * @param {ViteUserConfig} config
+ * @returns {Promise<ViteUserConfig>}
+ */
+export const defineConfig = async (config) => {
+  const facts = await packageFacts(process.cwd())
+  const declared = config.test?.projects
+  const base = withProvide(withSetupFiles(config.test, declared === undefined, facts), facts)
+  return defineVitestConfig({
+    ...config,
+    test: declared === undefined
+      ? base
+      : { ...base, projects: /** @type {Projects} */ (declared.map((project) => projectWithSetup(project, facts))) },
+  })
+}
+
+// AGENT outranks CI. This repo's agent shell sets both, so a CI-first reading
+// gives every agent run the thorough forge treatment - tenfold property draws
+// and coverage - for work that wants fast feedback. An agent run is a dev run.
+const isAgent = process.env['AGENT'] !== undefined
+
+// Presence, not equality: GitHub Actions writes "true" and the agent shell
+// writes "1", so testing against either value classifies the other as local.
+// The same rule the fork's run-count table applies: any value except unset, empty, `false` and `0`.
+const ciValue = process.env['CI']
+export const isCI = !isAgent && ciValue !== undefined && !['', 'false', '0'].includes(ciValue)
+
+const sharedTestTimeout = isCI ? 30_000 : isAgent ? 15_000 : 8_000
+
+/**
+ * Spread into a `defineConfig` object that does not use `sharedConfig` as a whole.
+ * Both pipelines need the condition, and Vite replaces its defaults when they are set.
+ * @type {import('vitest/config').ViteUserConfig}
+ */
+export const sourceResolveConditions = {
+  resolve: { conditions: [...defaultClientConditions, sourceCondition] },
+  ssr: { resolve: { conditions: [...defaultServerConditions, sourceCondition] } },
+}
+
+/**
+ * @type {import('vitest/config').ViteUserConfig}
+ */
+export const sharedConfig = {
+  ...sourceResolveConditions,
+  // Effect v3's `effect/TestClock` path, which models keep writing, resolves to
+  // the fork's compat module; on its virtual time `adjust` lets that much time pass.
+  resolve: {
+    ...sourceResolveConditions.resolve,
+    alias: { 'effect/TestClock': '@systemfsoftware/vitest/TestClock' },
+  },
+  test: {
+    globals: false,
+    environment: 'node',
+    // The guard and the conformance handoff are added to every test block that runs tests by
+    // `defineConfig`, which resolves the guard asynchronously; a config that spreads this object
+    // still carries both.
+    setupFiles: [],
+    includeSource: ['src/**/*.{js,ts}'],
+    exclude: ['**/.stryker-tmp/**', '**/node_modules/**', '**/.repo/**'],
+    passWithNoTests: true,
+    testTimeout: sharedTestTimeout,
+    silent: isAgent || isCI ? 'passed-only' : false,
+    ...(isCI ? { reporters: ['agent', 'github-actions'] } : {}),
+    ...(isAgent ? { bail: 1 } : {}),
+    coverage: {
+      enabled: process.env['COVERAGE'] === 'true',
+      provider: 'v8',
+      reporter: ['json', 'html', 'lcov'],
+    },
+  },
+}

package/lib/files.js

@@ -0,0 +1,30 @@
+/**
+ * The file helpers the config and the gate share. Every call is asynchronous, so a config that reads a
+ * manifest, resolves a guard or scans a source set never blocks the event loop it shares.
+ */
+import { access, readFile } from 'node:fs/promises'
+
+/**
+ * Whether a path exists, as a value rather than a throw.
+ *
+ * @param {string} path
+ * @returns {Promise<boolean>}
+ */
+export const exists = (path) => access(path).then(() => true, () => false)
+
+/**
+ * The first path that exists, or undefined when none does.
+ *
+ * @param {ReadonlyArray<string>} paths
+ * @returns {Promise<string | undefined>}
+ */
+export const firstExisting = async (paths) =>
+  (await Promise.all(paths.map(async (path) => ((await exists(path)) ? path : undefined)))).find(
+    (path) => path !== undefined,
+  )
+
+/**
+ * @param {string} path
+ * @returns {Promise<unknown>}
+ */
+export const readJson = async (path) => JSON.parse(await readFile(path, 'utf8'))

package/package.json

@@ -1,10 +1,45 @@
 {
   "name": "@systemfsoftware/vitest-config",
-  "version": "0.0.0-bootstrap.0",
-  "description": "Reserved for trusted publishing from github.com/systemfsoftware/systemfsoftware.",
+  "license": "Apache-2.0",
+  "version": "0.1.3",
+  "author": "Ryan Lee <drdgvhbh@gmail.com>",
+  "type": "module",
+  "module": "./lib/base.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./lib/base.d.ts",
+        "default": "./lib/base.js"
+      }
+    }
+  },
+  "files": [
+    "lib"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "peerDependencies": {
+    "vite": "^8.3.4",
+    "vitest": "^5.1.0"
+  },
+  "devDependencies": {
+    "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
+    "@systemfsoftware/tsconfig": "^2.1.0",
+    "@types/node": "^26.6.5",
+    "vite": "^8.3.4",
+    "vitest": "^5.1.0"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/systemfsoftware/systemfsoftware.git"
+    "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
+    "directory": "packages/toolchain/vitest-config"
   },
-  "license": "Apache-2.0"
-}
+  "homepage": "https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/toolchain/vitest-config#readme",
+  "scripts": {
+    "typecheck": "tsc -b",
+    "attw": "attw --pack ."
+  }
+}