@hublo/sentinel 1.4.0-alpha.9 → 1.4.0

package/dist/roles/test/setup/msw-server.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/roles/test/setup/msw-server.ts"],"sourcesContent":["/**\n * The msw server a migrated suite shares with its setup.\n *\n * ## Why this entry exists at all\n *\n * The setup beside it starts a server and the tests add handlers to one. If those are two different\n * instances, the one that listens has no handlers and every request is unhandled, which under\n * `onUnhandledRequest: 'error'` fails every test that touches HTTP.\n *\n * That is not hypothetical. Migrating `apps/cloud/agency` and running its suite produced exactly\n * it: 22 green tests under jest became 10 failures, with `[MSW] Cannot bypass a request when using\n * the \"error\" strategy`. The setup had been absorbed into sentinel while the 599 files that import\n * the server still pointed at the workspace's own instance.\n *\n * So the server is exported under its own name, and the codemod repoints those imports here. One\n * instance, listened to by the setup and used by the tests.\n */\nexport { server } from './msw.js'\n\n/**\n * msw's own API, re-exported, so a module gets its handlers from the SAME physical copy that\n * intercepts.\n *\n * sentinel ships msw as a dependency on purpose: a module must stand alone, and the workspace root\n * that used to provide it is going away. But a test that keeps `import { rest } from 'msw'` builds\n * its handlers with the WORKSPACE's copy while the server that listens is built with sentinel's.\n * Same version, two physical instances, one interceptor: the handler is never matched.\n *\n * Measured on `libs/cloud/shared`: the msw handler is never called and the test fails on\n * `expected \"vi.fn()\" to be called 1 times, but got 0 times`. Same family as the axios duplicate,\n * where `resolve.dedupe` changed nothing and only pointing at one physical path did.\n *\n * `export *` rather than a list: `rest` covers 669 of the 671 importing files here, but the\n * surface a test may need (`graphql`, `ctx`, the handler types) belongs to msw, not to a list\n * sentinel would have to keep in step. `setupServer` is not part of it: it lives in `msw/node`,\n * and the server is sentinel's to create.\n */\nexport * from 'msw'\n"],"mappings":";;;;;AAqCA,cAAc;","names":[]}
+{"version":3,"sources":["../../../../src/roles/test/setup/msw-server.ts"],"sourcesContent":["/**\n * The msw server a migrated suite shares with its setup.\n *\n * ## Why this entry exists at all\n *\n * The setup beside it starts a server and the tests add handlers to one. If those are two different\n * instances, the one that listens has no handlers and every request is unhandled, which under\n * `onUnhandledRequest: 'error'` fails every test that touches HTTP.\n *\n * That is not hypothetical. Migrating `apps/cloud/agency` and running its suite produced exactly\n * it: 22 green tests under jest became 10 failures, with `[MSW] Cannot bypass a request when using\n * the \"error\" strategy`. The setup had been absorbed into sentinel while the 599 files that import\n * the server still pointed at the workspace's own instance.\n *\n * So the server is exported under its own name, and the codemod repoints those imports here. One\n * instance, listened to by the setup and used by the tests.\n */\nexport { server } from './msw.js'\n\n/**\n * msw's own API, re-exported, so a module gets its handlers from the SAME physical copy that\n * intercepts.\n *\n * sentinel ships msw as a dependency on purpose: a module must stand alone, and the workspace root\n * that used to provide it is going away. But a test that keeps `import { rest } from 'msw'` builds\n * its handlers with the WORKSPACE's copy while the server that listens is built with sentinel's.\n * Same version, two physical instances, one interceptor: the handler is never matched.\n *\n * Measured on `libs/cloud/shared`: the msw handler is never called and the test fails on\n * `expected \"vi.fn()\" to be called 1 times, but got 0 times`. Same family as the axios duplicate,\n * where `resolve.dedupe` changed nothing and only pointing at one physical path did.\n *\n * `export *` rather than a list: `rest` covers 669 of the 671 importing files here, but the\n * surface a test may need (`graphql`, `ctx`, the handler types) belongs to msw, not to a list\n * sentinel would have to keep in step. `setupServer` is not part of it: it lives in `msw/node`,\n * and the server is sentinel's to create.\n */\nexport * from 'msw'\n"],"mappings":";;;;;;AAqCA,cAAc;","names":[]}

package/dist/roles/test/setup/w3c.d.ts

@@ -0,0 +1,75 @@
+import { ConfigData } from 'html-validate';
+
+/**
+ * `expect(element).toBeValidHtml()`, run by html-validate.
+ *
+ * Opt in from a module's config:
+ *
+ *     setupFiles: ['@hublo/sentinel/test/setup/w3c']
+ *
+ * ## Why html-validate and not vnu
+ *
+ * vnu is the W3C's own checker and the W3C's own documentation advises against running it as a
+ * service in a loop, which is what a test suite does. It also needs a JVM, but that was never the
+ * deciding argument: measured on the same markup, the two agree on almost everything that matters
+ * to a component test. What differs is the configuration, and configuration is the thing worth
+ * owning.
+ *
+ * ## The fragment is WRAPPED in a page before it is validated
+ *
+ * A component renders a fragment, and a fragment cannot be held to document-level rules: it has no
+ * doctype, no `<html lang>`, no `<title>`. The obvious answer is to switch those rules off, and it
+ * is the wrong one, because they are the rules that catch what a component silently breaks inside
+ * a real page.
+ *
+ * So the fragment is put INTO a minimal valid page and the page is validated. Héla brought this
+ * from an OVH project that did the same with vnu, and measured here it is strictly better:
+ *
+ *     case                  standard + 3 rules      wrapped, standard + document + 3
+ *     <img src="a.png">     wcag/h37                wcag/h37
+ *     <div><p>x</div>       no-implicit-close       no-implicit-close
+ *     <input type="text">   input-missing-label     input-missing-label
+ *     <div id="a" id="b">   no-dup-attr             no-dup-attr
+ *     <div id="a"> x2       no-dup-id               no-dup-id
+ *     <h1>a</h1><h3>b</h3>  nothing                 heading-level
+ *     correct markup        nothing                 nothing
+ *
+ * The last two lines are the point: wrapping buys `heading-level`, a skipped heading rank, which
+ * no fragment-level check can see, and it costs no false positive.
+ *
+ * ⚠️ `html-validate:document` is NOT a superset of `standard`, which is easy to assume and wrong:
+ * measured on its own it caught `input-missing-label` and missed the other four. Both are extended,
+ * plus the three rules neither of them carries.
+ *
+ * The wrapper is written on ONE line and its width is subtracted from every reported column, so a
+ * position still points into the component's own markup rather than into our envelope.
+ *
+ * ## What a pass means
+ *
+ * That the markup this component rendered is well formed and carries the attributes those rules
+ * require. It says nothing about the rest of the page it will live in, and nothing about anything
+ * only a browser can decide. `toBeAccessible()` is the other half, and the two overlap on purpose:
+ * `wcag/h37` and axe's `image-alt` are the same requirement seen by a parser and by a DOM.
+ */
+
+/**
+ * The configuration, which is the thing that decides the outcome.
+ *
+ * Exported so a module can read what it is being held to, and so a test can assert on it rather
+ * than on a behaviour that happens to follow from it.
+ */
+declare const W3C_CONFIG: ConfigData;
+declare module 'vitest' {
+    interface Matchers<T = any> {
+        /**
+         * Validate this element's markup with html-validate.
+         *
+         * ⚠️ The fragment is put INTO a minimal page before it is validated, so the document-level
+         * rules apply to what the component will actually sit in, without holding the component
+         * itself to a doctype it does not own.
+         */
+        toBeValidHtml: (config?: ConfigData) => Promise<T>;
+    }
+}
+
+export { W3C_CONFIG };

package/dist/roles/test/setup/w3c.js

@@ -0,0 +1,49 @@
+// src/roles/test/setup/w3c.ts
+import { expect } from "vitest";
+var W3C_CONFIG = {
+  extends: ["html-validate:standard", "html-validate:document"],
+  rules: {
+    "wcag/h37": "error",
+    "no-implicit-close": "error",
+    "input-missing-label": "error"
+  }
+};
+var PREFIX = '<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><title>component under test</title></head><body>';
+var SUFFIX = "</body></html>";
+function asDocument(html) {
+  const looksLikeADocument = /<!doctype\s+html/i.test(html) || /<html[\s>]/i.test(html);
+  return looksLikeADocument ? { html, wrapped: false } : { html: `${PREFIX}${html}${SUFFIX}`, wrapped: true };
+}
+var engine;
+function describe(message, wrapped) {
+  const shift = wrapped && message.line === 1 ? PREFIX.length : 0;
+  const column = Math.max(message.column - shift, 1);
+  return `  ${message.line}:${column}  ${message.message}  (${message.ruleId})`;
+}
+expect.extend({
+  async toBeValidHtml(received, config) {
+    const html = typeof received === "string" ? received : received instanceof Element ? received.innerHTML : void 0;
+    if (html === void 0) {
+      return {
+        pass: false,
+        message: () => `toBeValidHtml() needs an Element or an HTML string, and received ${typeof received}. From Testing Library, pass the container: expect(render(<X />).container).toBeValidHtml().`
+      };
+    }
+    engine ??= import("html-validate");
+    const { HtmlValidate } = await engine;
+    const validator = new HtmlValidate(config ?? W3C_CONFIG);
+    const document = asDocument(html);
+    const report = await validator.validateString(document.html);
+    const messages = report.results[0]?.messages ?? [];
+    return {
+      pass: messages.length === 0,
+      message: () => messages.length === 0 ? `expected invalid HTML, and html-validate found nothing to report.` : `${messages.length} HTML problem(s):
+
+${messages.map((message) => describe(message, document.wrapped)).join("\n")}`
+    };
+  }
+});
+export {
+  W3C_CONFIG
+};
+//# sourceMappingURL=w3c.js.map

package/dist/roles/test/setup/w3c.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/roles/test/setup/w3c.ts"],"sourcesContent":["/**\n * `expect(element).toBeValidHtml()`, run by html-validate.\n *\n * Opt in from a module's config:\n *\n *     setupFiles: ['@hublo/sentinel/test/setup/w3c']\n *\n * ## Why html-validate and not vnu\n *\n * vnu is the W3C's own checker and the W3C's own documentation advises against running it as a\n * service in a loop, which is what a test suite does. It also needs a JVM, but that was never the\n * deciding argument: measured on the same markup, the two agree on almost everything that matters\n * to a component test. What differs is the configuration, and configuration is the thing worth\n * owning.\n *\n * ## The fragment is WRAPPED in a page before it is validated\n *\n * A component renders a fragment, and a fragment cannot be held to document-level rules: it has no\n * doctype, no `<html lang>`, no `<title>`. The obvious answer is to switch those rules off, and it\n * is the wrong one, because they are the rules that catch what a component silently breaks inside\n * a real page.\n *\n * So the fragment is put INTO a minimal valid page and the page is validated. Héla brought this\n * from an OVH project that did the same with vnu, and measured here it is strictly better:\n *\n *     case                  standard + 3 rules      wrapped, standard + document + 3\n *     <img src=\"a.png\">     wcag/h37                wcag/h37\n *     <div><p>x</div>       no-implicit-close       no-implicit-close\n *     <input type=\"text\">   input-missing-label     input-missing-label\n *     <div id=\"a\" id=\"b\">   no-dup-attr             no-dup-attr\n *     <div id=\"a\"> x2       no-dup-id               no-dup-id\n *     <h1>a</h1><h3>b</h3>  nothing                 heading-level\n *     correct markup        nothing                 nothing\n *\n * The last two lines are the point: wrapping buys `heading-level`, a skipped heading rank, which\n * no fragment-level check can see, and it costs no false positive.\n *\n * ⚠️ `html-validate:document` is NOT a superset of `standard`, which is easy to assume and wrong:\n * measured on its own it caught `input-missing-label` and missed the other four. Both are extended,\n * plus the three rules neither of them carries.\n *\n * The wrapper is written on ONE line and its width is subtracted from every reported column, so a\n * position still points into the component's own markup rather than into our envelope.\n *\n * ## What a pass means\n *\n * That the markup this component rendered is well formed and carries the attributes those rules\n * require. It says nothing about the rest of the page it will live in, and nothing about anything\n * only a browser can decide. `toBeAccessible()` is the other half, and the two overlap on purpose:\n * `wcag/h37` and axe's `image-alt` are the same requirement seen by a parser and by a DOM.\n */\n/// <reference lib=\"dom\" />\nimport type { ConfigData, Message } from 'html-validate'\nimport { expect } from 'vitest'\n\n/**\n * The configuration, which is the thing that decides the outcome.\n *\n * Exported so a module can read what it is being held to, and so a test can assert on it rather\n * than on a behaviour that happens to follow from it.\n */\nexport const W3C_CONFIG: ConfigData = {\n  extends: ['html-validate:standard', 'html-validate:document'],\n  rules: {\n    'wcag/h37': 'error',\n    'no-implicit-close': 'error',\n    'input-missing-label': 'error',\n  },\n}\n\n/**\n * The page a fragment is put into, on ONE line so a reported position stays readable.\n *\n * `lang` and `<title>` are there because the document rules require them, and requiring them of\n * the COMPONENT would be wrong: it does not own the page it renders into.\n */\nconst PREFIX =\n  '<!DOCTYPE html><html lang=\"en\"><head><meta charset=\"utf-8\"><title>component under test</title></head><body>'\nconst SUFFIX = '</body></html>'\n\n/**\n * The fragment, inside a page, unless it already IS one.\n *\n * ⚠️ Conditional, taken from the OVH manager kit: a test that hands over a whole document, which\n * happens as soon as someone validates a server-rendered page, would otherwise get a second\n * doctype and a nested `<html>`, and every message after that would be about our wrapper.\n */\nfunction asDocument(html: string): { html: string; wrapped: boolean } {\n  const looksLikeADocument = /<!doctype\\s+html/i.test(html) || /<html[\\s>]/i.test(html)\n  return looksLikeADocument\n    ? { html, wrapped: false }\n    : { html: `${PREFIX}${html}${SUFFIX}`, wrapped: true }\n}\n\n/** The engine, kept once a suite has actually needed it. See the note at its first use. */\nlet engine: Promise<typeof import('html-validate')> | undefined\n\n/**\n * One message, with a position that points into the COMPONENT's markup.\n *\n * Everything the component rendered sits on the wrapper's single first line, so only a message on\n * line 1 needs its column moved back; a message on a later line is already at the component's own\n * coordinates.\n */\nfunction describe(message: Message, wrapped: boolean): string {\n  const shift = wrapped && message.line === 1 ? PREFIX.length : 0\n  const column = Math.max(message.column - shift, 1)\n  return `  ${message.line}:${column}  ${message.message}  (${message.ruleId})`\n}\n\nexpect.extend({\n  async toBeValidHtml(received: unknown, config?: ConfigData) {\n    const html =\n      typeof received === 'string'\n        ? received\n        : received instanceof Element\n          ? received.innerHTML\n          : undefined\n\n    if (html === undefined) {\n      return {\n        pass: false,\n        message: () =>\n          `toBeValidHtml() needs an Element or an HTML string, and received ${typeof received}. ` +\n          `From Testing Library, pass the container: expect(render(<X />).container).toBeValidHtml().`,\n      }\n    }\n\n    /*\n     * ⚠️ Loaded on FIRST USE. `setupFiles` runs per test FILE under Vitest's isolation, and\n     * html-validate costs 75 ms to import: on `host-admin`, 1460 files, that is 110 seconds added\n     * to every run for a matcher almost no file calls.\n     */\n    engine ??= import('html-validate')\n    const { HtmlValidate } = await engine\n    const validator = new HtmlValidate(config ?? W3C_CONFIG)\n    const document = asDocument(html)\n    const report = await validator.validateString(document.html)\n    const messages = report.results[0]?.messages ?? []\n\n    return {\n      pass: messages.length === 0,\n      message: () =>\n        messages.length === 0\n          ? `expected invalid HTML, and html-validate found nothing to report.`\n          : `${messages.length} HTML problem(s):\\n\\n` +\n            `${messages.map((message) => describe(message, document.wrapped)).join('\\n')}`,\n    }\n  },\n})\n\ndeclare module 'vitest' {\n  // `T = any` to match Vitest's own declaration; see the same note in `a11y.ts`.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  interface Matchers<T = any> {\n    /**\n     * Validate this element's markup with html-validate.\n     *\n     * ⚠️ The fragment is put INTO a minimal page before it is validated, so the document-level\n     * rules apply to what the component will actually sit in, without holding the component\n     * itself to a doctype it does not own.\n     */\n    toBeValidHtml: (config?: ConfigData) => Promise<T>\n  }\n}\n"],"mappings":";AAqDA,SAAS,cAAc;AAQhB,IAAM,aAAyB;AAAA,EACpC,SAAS,CAAC,0BAA0B,wBAAwB;AAAA,EAC5D,OAAO;AAAA,IACL,YAAY;AAAA,IACZ,qBAAqB;AAAA,IACrB,uBAAuB;AAAA,EACzB;AACF;AAQA,IAAM,SACJ;AACF,IAAM,SAAS;AASf,SAAS,WAAW,MAAkD;AACpE,QAAM,qBAAqB,oBAAoB,KAAK,IAAI,KAAK,cAAc,KAAK,IAAI;AACpF,SAAO,qBACH,EAAE,MAAM,SAAS,MAAM,IACvB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,IAAI,SAAS,KAAK;AACzD;AAGA,IAAI;AASJ,SAAS,SAAS,SAAkB,SAA0B;AAC5D,QAAM,QAAQ,WAAW,QAAQ,SAAS,IAAI,OAAO,SAAS;AAC9D,QAAM,SAAS,KAAK,IAAI,QAAQ,SAAS,OAAO,CAAC;AACjD,SAAO,KAAK,QAAQ,IAAI,IAAI,MAAM,KAAK,QAAQ,OAAO,MAAM,QAAQ,MAAM;AAC5E;AAEA,OAAO,OAAO;AAAA,EACZ,MAAM,cAAc,UAAmB,QAAqB;AAC1D,UAAM,OACJ,OAAO,aAAa,WAChB,WACA,oBAAoB,UAClB,SAAS,YACT;AAER,QAAI,SAAS,QAAW;AACtB,aAAO;AAAA,QACL,MAAM;AAAA,QACN,SAAS,MACP,oEAAoE,OAAO,QAAQ;AAAA,MAEvF;AAAA,IACF;AAOA,eAAW,OAAO,eAAe;AACjC,UAAM,EAAE,aAAa,IAAI,MAAM;AAC/B,UAAM,YAAY,IAAI,aAAa,UAAU,UAAU;AACvD,UAAM,WAAW,WAAW,IAAI;AAChC,UAAM,SAAS,MAAM,UAAU,eAAe,SAAS,IAAI;AAC3D,UAAM,WAAW,OAAO,QAAQ,CAAC,GAAG,YAAY,CAAC;AAEjD,WAAO;AAAA,MACL,MAAM,SAAS,WAAW;AAAA,MAC1B,SAAS,MACP,SAAS,WAAW,IAChB,sEACA,GAAG,SAAS,MAAM;AAAA;AAAA,EACf,SAAS,IAAI,CAAC,YAAY,SAAS,SAAS,SAAS,OAAO,CAAC,EAAE,KAAK,IAAI,CAAC;AAAA,IACpF;AAAA,EACF;AACF,CAAC;","names":[]}

package/dist/roles/test/setup/workspace-entry.js

@@ -1,7 +1,8 @@
 import {
   pinWorkspaceTimezone
-} from "../../../chunk-CPCUPK4J.js";
-import "../../../chunk-WLFE5RUU.js";
+} from "../../../chunk-Z7L4FGKP.js";
+import "../../../chunk-ELZHIN6E.js";
+import "../../../chunk-KMKQDGI6.js";
 
 // src/roles/test/setup/workspace-entry.ts
 await pinWorkspaceTimezone();

package/dist/roles/test/setup/workspace-entry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/roles/test/setup/workspace-entry.ts"],"sourcesContent":["/**\n * What the WORKSPACE's shared jest setup did, for the modules that actually loaded it.\n *\n * Separate from `setup/jest-parity` on purpose, and the split is the whole point. `setup/jest-parity` carries the\n * runner shims: `jest.*` semantics restored under Vitest, which every migrated module needs whatever\n * its config said. This entry carries the ZONE that `jest.setup.after.env.js` pinned at the workspace root, which\n * only a module whose jest config NAMED that file ever had:\n *\n *     require('dotenv-flow').config(...)      the .env cascade\n *     Settings.defaultZone = 'utc'            luxon's default zone\n *\n * Measured on this repo: 97 modules name the root setup, 7 name a setup of their own instead. For\n * those 7 the pin was never applied, and applying it in the migration changes what the suite does\n * while claiming to move it.\n *\n * `libs/front/logic` is the one that said so out loud. It has its own setup, uses luxon, and its\n * test is literally called \"formats them in the local zone\":\n *\n *     expect(formatTimeOfDay(new Date(2024, 2, 1, 8, 5))).toBe('08:05')\n *     // pinned to utc: '07:05'\n *\n * One test, and it would have been one silent hour of offset in any suite that did not assert it.\n */\nimport { pinWorkspaceTimezone } from './workspace.js'\n\n/*\n * Awaited at the top level, so the environment is loaded before the first test file is imported.\n * Deferring it to a `beforeAll` would be too late: a module read at import time would already have\n * captured an unset variable.\n */\nawait pinWorkspaceTimezone()\n"],"mappings":";;;;;;AA8BA,MAAM,qBAAqB;","names":[]}
+{"version":3,"sources":["../../../../src/roles/test/setup/workspace-entry.ts"],"sourcesContent":["/**\n * What the WORKSPACE's shared jest setup did, for the modules that actually loaded it.\n *\n * Separate from `setup/jest-parity` on purpose, and the split is the whole point. `setup/jest-parity` carries the\n * runner shims: `jest.*` semantics restored under Vitest, which every migrated module needs whatever\n * its config said. This entry carries the ZONE that `jest.setup.after.env.js` pinned at the workspace root, which\n * only a module whose jest config NAMED that file ever had:\n *\n *     require('dotenv-flow').config(...)      the .env cascade\n *     Settings.defaultZone = 'utc'            luxon's default zone\n *\n * Measured on this repo: 97 modules name the root setup, 7 name a setup of their own instead. For\n * those 7 the pin was never applied, and applying it in the migration changes what the suite does\n * while claiming to move it.\n *\n * `libs/front/logic` is the one that said so out loud. It has its own setup, uses luxon, and its\n * test is literally called \"formats them in the local zone\":\n *\n *     expect(formatTimeOfDay(new Date(2024, 2, 1, 8, 5))).toBe('08:05')\n *     // pinned to utc: '07:05'\n *\n * One test, and it would have been one silent hour of offset in any suite that did not assert it.\n */\nimport { pinWorkspaceTimezone } from './workspace.js'\n\n/*\n * Awaited at the top level, so the environment is loaded before the first test file is imported.\n * Deferring it to a `beforeAll` would be too late: a module read at import time would already have\n * captured an unset variable.\n */\nawait pinWorkspaceTimezone()\n"],"mappings":";;;;;;;AA8BA,MAAM,qBAAqB;","names":[]}

package/dist/roles/test/shared-test-config.d.ts

@@ -21,6 +21,19 @@ interface SharedTestOptions {
      * plugin for all of them took the suite from 98s to 249s.
      */
     lowerDecoratorsWithTypeScript?: boolean;
+    /**
+     * Let the files of this suite share a worker instead of each getting its own registry.
+     *
+     * Off by default, which is Vitest's own default and jest's semantics. Turning it off buys the
+     * whole of `./setup/file-boundary.js` and `./isolation-split.js`: measured on
+     * `front-components`, 44.6s isolated against 11.0s split, with all 1418 tests green and the
+     * same result across ten shuffled file orders.
+     *
+     * A module takes it deliberately, and proves it with `--validate`, because the switch is the one
+     * thing in this preset that changes what a suite MEANS: a file can see what an earlier file left
+     * behind, and only running the suite can say whether any of them does.
+     */
+    isolate?: boolean;
     /** Merged over the base. For what a module genuinely needs to differ on, nothing else. */
     overrides?: ViteUserConfig;
 }

package/dist/roles/test/shared-test-config.js

@@ -1,7 +1,8 @@
 import {
   sharedTestConfig
-} from "../../chunk-7PUVK4YM.js";
-import "../../chunk-3TDUIKVQ.js";
+} from "../../chunk-5VNYQIFD.js";
+import "../../chunk-SWWQ7X7B.js";
+import "../../chunk-QXFCZON7.js";
 export {
   sharedTestConfig
 };

package/dist/validate-BKD2ICT7.js

@@ -0,0 +1,170 @@
+import {
+  captureReference,
+  compareAgainstReference,
+  fromWorkspaceRoot,
+  hasReference,
+  moduleEnvironment,
+  readTestAdoption,
+  resolveVitest,
+  suiteOf
+} from "./chunk-BXXNV6NP.js";
+import "./chunk-O7REVMOC.js";
+import "./chunk-QXFCZON7.js";
+import "./chunk-KMKQDGI6.js";
+
+// src/roles/test/validate.ts
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function runVitest(cwd, config, extra = []) {
+  const { bin } = resolveVitest(cwd);
+  if (bin === void 0) return void 0;
+  const relocated = fromWorkspaceRoot(cwd, ["--config", config], []);
+  const out = join(mkdtempSync(join(tmpdir(), "sentinel-validate-")), "vitest.json");
+  try {
+    execFileSync(
+      bin,
+      ["run", ...relocated.options, ...extra, "--reporter=json", `--outputFile=${out}`],
+      {
+        cwd: relocated.cwd,
+        // The SAME environment the reference was taken in, or the two sides are two programs.
+        // `relocated.env` last: moving the process is part of the run, not part of the module.
+        env: { ...moduleEnvironment(cwd).env, ...relocated.env },
+        stdio: ["ignore", "ignore", "ignore"],
+        maxBuffer: 1 << 28
+      }
+    );
+  } catch {
+  }
+  if (!existsSync(out)) return void 0;
+  try {
+    return JSON.parse(readFileSync(out, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function vitestConfigFor(cwd, suite) {
+  const stems = suite === "main" ? ["vitest.config"] : [`vitest.${suite}.config`, `vitest.${suite}-config`];
+  for (const stem of stems) {
+    for (const extension of [".mts", ".ts", ".mjs", ".js"]) {
+      if (existsSync(join(cwd, `${stem}${extension}`))) return `${stem}${extension}`;
+    }
+  }
+  return void 0;
+}
+function sharesAWorker(cwd, config) {
+  try {
+    return /\bisolate\s*:\s*false\b/.test(readFileSync(join(cwd, config), "utf8"));
+  } catch {
+    return false;
+  }
+}
+function shuffledPassMatches(root, suite, config) {
+  const seed = Math.floor(Math.random() * 1e6);
+  const report = runVitest(root, config, ["--sequence.shuffle.files", `--sequence.seed=${seed}`]);
+  if (report === void 0) {
+    return {
+      ok: false,
+      message: `the shuffled pass (seed ${seed}) produced no report, so order independence is unproven.`
+    };
+  }
+  const comparison = compareAgainstReference(root, suite, report);
+  if (comparison.ok) {
+    return { ok: true, message: `and again in a random file order (seed ${seed}).` };
+  }
+  return {
+    ok: false,
+    message: `this suite shares a worker, and it depends on the ORDER of its files: in a random order (seed ${seed}) it no longer matches. ${comparison.message} Reproduce with \`--sequence.shuffle.files --sequence.seed=${seed}\`. Something a file does outlives it; until that is found, the suite is not safe without isolation.`
+  };
+}
+var KNOWN_SUITES = ["main", "prisma", "integration", "functional"];
+function suitesOf(cwd, adoption) {
+  const declared = adoption.state === "jest" ? adoption.jestConfigs.map(suiteOf) : KNOWN_SUITES.filter((suite) => vitestConfigFor(cwd, suite) !== void 0);
+  const recorded = KNOWN_SUITES.filter((suite) => hasReference(cwd, suite));
+  return [.../* @__PURE__ */ new Set([...declared, ...recorded])];
+}
+function validateModuleTests(name, root) {
+  const adoption = readTestAdoption(root);
+  if (adoption.state === "no-tests") {
+    return [
+      { module: name, suite: "main", ok: true, message: `no tests, so there is nothing to prove.` }
+    ];
+  }
+  const suites = suitesOf(root, adoption);
+  if (suites.length === 0) {
+    return [
+      {
+        module: name,
+        suite: "main",
+        ok: false,
+        message: `no test config could be read, so there is no suite to prove.`
+      }
+    ];
+  }
+  return suites.map((suite) => validateSuite(name, root, adoption, suite));
+}
+function validateSuite(name, root, adoption, suite) {
+  if (hasReference(root, suite)) {
+    if (adoption.state === "jest") {
+      return {
+        module: name,
+        suite,
+        ok: false,
+        message: `a reference is recorded, but this module still tests with jest (${adoption.jestConfigs.join(", ")}). Migrate it with \`sentinel --init --test\`, then run this again to compare.`
+      };
+    }
+    const config2 = vitestConfigFor(root, suite);
+    if (config2 === void 0) {
+      return {
+        module: name,
+        suite,
+        ok: false,
+        message: `a reference is recorded for the \`${suite}\` suite, and this module has no Vitest config for it. The migration wrote one config where the jest side had two, so one suite is not running at all.`
+      };
+    }
+    const report = runVitest(root, config2);
+    if (report === void 0) {
+      return {
+        module: name,
+        suite,
+        ok: false,
+        message: `the Vitest run produced no report, so nothing could be compared. Check that the suite starts at all: \`sentinel --run --test\`.`
+      };
+    }
+    const comparison = compareAgainstReference(root, suite, report);
+    if (!comparison.ok || !sharesAWorker(root, config2)) {
+      return { module: name, suite, ok: comparison.ok, message: comparison.message };
+    }
+    const shuffled = shuffledPassMatches(root, suite, config2);
+    return {
+      module: name,
+      suite,
+      ok: shuffled.ok,
+      message: shuffled.ok ? `${comparison.message} ${shuffled.message}` : shuffled.message
+    };
+  }
+  if (adoption.state !== "jest") {
+    return {
+      module: name,
+      suite,
+      ok: false,
+      message: `already migrated, and no reference was recorded before it was, so there is nothing to compare against. A proof has to be started BEFORE the migration: \`sentinel --validate --test\` on the jest state, then \`--init --test\`, then this again.`
+    };
+  }
+  const config = adoption.jestConfigs.find((candidate) => suiteOf(candidate) === suite);
+  if (config === void 0) {
+    return {
+      module: name,
+      suite,
+      ok: false,
+      message: `this module reads as jest but names no config for the \`${suite}\` suite.`
+    };
+  }
+  const capture = captureReference(root, config);
+  return { module: name, suite, ok: capture.captured, message: capture.message };
+}
+export {
+  sharesAWorker,
+  validateModuleTests
+};