@ploaness/config 1.0.0

package/dist/vitest-core.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The sequence block both Vitest configs declare, named so each carries the same shape rather than a
+ * structural type inferred separately at two call sites.
+ */
+export interface DeterministicSequence {
+    readonly shuffle: {
+        readonly files: boolean;
+        readonly tests: boolean;
+    };
+    readonly seed: number;
+    readonly concurrent: boolean;
+    readonly hooks: 'stack';
+    readonly setupFiles: 'list';
+}
+/**
+ * The per-file coverage floor every governed member is held to.
+ *
+ * Declared here because two runner configurations now read it, and a floor written twice is a floor
+ * that will eventually differ between the members of one repository.
+ */
+export declare const COVERAGE_THRESHOLD: number;
+/**
+ * The fixed fast-check seed the property specs are written against.
+ *
+ * It carries no meaning. What matters is that it never changes, so a failing property is reproducible by
+ * rerunning rather than by guessing which inputs the last run happened to draw.
+ */
+export declare const PROPERTY_TEST_SEED: number;
+/**
+ * The absolute path of the setup file that installs the harness guards.
+ *
+ * Absolute rather than a bare specifier: under pnpm's strict layout a consuming project cannot resolve
+ * `@ploaness/config` at all, but this module knows where it itself lives.
+ * @returns the path, for a Vitest `setupFiles` entry.
+ */
+export declare const harnessSetupFile: () => string;
+/**
+ * The project's own setup file, listed only when the project wrote one.
+ *
+ * It was listed unconditionally, and nothing wrote it: `ploaness init` scaffolds five stubs and this was
+ * not among them, so a freshly initialised project met a Vite resolve error out of the `tests` gate
+ * rather than a finding. Whether a project registers matchers of its own is the project's business, so
+ * the entry is a fact ploaness reads rather than a file ploaness demands.
+ * @returns a one-entry list, or an empty one.
+ */
+export declare const projectSetupFiles: () => readonly string[];
+/**
+ * How the suite is ordered, which is the check for the rule that a test reaches its verdict whatever
+ * order the suite runs in. A test that only passes in declaration order is passing on an accident of
+ * file layout, and shuffling is what turns that accident into a finding.
+ */
+export declare const DETERMINISTIC_SEQUENCE: DeterministicSequence;
+/**
+ * One entry of a reporter list, spelled as the literals Vitest's own option type accepts.
+ *
+ * That type takes a reporter NAME or a `[name, options]` tuple, both as literal types - a widened
+ * `string` satisfies neither, so a list inferred from an array literal would not be assignable at
+ * either call site. Naming the shape once is what lets both configs read the same value.
+ */
+export type ReporterEntry = 'default' | ['github-actions', {
+    jobSummary: {
+        enabled: false;
+    };
+}];
+/**
+ * The reporters a run inside GitHub Actions declares.
+ *
+ * Vitest appends its own `github-actions` reporter whenever `GITHUB_ACTIONS` is set AND no reporter is
+ * declared, and that reporter writes a "Vitest Test Report" scoreboard into the workflow's job summary.
+ * A verification is a sequence of suites, several of which are MEANT to fail - `it/` drives a fixture
+ * whose network guard has to block a remote connection, and asserts that it did - so the summary
+ * reported failures at the top of a green run, with nothing beside them to say they were the expected
+ * ones. The verdict is the run's exit status; a second scoreboard that contradicts it teaches a reader
+ * to trust neither.
+ *
+ * Only the summary goes. `displayAnnotations` is left at its default, which marks a failing test on the
+ * line that failed rather than on the run's front page - and is the half of this reporter that says
+ * something the exit status does not.
+ */
+export declare const GITHUB_ACTIONS_REPORTERS: readonly ReporterEntry[];
+/**
+ * The reporters both Vitest configs declare.
+ *
+ * The branch mirrors the condition Vitest itself applies rather than declaring the reporter
+ * unconditionally: outside a workflow there is no job summary and no annotation surface, so the
+ * `::error` lines would land in a local terminal as noise nothing reads.
+ * @returns the list, for a Vitest `reporters` entry.
+ */
+export declare const testReporters: () => readonly ReporterEntry[];
+//# sourceMappingURL=vitest-core.d.ts.map

package/dist/vitest-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest-core.d.ts","sourceRoot":"","sources":["../src/vitest-core.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAA;IACtE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAWD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAW,CAAA;AAE5C;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAsB,CAAA;AASvD;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,QAAO,MACwB,CAAA;AAE5D;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,QAAO,SAAS,MAAM,EACkC,CAAA;AAEtF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,qBAWnC,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,CAAC,gBAAgB,EAAE;IAAE,UAAU,EAAE;QAAE,OAAO,EAAE,KAAK,CAAA;KAAE,CAAA;CAAE,CAAC,CAAA;AAE9F;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,EAAE,SAAS,aAAa,EAG5D,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,QAAO,SAAS,aAAa,EAC4B,CAAA"}

package/dist/vitest-core.js

@@ -0,0 +1,101 @@
+// The Vitest values the shipped config and the ploaness repository's own config both need.
+//
+// The sibling of eslint-core.js, and it exists for the same reason: two configs that must agree about a
+// literal will not stay in agreement, and the seed below is exactly the kind of literal that drifts
+// silently because nothing fails when it does.
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { PROJECT_SETUP_FILE as PROJECT_SETUP_FILE_NAME } from '@ploaness/governance';
+/**
+ * The setup file a project writes for itself, if it wants one, as this config must spell it.
+ *
+ * The name comes from governance rather than from a second literal here: the Biome block requires this
+ * file, the ESLint config exempts it from a rule aimed at code rather than at process configuration, and
+ * this config loads it. Three tools agreeing about one filename is a joint, not a coincidence.
+ */
+const PROJECT_SETUP_FILE = `./${PROJECT_SETUP_FILE_NAME}`;
+/**
+ * The per-file coverage floor every governed member is held to.
+ *
+ * Declared here because two runner configurations now read it, and a floor written twice is a floor
+ * that will eventually differ between the members of one repository.
+ */
+export const COVERAGE_THRESHOLD = 80;
+/**
+ * The fixed fast-check seed the property specs are written against.
+ *
+ * It carries no meaning. What matters is that it never changes, so a failing property is reproducible by
+ * rerunning rather than by guessing which inputs the last run happened to draw.
+ */
+export const PROPERTY_TEST_SEED = 1_734_000_000;
+// The order a shuffled suite runs in. It is fixed for the same reason the seed above is: a check has one
+// verdict on an unchanged repository, and Vitest's own default here is the wall clock, which would make
+// the suite report differently on two runs of the same tree. One fixed seed samples one order rather
+// than proving independence of all of them - but it is an order other than the one the files happen to
+// be written in, which is the coupling that actually accumulates.
+const TEST_ORDER_SEED = 1_734_000_002;
+/**
+ * The absolute path of the setup file that installs the harness guards.
+ *
+ * Absolute rather than a bare specifier: under pnpm's strict layout a consuming project cannot resolve
+ * `@ploaness/config` at all, but this module knows where it itself lives.
+ * @returns the path, for a Vitest `setupFiles` entry.
+ */
+export const harnessSetupFile = () => fileURLToPath(new URL('vitest-setup.js', import.meta.url));
+/**
+ * The project's own setup file, listed only when the project wrote one.
+ *
+ * It was listed unconditionally, and nothing wrote it: `ploaness init` scaffolds five stubs and this was
+ * not among them, so a freshly initialised project met a Vite resolve error out of the `tests` gate
+ * rather than a finding. Whether a project registers matchers of its own is the project's business, so
+ * the entry is a fact ploaness reads rather than a file ploaness demands.
+ * @returns a one-entry list, or an empty one.
+ */
+export const projectSetupFiles = () => existsSync(path.join(process.cwd(), PROJECT_SETUP_FILE)) ? [PROJECT_SETUP_FILE] : [];
+/**
+ * How the suite is ordered, which is the check for the rule that a test reaches its verdict whatever
+ * order the suite runs in. A test that only passes in declaration order is passing on an accident of
+ * file layout, and shuffling is what turns that accident into a finding.
+ */
+export const DETERMINISTIC_SEQUENCE = Object.freeze({
+    shuffle: Object.freeze({ files: true, tests: true }),
+    seed: TEST_ORDER_SEED,
+    // A concurrent test interleaves with its neighbours, which is order-dependence rather than
+    // independence of order: it makes the coupling harder to see instead of impossible to have.
+    concurrent: false,
+    // Stated rather than inherited. A default can move between releases; a declaration cannot.
+    hooks: 'stack',
+    // The harness setup file installs the network guard, and it has to be in place before any project
+    // setup runs. Vitest's default here loads setup files in parallel, which would make that a race.
+    setupFiles: 'list',
+});
+/**
+ * The reporters a run inside GitHub Actions declares.
+ *
+ * Vitest appends its own `github-actions` reporter whenever `GITHUB_ACTIONS` is set AND no reporter is
+ * declared, and that reporter writes a "Vitest Test Report" scoreboard into the workflow's job summary.
+ * A verification is a sequence of suites, several of which are MEANT to fail - `it/` drives a fixture
+ * whose network guard has to block a remote connection, and asserts that it did - so the summary
+ * reported failures at the top of a green run, with nothing beside them to say they were the expected
+ * ones. The verdict is the run's exit status; a second scoreboard that contradicts it teaches a reader
+ * to trust neither.
+ *
+ * Only the summary goes. `displayAnnotations` is left at its default, which marks a failing test on the
+ * line that failed rather than on the run's front page - and is the half of this reporter that says
+ * something the exit status does not.
+ */
+export const GITHUB_ACTIONS_REPORTERS = [
+    'default',
+    ['github-actions', { jobSummary: { enabled: false } }],
+];
+/**
+ * The reporters both Vitest configs declare.
+ *
+ * The branch mirrors the condition Vitest itself applies rather than declaring the reporter
+ * unconditionally: outside a workflow there is no job summary and no annotation surface, so the
+ * `::error` lines would land in a local terminal as noise nothing reads.
+ * @returns the list, for a Vitest `reporters` entry.
+ */
+export const testReporters = () => process.env['GITHUB_ACTIONS'] === 'true' ? GITHUB_ACTIONS_REPORTERS : ['default'];
+//# sourceMappingURL=vitest-core.js.map

package/dist/vitest-core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest-core.js","sourceRoot":"","sources":["../src/vitest-core.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,EAAE;AACF,wGAAwG;AACxG,oGAAoG;AACpG,+CAA+C;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,kBAAkB,IAAI,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAcpF;;;;;;GAMG;AACH,MAAM,kBAAkB,GAAW,KAAK,uBAAuB,EAAE,CAAA;AAEjE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAW,EAAE,CAAA;AAE5C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAW,aAAa,CAAA;AAEvD,yGAAyG;AACzG,wGAAwG;AACxG,qGAAqG;AACrG,uGAAuG;AACvG,kEAAkE;AAClE,MAAM,eAAe,GAAW,aAAa,CAAA;AAE7C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAW,EAAE,CAC3C,aAAa,CAAC,IAAI,GAAG,CAAC,iBAAiB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAA;AAE5D;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAsB,EAAE,CACvD,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;AAEtF;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAA0B,MAAM,CAAC,MAAM,CAAC;IACzE,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACpD,IAAI,EAAE,eAAe;IACrB,2FAA2F;IAC3F,4FAA4F;IAC5F,UAAU,EAAE,KAAK;IACjB,2FAA2F;IAC3F,KAAK,EAAE,OAAO;IACd,kGAAkG;IAClG,iGAAiG;IACjG,UAAU,EAAE,MAAM;CACnB,CAAC,CAAA;AAWF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAA6B;IAChE,SAAS;IACT,CAAC,gBAAgB,EAAE,EAAE,UAAU,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC;CACvD,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,GAA6B,EAAE,CAC1D,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA"}

package/dist/vitest-library.d.ts

@@ -0,0 +1,3 @@
+declare const config: Readonly<Record<string, unknown>>;
+export default config;
+//# sourceMappingURL=vitest-library.d.ts.map

package/dist/vitest-library.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest-library.d.ts","sourceRoot":"","sources":["../src/vitest-library.ts"],"names":[],"mappings":"AAyCA,QAAA,MAAM,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAmB,CAAA;AAEjE,eAAe,MAAM,CAAA"}

package/dist/vitest-library.js

@@ -0,0 +1,37 @@
+// The Vitest configuration for a member that serves no application.
+//
+// Two differences from the application configuration, both about what is absent rather than about what
+// is relaxed: the environment is node, because a package with no browser has no DOM to simulate and
+// paying for jsdom on every file would be waste; and the React plugin is not loaded, because a package
+// with no components has nothing for it to transform. The coverage floors, the deterministic sequence
+// and the network guard are the same ones an application is held to.
+import { COVERAGE_INCLUDE } from '@ploaness/governance';
+import { defineConfig } from 'vitest/config';
+import { projectSettings as settings } from './project-settings.js';
+import { COVERAGE_THRESHOLD, DETERMINISTIC_SEQUENCE, harnessSetupFile, projectSetupFiles, } from './vitest-core.js';
+const declared = defineConfig({
+    resolve: { tsconfigPaths: true },
+    test: {
+        environment: 'node',
+        include: ['tests/unit/**/*.unit.spec.ts', 'tests/int/**/*.int.spec.ts'],
+        setupFiles: [harnessSetupFile(), ...projectSetupFiles()],
+        sequence: DETERMINISTIC_SEQUENCE,
+        coverage: {
+            provider: 'v8',
+            include: [...COVERAGE_INCLUDE],
+            exclude: [...settings.coverageExclude],
+            thresholds: {
+                perFile: true,
+                lines: COVERAGE_THRESHOLD,
+                branches: COVERAGE_THRESHOLD,
+                functions: COVERAGE_THRESHOLD,
+                statements: COVERAGE_THRESHOLD,
+            },
+        },
+    },
+});
+// Structural, for the reason the application configuration records: naming Vite's own type would make
+// `vite` resolvable from this package a condition of type-checking a consumer's config file.
+const config = { ...declared };
+export default config;
+//# sourceMappingURL=vitest-library.js.map

package/dist/vitest-library.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest-library.js","sourceRoot":"","sources":["../src/vitest-library.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,EAAE;AACF,uGAAuG;AACvG,oGAAoG;AACpG,uGAAuG;AACvG,sGAAsG;AACtG,qEAAqE;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EAAE,eAAe,IAAI,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,kBAAkB,CAAA;AAEzB,MAAM,QAAQ,GAAoC,YAAY,CAAC;IAC7D,OAAO,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE;IAChC,IAAI,EAAE;QACJ,WAAW,EAAE,MAAM;QACnB,OAAO,EAAE,CAAC,8BAA8B,EAAE,4BAA4B,CAAC;QACvE,UAAU,EAAE,CAAC,gBAAgB,EAAE,EAAE,GAAG,iBAAiB,EAAE,CAAC;QACxD,QAAQ,EAAE,sBAAsB;QAChC,QAAQ,EAAE;YACR,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,CAAC,GAAG,gBAAgB,CAAC;YAC9B,OAAO,EAAE,CAAC,GAAG,QAAQ,CAAC,eAAe,CAAC;YACtC,UAAU,EAAE;gBACV,OAAO,EAAE,IAAI;gBACb,KAAK,EAAE,kBAAkB;gBACzB,QAAQ,EAAE,kBAAkB;gBAC5B,SAAS,EAAE,kBAAkB;gBAC7B,UAAU,EAAE,kBAAkB;aAC/B;SACF;KACF;CACF,CAAC,CAAA;AAEF,sGAAsG;AACtG,6FAA6F;AAC7F,MAAM,MAAM,GAAsC,EAAE,GAAG,QAAQ,EAAE,CAAA;AAEjE,eAAe,MAAM,CAAA"}

package/dist/vitest-setup.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vitest-setup.d.ts.map

package/dist/vitest-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest-setup.d.ts","sourceRoot":"","sources":["../src/vitest-setup.ts"],"names":[],"mappings":""}

package/dist/vitest-setup.js

@@ -0,0 +1,150 @@
+// The first setup file the shipped Vitest config loads. It does two things: it reads the project
+// environment, and it installs the network guard.
+//
+// It imports node builtins and @ploaness/governance, and NOTHING ELSE. A setup file that lives inside
+// node_modules/@ploaness/config resolves `vitest`, `fast-check`, and `@testing-library/*` to the
+// harness's own copies rather than to the project's, so a hook, a matcher, or a global seed registered
+// against one of those would attach to a module instance the suite never loads and silently do nothing.
+// Resolving from the project root does not rescue it either: that yields a package's CommonJS entry
+// while the suite loads its ESM one, which is two module records again. That is why the fast-check
+// global seed stays in the project's own `vitest.setup.ts`, and it is the constraint an otherwise
+// reasonable refactor of this file will break.
+//
+// Every decision lives in @ploaness/governance. What is left here is the interception, which is the one
+// part that cannot be pure.
+import dns from 'node:dns';
+import { existsSync } from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import { describeSocketTarget, findNetworkEscape, hostOfUrl, isRecord, localAddresses, RESOLVER_METHODS, runEnvironmentFiles, } from '@ploaness/governance';
+// A predicate rather than an assertion. `typeof value === 'function'` narrows to a shape with no call
+// signature, so every caller would otherwise have to assert - and an assertion is uncovered by the type
+// coverage measurement this repository holds at 100%, which is the point of preferring the predicate.
+const isIntercepted = (value) => typeof value === 'function';
+// Read here for the reason the Playwright config reads them: an integration spec boots the project,
+// and a Payload configuration validates `process.env` as the module loads, so the spec dies on
+// configuration rather than on code. A project could put this in its own `vitest.setup.ts` and many
+// did, but then the promise that a gate running the application uses the real environment holds only
+// for the projects that remembered. Nothing loaded here replaces a value already set, so a project
+// that still loads them itself is unaffected, and a variable CI exported outranks both files.
+//
+// Vitest re-runs this module once per spec file. That costs nothing to repeat: a file that is read
+// twice sets nothing the second time, because the first read already set it.
+for (const file of runEnvironmentFiles(existsSync)) {
+    process.loadEnvFile(file);
+}
+// Vitest re-runs a setup module once per spec file, while the builtins it patches live for the whole
+// worker. Without a mark, each file would wrap the previous file's wrapper one layer deeper.
+const GUARD_MARK = Symbol.for('ploaness.network-guard');
+const MACHINE_ADDRESSES = localAddresses(os.networkInterfaces());
+const refuse = (attempt) => {
+    const refusal = findNetworkEscape(attempt, MACHINE_ADDRESSES);
+    if (refusal !== undefined) {
+        throw new Error(refusal);
+    }
+};
+// A proxy rather than a wrapper function, for two reasons that both come from what is being wrapped.
+// `net.Socket.prototype.connect` is a method, so the receiver has to reach the original - and a proxy
+// forwards it without the wrapper ever naming `this`. And `dns.lookup` announces its promisified shape
+// through a symbol property, which a hand-written wrapper has to remember to copy and a proxy carries
+// by construction, along with the function's name and arity.
+const guard = (original, toAttempt) => new Proxy(original, {
+    // Annotated rather than inherited from `ProxyHandler`, whose own declaration types the receiver and
+    // the argument list as `any`; taking that would put two `any` values into the single function every
+    // network call in the suite passes through.
+    apply: (target, receiver, callArguments) => {
+        refuse(toAttempt(callArguments));
+        const result = Reflect.apply(target, receiver, callArguments);
+        return result;
+    },
+    has: (target, key) => key === GUARD_MARK || Reflect.has(target, key),
+});
+// Installed non-writable and non-configurable, so a project setup file or a spec body cannot put the
+// original back. Installing it twice is not a no-op but an error, which is what the mark check prevents.
+const install = (owner, key, toAttempt) => {
+    const original = Reflect.get(owner, key);
+    if (!isIntercepted(original) || Reflect.has(original, GUARD_MARK)) {
+        return;
+    }
+    Object.defineProperty(owner, key, {
+        value: guard(original, toAttempt),
+        writable: false,
+        enumerable: Object.getOwnPropertyDescriptor(owner, key)?.enumerable ?? true,
+        configurable: false,
+    });
+};
+const firstArgumentOf = (callArguments) => {
+    const [target] = callArguments;
+    return typeof target === 'string' ? target : String(target);
+};
+const toLookupAttempt = (callArguments) => ({
+    api: 'lookup',
+    host: firstArgumentOf(callArguments),
+    destination: firstArgumentOf(callArguments),
+});
+const toResolveAttempt = (callArguments) => ({
+    api: 'resolve',
+    host: firstArgumentOf(callArguments),
+    destination: firstArgumentOf(callArguments),
+});
+// `fetch` accepts a string, a `URL`, or a `Request`, and each yields its address differently. A single
+// `String(...)` over that union stringifies a `Request` to `[object Object]`, which would make the
+// refusal name nothing a reader could act on.
+const fetchTargetUrl = (target) => {
+    if (typeof target === 'string') {
+        return target;
+    }
+    if (target instanceof URL) {
+        return target.href;
+    }
+    const declared = isRecord(target) ? target['url'] : undefined;
+    return typeof declared === 'string' ? declared : '';
+};
+const toFetchAttempt = (callArguments) => {
+    const [target] = callArguments;
+    const raw = fetchTargetUrl(target);
+    return { api: 'fetch', host: hostOfUrl(raw), destination: raw };
+};
+// The chokepoint. Every TCP reach in Node passes through it - `net.connect`, the http and https agents,
+// `tls.connect` (a TLSSocket inherits this method rather than declaring its own), http2, undici and so
+// the global fetch, and every database driver. Guarding it alone would already be the whole rule.
+install(net.Socket.prototype, 'connect', describeSocketTarget);
+// Redundant with the socket guard for anything that goes on to connect, and worth having anyway: it
+// names the host rather than the socket, and it catches a caller that resolves before deciding where to
+// go.
+install(dns, 'lookup', toLookupAttempt);
+install(dns.promises, 'lookup', toLookupAttempt);
+// The hole the socket guard does not cover. The resolver family queries a nameserver over UDP without
+// ever creating a socket, which is how an SRV lookup leaves the machine with nothing to intercept.
+//
+// The module-level `dns.resolve*` functions are bound to a default Resolver instance, so patching them
+// leaves `new dns.Resolver().resolveSrv(...)` reaching `Resolver.prototype` untouched - the exact hole
+// this block exists to close, one constructor away. The prototypes are guarded too.
+// Named without a presence check: both constructors are declared by node's own types, so an optional
+// chain here would be a defence against a shape the runtime cannot have and the compiler already denies.
+const resolverOwners = [
+    dns,
+    dns.promises,
+    dns.Resolver.prototype,
+    dns.promises.Resolver.prototype,
+];
+for (const method of RESOLVER_METHODS) {
+    for (const owner of resolverOwners) {
+        install(owner, method, toResolveAttempt);
+    }
+}
+// Left replaceable, unlike the two above. A DOM test environment swaps the globals between files, and a
+// non-configurable `fetch` would break that swap. This layer exists for the message it produces; if it
+// is replaced, the socket guard still refuses the request one layer down.
+// Read through Reflect rather than as a bare name: a runtime without it would make the bare name a
+// reference error rather than an absence to skip over.
+const currentFetch = Reflect.get(globalThis, 'fetch');
+if (isIntercepted(currentFetch) && !Reflect.has(currentFetch, GUARD_MARK)) {
+    Object.defineProperty(globalThis, 'fetch', {
+        value: guard(currentFetch, toFetchAttempt),
+        writable: true,
+        enumerable: false,
+        configurable: true,
+    });
+}
+//# sourceMappingURL=vitest-setup.js.map

package/dist/vitest-setup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest-setup.js","sourceRoot":"","sources":["../src/vitest-setup.ts"],"names":[],"mappings":"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"}

package/dist/vitest.d.ts

@@ -0,0 +1,3 @@
+declare const config: Readonly<Record<string, unknown>>;
+export default config;
+//# sourceMappingURL=vitest.d.ts.map

package/dist/vitest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.d.ts","sourceRoot":"","sources":["../src/vitest.ts"],"names":[],"mappings":"AAmIA,QAAA,MAAM,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAmB,CAAA;AAEjE,eAAe,MAAM,CAAA"}

package/dist/vitest.js

@@ -0,0 +1,117 @@
+// The Vitest configuration ploaness owns. A consuming project re-exports it verbatim; the only
+// project-specific input is the coverage exclusion list, which the project declares under the `ploaness`
+// key of its package.json rather than by editing this file.
+//
+// The coverage policy is default-safe, which is the point: EVERY TypeScript module under the declared
+// source roots is in scope, and exemptions are carved out by ROLE, never by naming a handful of folders
+// that happen to have tests today. A new logic directory is therefore covered the moment it exists,
+// instead of silently escaping an allowlist nobody remembered to extend. With `include` set, Vitest
+// counts every matching file even when no test imports it, so an untested unit scores zero and fails the
+// gate rather than being invisible.
+import { COVERAGE_INCLUDE } from '@ploaness/governance';
+import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vitest/config';
+import { projectSettings as settings } from './project-settings.js';
+import { COVERAGE_THRESHOLD, DETERMINISTIC_SEQUENCE, harnessSetupFile, projectSetupFiles, testReporters, } from './vitest-core.js';
+// The environment is per suite rather than per repository, and that split is load-bearing rather than
+// tidy. `jsdom` installs its OWN realm's globals, typed-array constructors included, so a Node `Buffer`
+// fails `input instanceof Uint8Array` inside any library that guards its input that way - the check
+// compares constructor identity, not shape. Payload's upload pipeline does exactly that, through
+// `file-type`, and wraps the resulting TypeError in a `ValidationError` on the `file` field. The
+// consequence was that no Payload project running this config could integration-test an upload against
+// an `upload.mimeTypes` allowlist: the suite reported the project's own allowlist rejecting a valid PNG,
+// which is a defect in this file wearing the costume of a defect in the project's security policy.
+//
+// So an integration spec, which boots the server-side application and has no DOM to want, runs under
+// `node`. A unit spec keeps `jsdom`: `tests/component/**` is where a spec that needs a DOM belongs, but
+// a `.ts` unit spec reaching for `document` is a shape consumers already have, and taking it away is a
+// different decision from this one.
+const SUITES = [
+    {
+        name: 'node',
+        environment: 'node',
+        include: ['tests/int/**/*.int.spec.ts', 'tests/int/**/*.int.spec.tsx'],
+    },
+    {
+        name: 'jsdom',
+        environment: 'jsdom',
+        include: [
+            'tests/unit/**/*.unit.spec.ts',
+            // A component spec had no home. ploaness pins and ships React Testing Library, jest-dom,
+            // user-event and a jsdom environment - a stack that exists for exactly this - while collecting
+            // only `.ts` under unit and anything under int. So a project writing the component tests the
+            // harness equips it for had to mislabel them as integration tests or watch them silently stop
+            // running, which is what a real consumer's suite was doing when this was found.
+            'tests/component/**/*.component.spec.tsx',
+            'tests/component/**/*.component.spec.ts',
+        ],
+    },
+];
+// Every suite carries the guards, because a project gets its own Vite server and inherits nothing from
+// the root unless it says so. The plugin is constructed per suite rather than shared: two servers
+// holding one plugin instance would share whatever state it keeps.
+const suiteProject = (suite) => ({
+    plugins: [react()],
+    // Vite resolves the project's path aliases from tsconfig natively, so no extra plugin is needed.
+    resolve: { tsconfigPaths: true },
+    test: {
+        name: suite.name,
+        environment: suite.environment,
+        include: [...suite.include],
+        // The harness file first, and `sequence.setupFiles: 'list'` makes that ordering binding rather
+        // than incidental: it installs the network guard, which has to be in place before a project's own
+        // setup runs. A project cannot reach either entry - its vitest.config.mts is a bare re-export of
+        // this file, and the `tests` gate builds its own argv.
+        setupFiles: [harnessSetupFile(), ...projectSetupFiles()],
+        sequence: DETERMINISTIC_SEQUENCE,
+        // Run spec files one at a time. Each top-level test command gets one ephemeral database, but every
+        // Payload-booting spec within that command shares it; in parallel, two boots could race to CREATE
+        // the same enum or table. Serial boots make the first push establish the schema and later boots find
+        // it already present, which is idempotent.
+        //
+        // Declared on every suite, not once at the root: Vitest collapses the suites into a single serial
+        // group only when each one asks for a single worker, so a suite that omitted this would run
+        // alongside the others and put the shared database back in a race.
+        fileParallelism: false,
+    },
+});
+// Structural rather than Vite's own `UserConfig`, and the annotation is load-bearing rather than
+// stylistic. An emitted declaration naming `import('vite').UserConfig` would make `vite` resolvable
+// from this package a condition of type-checking a consumer's `vitest.config.mts` - and `vite` arrives
+// here only as a transitive dependency of `vitest`, which pnpm's strict layout does not expose. The
+// consumer re-exports this value and never reads a field off it, so the shape is all it needs. The
+// hand-written declaration this file replaced recorded the same decision.
+// `ReturnType` rather than the runner's own exported type: naming that type would import it, which is
+// the dependency the annotation below exists to avoid. This binding is module-local, so it reaches no
+// declaration file either way.
+const declared = defineConfig({
+    test: {
+        projects: SUITES.map((suite) => suiteProject(suite)),
+        // Root-only, like coverage below: a reporter reports on the run rather than on one suite.
+        reporters: [...testReporters()],
+        // Coverage stays at the root because Vitest forbids it anywhere else: it is one measurement over
+        // the whole verification rather than a property of any one suite.
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'html', 'lcov'],
+            // Imported rather than written here: the exclusion-reach rule judges a declared exclusion against
+            // exactly this set, and a second copy of it would decide a verdict the report never agreed with.
+            include: [...COVERAGE_INCLUDE],
+            exclude: [...settings.coverageExclude],
+            thresholds: {
+                // perFile: every covered file must independently clear the bar. Without it one fully covered
+                // file can mask an uncovered one in the aggregate, which is exactly how an untested helper hides.
+                perFile: true,
+                lines: COVERAGE_THRESHOLD,
+                branches: COVERAGE_THRESHOLD,
+                functions: COVERAGE_THRESHOLD,
+                statements: COVERAGE_THRESHOLD,
+            },
+        },
+    },
+});
+// A shallow copy rather than an assertion: a spread yields an anonymous object type, which carries
+// the index signature an interface does not, so the structural annotation above holds without one.
+const config = { ...declared };
+export default config;
+//# sourceMappingURL=vitest.js.map

package/dist/vitest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.js","sourceRoot":"","sources":["../src/vitest.ts"],"names":[],"mappings":"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"}

package/knip.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://unpkg.com/knip@6/schema.json",
+  "ignoreDependencies": ["@payloadcms/ui", "@testing-library/user-event", "@ploaness/.+"],
+  "entry": ["eslint.config.mjs"]
+}