declapract-typescript-ehmpathy 0.49.11 → 0.49.13

package/dist/practices/terraform-aws/best-practice/provision/aws/environments/prep/main.tf

@@ -1,6 +1,6 @@
 provider "aws" {
   region              = "us-east-1"
-  allowed_account_ids = ["@declapract{variable.awsAccountId.prep}"] # `prep` access tier resources are provisioned in the `prep` aws account
+  allowed_account_ids = ["@declapract{variable.awsAccountId.prep}"] # `prep` access resources are provisioned in the `prep` aws account
 }
 
 terraform {

package/dist/practices/tests-any/__snapshots__/changedsince-origin-main.declapract.integration.test.ts.snap

@@ -0,0 +1,8 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`tests-any changedSince=origin/main policy given: the shipped best-practice/package.json when: the changed-file test commands are read then: the emitted changed-file commands match snapshot: tests-any changed-file commands 1`] = `
+{
+  "test:integration": "set -eu && jest -c ./jest.integration.config.ts --forceExit --verbose --passWithNoTests $([ -n "\${CI:-}" ] && echo '--ci') $([ "\${THOROUGH:-}" != "true" ] && echo '--changedSince=origin/main') $([ "\${RESNAP:-}" = "true" ] && echo '--updateSnapshot')",
+  "test:unit": "set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n "\${CI:-}" ] && echo '--ci') $([ "\${THOROUGH:-}" != "true" ] && echo '--changedSince=origin/main') $([ "\${RESNAP:-}" = "true" ] && echo '--updateSnapshot')",
+}
+`;

package/dist/practices/tests-any/autoprune-hooks.declapract.integration.test.ts

@@ -0,0 +1,104 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { given, then, when } from 'test-fns';
+
+/**
+ * .what = clamps that every jest config template the tests-node / tests-expo practices ship
+ *         REACHES both autoprune hooks -- never one without the other -- whether it wires the
+ *         autoprune setup DIRECTLY or through a COMPOSITE globalSetup.
+ * .why  = test-fns >=1.16 reclaims the temp dirs genTempDir makes, but jest needs TWO keys:
+ *         globalSetup stamps the run, globalTeardown reclaims its dirs. a config with globalSetup
+ *         and NO globalTeardown stamps every dir and reclaims none -- the half-wired state #590
+ *         names, which test-fns itself detects + reports but the practice must never SHIP. the
+ *         floor bump (tests-any package.json, test-fns >=1.17.0) delivers the capability; this
+ *         clamp guards the wire-up so a future edit cannot drop one key and leave the other.
+ * .why-composite = #598 makes the two node suite configs (integration + acceptance) COMPOSE an
+ *         livedb wake with autoprune's setup, so their `globalSetup` points at a local
+ *         `jest.<suite>.prepare.ts` rather than the `test-fns/autoprune.setup.jest` subpath
+ *         directly. jest allows ONE globalSetup, so the composite is how both run. this clamp
+ *         follows the indirection: a composite config still REACHES autoprune iff its globalSetup
+ *         file imports the autoprune subpath. so a drop of the autoprune import from a composite
+ *         reddens here exactly as a drop of the direct key would.
+ * .teeth = remove `globalTeardown` from any config, OR remove the autoprune setup from a direct
+ *          config, OR drop the `test-fns/autoprune.setup.jest` import from a composite globalSetup
+ *          file, and the matched case reddens (the both-reached-together assertion).
+ * .note = the subject is the shipped TEMPLATE text, read as a string -- so this clamp is
+ *         independent of which test-fns version is installed here (the autoprune subpaths only
+ *         need to load in a CONSUMER, which the floor bump guarantees). the `.declapract.test.ts`
+ *         suffix is this repo's UNIT-test marker; declapract's loader excludes `.test.ts`, so this
+ *         file is neither loaded as a declaration nor copied to a consumer.
+ */
+
+// a DIRECT config wires the setup as `globalSetup: 'test-fns/autoprune.setup.jest'`; a COMPOSITE
+// file IMPORTS it as `... from 'test-fns/autoprune.setup.jest'`. the two forms are distinct on
+// purpose: a `.why` comment may quote the `globalSetup: '...'` form as prose, so the composite
+// reach-check matches the IMPORT form (`from '...'`), which a comment does not carry -- else a
+// mere mention of the subpath in a comment would satisfy the clamp (a teeth hole caught in dogfood).
+const SETUP_DIRECT_KEY = "globalSetup: 'test-fns/autoprune.setup.jest'";
+const SETUP_IMPORT = "from 'test-fns/autoprune.setup.jest'";
+const TEARDOWN_KEY = "globalTeardown: 'test-fns/autoprune.teardown.jest'";
+
+// anchor on __dirname, not process.cwd(): the repo-root-relative paths below must point at the same
+// file wherever jest is invoked from (a nested `jest src/practices/...` run has a different cwd).
+// from this file (src/practices/tests-any/) the repo root is three segments up.
+const REPO_ROOT = join(__dirname, '../../..');
+
+// each config either wires the autoprune setup DIRECTLY, or COMPOSES it via a local globalSetup
+// file that imports the autoprune subpath. `composite` names that file, relative to the practice.
+const configs: { relPath: string; composite: string | null }[] = [
+  { relPath: 'src/practices/tests-node/best-practice/jest.unit.config.ts', composite: null },
+  {
+    relPath: 'src/practices/tests-node/best-practice/jest.integration.config.ts',
+    composite: 'src/practices/tests-node/best-practice/jest.integration.prepare.ts',
+  },
+  {
+    relPath: 'src/practices/tests-node/best-practice/jest.acceptance.config.ts',
+    composite: 'src/practices/tests-node/best-practice/jest.acceptance.prepare.ts',
+  },
+  { relPath: 'src/practices/tests-expo/best-practice/jest.unit.config.ts', composite: null },
+  { relPath: 'src/practices/tests-expo/best-practice/jest.integration.config.ts', composite: null },
+  { relPath: 'src/practices/tests-expo/best-practice/jest.acceptance.config.ts', composite: null },
+];
+
+/**
+ * .what = whether a config REACHES the autoprune setup -- directly, or through its composite.
+ * .why  = the invariant #590 guards is "setup is reached", not "setup is inline". a composite
+ *         config reaches it iff its globalSetup file imports the autoprune subpath.
+ */
+const reachesAutopruneSetup = (input: {
+  configContents: string;
+  composite: string | null;
+}): boolean => {
+  // direct: the config itself wires `globalSetup: 'test-fns/autoprune.setup.jest'`
+  if (input.configContents.includes(SETUP_DIRECT_KEY)) return true;
+
+  // composite: the config points at a local globalSetup file that IMPORTS the autoprune subpath
+  if (!input.composite) return false;
+  const compositeContents = readFileSync(join(REPO_ROOT, input.composite), 'utf8');
+  return compositeContents.includes(SETUP_IMPORT);
+};
+
+describe('autoprune hook reach across the shipped jest configs', () => {
+  for (const { relPath, composite } of configs) {
+    given(`[case] ${relPath}${composite ? ' (composite)' : ' (direct)'}`, () => {
+      const configContents = readFileSync(join(REPO_ROOT, relPath), 'utf8');
+
+      when('[t0] the shipped config is read', () => {
+        then('it reaches the autoprune setup (stamps the run)', () => {
+          expect(reachesAutopruneSetup({ configContents, composite })).toEqual(true);
+        });
+
+        then('it wires globalTeardown (reclaims the dirs)', () => {
+          expect(configContents).toContain(TEARDOWN_KEY);
+        });
+
+        then('it never ships one hook without the other (half-wired = stamp, no reclaim)', () => {
+          const reachesSetup = reachesAutopruneSetup({ configContents, composite });
+          const hasTeardown = configContents.includes(TEARDOWN_KEY);
+          expect(reachesSetup).toEqual(hasTeardown);
+        });
+      });
+    });
+  }
+});

package/dist/practices/tests-any/bad-practices/old-acceptance-import-paths/.declapract.readme.md

@@ -21,11 +21,11 @@ replaces all occurrences of `acceptance/` with `blackbox/` in import paths.
 before:
 ```typescript
 import { locally } from '../acceptance/environment';
-import { stage } from '../../acceptance/utils/environment';
+import { access } from '../../acceptance/utils/environment';
 ```
 
 after:
 ```typescript
 import { locally } from '../blackbox/environment';
-import { stage } from '../../blackbox/utils/environment';
+import { access } from '../../blackbox/utils/environment';
 ```

package/dist/practices/tests-any/bad-practices/old-acceptance-test-utils/blackbox/lambdas/<star>.ts.declapract.ts

@@ -20,7 +20,6 @@ export const fix: FileFixFunction = async (contents, context) => {
         `import { invokeLambda } from '../_utils/invokeLambda';`,
         [
           `import { invokeLambdaForTesting } from 'simple-lambda-testing-methods';`,
-          `import { stage } from '../../src/utils/environment';`,
           `import { locally } from '../environment';`,
         ].join('\n'),
       )
@@ -30,14 +29,15 @@ export const fix: FileFixFunction = async (contents, context) => {
         'invokeLambdaForTesting({',
       )
       .replace(
-        // replace the inputs
-        /name: '(\w+)',/g,
-        [
-          `service: '${projectName}',`,
-          `function: '$1',`,
-          `stage,`,
-          `locally,`,
-        ].join('\n'),
+        // replace the inputs; capture the indent that precedes `name:` so the
+        // expanded 3-line option block stays aligned with its siblings
+        /^([ \t]*)name: '(\w+)',/gm,
+        (_match, indent, fnName) =>
+          [
+            `${indent}service: '${projectName}',`,
+            `${indent}function: '${fnName}',`,
+            `${indent}locally,`,
+          ].join('\n'),
       )
       .replace(/data: /g, 'event: '),
   };

package/dist/practices/tests-any/best-practice/package.json

@@ -4,12 +4,12 @@
     "@types/jest": "@declapract{check.minVersion('30.0.0')}",
     "jest": "@declapract{check.minVersion('30.2.0')}",
     "esbuild-register": "@declapract{check.minVersion('3.6.0')}",
-    "test-fns": "@declapract{check.minVersion('1.15.8')}",
+    "test-fns": "@declapract{check.minVersion('1.17.0')}",
     "tsx": "@declapract{check.minVersion('4.20.6')}"
   },
   "scripts": {
-    "test:unit": "set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n \"${CI:-}\" ] && echo '--ci') $([ \"${THOROUGH:-}\" != \"true\" ] && echo '--changedSince=main') $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')",
-    "test:integration": "set -eu && jest -c ./jest.integration.config.ts --forceExit --verbose --passWithNoTests $([ -n \"${CI:-}\" ] && echo '--ci') $([ \"${THOROUGH:-}\" != \"true\" ] && echo '--changedSince=main') $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')",
+    "test:unit": "set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n \"${CI:-}\" ] && echo '--ci') $([ \"${THOROUGH:-}\" != \"true\" ] && echo '--changedSince=origin/main') $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')",
+    "test:integration": "set -eu && jest -c ./jest.integration.config.ts --forceExit --verbose --passWithNoTests $([ -n \"${CI:-}\" ] && echo '--ci') $([ \"${THOROUGH:-}\" != \"true\" ] && echo '--changedSince=origin/main') $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')",
     "test:acceptance:locally": "set -eu && npm run build && LOCALLY=true jest -c ./jest.acceptance.config.ts --forceExit --verbose --runInBand --passWithNoTests $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')",
     "test": "set -eu && npm run test:commits && npm run test:types && npm run test:format && npm run test:lint && npm run test:unit && npm run test:integration && npm run test:acceptance:locally",
     "test:acceptance": "set -eu && npm run build && jest -c ./jest.acceptance.config.ts --forceExit --verbose --runInBand --passWithNoTests $([ -n \"${CI:-}\" ] && echo '--ci') $([ \"${RESNAP:-}\" = \"true\" ] && echo '--updateSnapshot')"

package/dist/practices/tests-any/changedsince-origin-main.declapract.integration.test.ts

@@ -0,0 +1,58 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { given, then, when } from 'test-fns';
+
+/**
+ * .what = clamps #531: the shipped `test:unit` + `test:integration` commands scope changed-file
+ *         detection against `origin/main`, NEVER bare `main`.
+ * .why  = a local `main` drifts behind the real trunk the moment a teammate merges without a local
+ *         pull, so `--changedSince=main` drags unrelated already-merged suites into scope — the
+ *         exact stale-ref defect #531 names. `origin/main` is the true fork point, so the scope
+ *         holds only this branch's own change.
+ * .teeth = revert either command to `--changedSince=main` in best-practice/package.json and the
+ *          "no bare main" assertion reddens (the emitted `echo '--changedSince=main'` carries the
+ *          `--changedSince=main'` token; the origin form carries `--changedSince=origin/main'`,
+ *          which does NOT contain it).
+ * .note = the subject is the shipped TEMPLATE, read once from __dirname (a single static-file read,
+ *         as the kin `dpdmrc-exclude-policy` / `commitlint-body-max-line` clamps do). this file
+ *         sits at the practice ROOT, so declapract never emits it (per the #583 relocation convention).
+ */
+describe('tests-any changedSince=origin/main policy', () => {
+  given('the shipped best-practice/package.json', () => {
+    const parsed = JSON.parse(
+      readFileSync(join(__dirname, 'best-practice/package.json'), 'utf8'),
+    );
+    const scripts: Record<string, string> = parsed?.scripts ?? {};
+
+    when('the changed-file test commands are read', () => {
+      then('test:unit scopes against origin/main', () => {
+        expect(scripts['test:unit']).toContain('--changedSince=origin/main');
+      });
+
+      then('test:integration scopes against origin/main', () => {
+        expect(scripts['test:integration']).toContain(
+          '--changedSince=origin/main',
+        );
+      });
+
+      then('neither command scopes against a bare local main', () => {
+        // the emitted flag is quoted: `echo '--changedSince=origin/main'`. a bare-main revert
+        // emits `echo '--changedSince=main'`, whose `--changedSince=main'` token the origin form
+        // never carries — so this token is the precise teeth for the drift #531 forbids.
+        const bareMainToken = "--changedSince=main'";
+        expect(scripts['test:unit']).not.toContain(bareMainToken);
+        expect(scripts['test:integration']).not.toContain(bareMainToken);
+      });
+
+      // the emitted commands are the caller-faced contract: snapshot both so a reword that keeps
+      // the origin token green (a re-ordered flag, a reshaped command) reddens a vibecheck.
+      then('the emitted changed-file commands match snapshot', () => {
+        expect({
+          'test:unit': scripts['test:unit'],
+          'test:integration': scripts['test:integration'],
+        }).toMatchSnapshot('tests-any changed-file commands');
+      });
+    });
+  });
+});

package/dist/practices/tests-any/{best-practice/package.json.shell-flags.declapract.integration.test.ts → package.json.shell-flags.declapract.integration.test.ts}

@@ -1,5 +1,17 @@
 import { execSync } from 'child_process';
 
+/**
+ * .what = read the whitespace-split arg list out of the stand-in jest echo output.
+ * .why  = a pure transformer that names the `JEST_ARGS: …` decode, so `getJestFlags` reads
+ *         what-not-how rather than an inline regex-match + positional `match[1]` a reader must
+ *         simulate. no output line = an empty arg list.
+ */
+const asArgsFromJestEchoOutput = (input: { output: string }): string[] => {
+  const found = input.output.match(/JEST_ARGS: (.*)/);
+  if (!found) return [];
+  return found[1].split(/\s+/).filter(Boolean);
+};
+
 /**
  * Tests the shell flag expressions used in package.json test commands.
  *
@@ -32,14 +44,14 @@ describe('package.json shell flag expressions', () => {
         cleanEnv[key] = value;
       }
     }
-    // Overlay the test env vars (undefined means unset)
+    // overlay the test env vars (undefined means unset)
     for (const [key, value] of Object.entries(env)) {
       if (value !== undefined) {
         cleanEnv[key] = value;
       }
     }
 
-    // Run the command with jest replaced by echo to capture args
+    // run the command with jest replaced by echo to capture args
     const result = execSync(
       `bash -c 'jest() { echo "JEST_ARGS: $*"; }; ${command}'`,
       {
@@ -52,14 +64,12 @@ describe('package.json shell flag expressions', () => {
       },
     );
 
-    // Extract the jest args from output
-    const match = result.match(/JEST_ARGS: (.*)/);
-    if (!match) return [];
-    return match[1].split(/\s+/).filter(Boolean);
+    // read the jest args out of the stand-in echo output (named, what-not-how)
+    return asArgsFromJestEchoOutput({ output: result });
   };
 
-  // The test:unit command from package.json best-practice
-  const testUnitCommand = `set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n "\${CI:-}" ] && echo '--ci') $([ "\${THOROUGH:-}" != "true" ] && echo '--changedSince=main') $([ "\${RESNAP:-}" = "true" ] && echo '--updateSnapshot')`;
+  // the test:unit command from package.json best-practice
+  const testUnitCommand = `set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n "\${CI:-}" ] && echo '--ci') $([ "\${THOROUGH:-}" != "true" ] && echo '--changedSince=origin/main') $([ "\${RESNAP:-}" = "true" ] && echo '--updateSnapshot')`;
 
   describe('RESNAP flag', () => {
     it('should pass --updateSnapshot when RESNAP=true', () => {
@@ -89,24 +99,24 @@ describe('package.json shell flag expressions', () => {
   });
 
   describe('THOROUGH flag', () => {
-    it('should pass --changedSince=main when THOROUGH is unset (run only changed)', () => {
+    it('should pass --changedSince=origin/main when THOROUGH is unset (run only changed)', () => {
       const flags = getJestFlags(testUnitCommand, {});
-      expect(flags).toContain('--changedSince=main');
+      expect(flags).toContain('--changedSince=origin/main');
     });
 
-    it('should pass --changedSince=main when THOROUGH=false', () => {
+    it('should pass --changedSince=origin/main when THOROUGH=false', () => {
       const flags = getJestFlags(testUnitCommand, { THOROUGH: 'false' });
-      expect(flags).toContain('--changedSince=main');
+      expect(flags).toContain('--changedSince=origin/main');
     });
 
-    it('should pass --changedSince=main when THOROUGH is empty string', () => {
+    it('should pass --changedSince=origin/main when THOROUGH is empty string', () => {
       const flags = getJestFlags(testUnitCommand, { THOROUGH: '' });
-      expect(flags).toContain('--changedSince=main');
+      expect(flags).toContain('--changedSince=origin/main');
     });
 
-    it('should not pass --changedSince=main when THOROUGH=true (run all tests)', () => {
+    it('should not pass --changedSince=origin/main when THOROUGH=true (run all tests)', () => {
       const flags = getJestFlags(testUnitCommand, { THOROUGH: 'true' });
-      expect(flags).not.toContain('--changedSince=main');
+      expect(flags).not.toContain('--changedSince=origin/main');
     });
   });
 

package/dist/practices/tests-expo/.declapract.integration.test.ts

@@ -92,11 +92,15 @@ describe('expo test-toolchain triad — pipeline', () => {
         expect(pkg.scripts.build).toEqual('npm run build:web');
       });
 
-      then('package.json carries the typescript + jest-expo deps at concrete versions', () => {
+      then('package.json carries the typescript dep at a concrete version, and the SDK-coupled expo deps gated to the repo majors', () => {
         const pkg = JSON.parse(state.pkgSettled!);
+        // typescript is a plain minVersion floor (tests-any), resolved concrete on pass 2
         expect(pkg.devDependencies.typescript).toEqual('5.4.5');
-        expect(pkg.devDependencies['jest-expo']).toEqual('54.0.0');
-        expect(pkg.devDependencies['react-test-renderer']).toEqual('19.0.0');
+        // jest-expo + react-test-renderer are GATED to the repo's own expo/react majors (#584):
+        // the fixture declares expo ^54 + react ^19, so the gate pins jest-expo to the expo major
+        // and react-test-renderer to the react major (caret, not a fixed pin — the major is the gate)
+        expect(pkg.devDependencies['jest-expo']).toEqual('^54.0.0');
+        expect(pkg.devDependencies['react-test-renderer']).toEqual('^19.0.0');
       });
 
       then('tsconfig.json extends the expo base, not the node base', () => {

package/dist/practices/tests-expo/.test/assets/repo-expo-greenfield/package.json

@@ -1,4 +1,8 @@
 {
   "name": "test-expo-app",
-  "version": "1.0.0"
+  "version": "1.0.0",
+  "dependencies": {
+    "expo": "^54.0.0",
+    "react": "^19.0.0"
+  }
 }

package/dist/practices/tests-expo/__snapshots__/.declapract.integration.test.ts.snap

@@ -48,6 +48,11 @@ const config: Config = {
   ],
   setupFilesAfterEnv: ['./jest.unit.env.ts'],
 
+  // reclaim every temp dir genTempDir made this run (test-fns autoprune). jest needs BOTH keys;
+  // one without the other stamps and never reclaims.
+  globalSetup: 'test-fns/autoprune.setup.jest',
+  globalTeardown: 'test-fns/autoprune.teardown.jest',
+
   // use 50% of threads to leave headroom for other processes
   maxWorkers: '50%', // https://stackoverflow.com/questions/71287710/why-does-jest-run-faster-with-maxworkers-50
 };
@@ -61,23 +66,27 @@ exports[`expo test-toolchain triad — pipeline given: [case1] a fresh expo repo
 "{
   "name": "test-expo-app",
   "version": "1.0.0",
+  "dependencies": {
+    "expo": "^54.0.0",
+    "react": "^19.0.0"
+  },
   "devDependencies": {
     "@jest/globals": "30.2.0",
     "@types/jest": "30.0.0",
     "jest": "30.2.0",
     "esbuild-register": "3.6.0",
-    "test-fns": "1.15.8",
+    "test-fns": "1.17.0",
     "tsx": "4.20.6",
-    "jest-expo": "54.0.0",
-    "@babel/core": "7.24.0",
-    "babel-preset-expo": "12.0.0",
-    "react-test-renderer": "19.0.0",
-    "isomorphic-fetch": "3.0.0",
+    "jest-expo": "^54.0.0",
+    "react-test-renderer": "^19.0.0",
+    "@babel/core": "^7.24.0",
+    "babel-preset-expo": "^12.0.0",
+    "isomorphic-fetch": "^3.0.0",
     "typescript": "5.4.5"
   },
   "scripts": {
-    "test:unit": "set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n \\"\${CI:-}\\" ] && echo '--ci') $([ \\"\${THOROUGH:-}\\" != \\"true\\" ] && echo '--changedSince=main') $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",
-    "test:integration": "set -eu && jest -c ./jest.integration.config.ts --forceExit --verbose --passWithNoTests $([ -n \\"\${CI:-}\\" ] && echo '--ci') $([ \\"\${THOROUGH:-}\\" != \\"true\\" ] && echo '--changedSince=main') $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",
+    "test:unit": "set -eu && jest -c ./jest.unit.config.ts --forceExit --verbose --passWithNoTests $([ -n \\"\${CI:-}\\" ] && echo '--ci') $([ \\"\${THOROUGH:-}\\" != \\"true\\" ] && echo '--changedSince=origin/main') $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",
+    "test:integration": "set -eu && jest -c ./jest.integration.config.ts --forceExit --verbose --passWithNoTests $([ -n \\"\${CI:-}\\" ] && echo '--ci') $([ \\"\${THOROUGH:-}\\" != \\"true\\" ] && echo '--changedSince=origin/main') $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",
     "test:acceptance:locally": "set -eu && npm run build && LOCALLY=true jest -c ./jest.acceptance.config.ts --forceExit --verbose --runInBand --passWithNoTests $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",
     "test": "set -eu && npm run test:commits && npm run test:types && npm run test:format && npm run test:lint && npm run test:unit && npm run test:integration && npm run test:acceptance:locally",
     "test:acceptance": "set -eu && npm run build && jest -c ./jest.acceptance.config.ts --forceExit --verbose --runInBand --passWithNoTests $([ -n \\"\${CI:-}\\" ] && echo '--ci') $([ \\"\${RESNAP:-}\\" = \\"true\\" ] && echo '--updateSnapshot')",

package/dist/practices/tests-expo/__snapshots__/package.json.declapract.integration.test.ts.snap

@@ -0,0 +1,60 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`tests-expo package.json — pipeline gate on the repo expo/react major given: [case1] an expo-51 / react-18 repo seeded with a react-19-era jest-expo 54 the gate aligns down to the expo major (51) when: [t0] the tests-expo gate is applied to the seeded package.json then: before + after match snapshot: package.json — after gate 1`] = `
+"{
+  "name": "app-protools-shaped",
+  "version": "1.0.0",
+  "packageManager": "pnpm@10.32.1",
+  "scripts": {
+    "install:deps": "npm install",
+    "start": "expo start"
+  },
+  "overrides": {
+    "type-fns": "1.9.9"
+  },
+  "resolutions": {
+    "@commitlint/format": "19.9.9"
+  },
+  "devDependencies": {
+    "expo": "~51.0.0",
+    "react": "18.2.0",
+    "jest-expo": "^51.0.0",
+    "react-test-renderer": "^18.0.0",
+    "babel-preset-expo": "^12.0.0",
+    "isomorphic-fetch": "^3.0.0",
+    "@babel/core": "^7.24.0"
+  }
+}
+"
+`;
+
+exports[`tests-expo package.json — pipeline gate on the repo expo/react major given: [case1] an expo-51 / react-18 repo seeded with a react-19-era jest-expo 54 the gate aligns down to the expo major (51) when: [t0] the tests-expo gate is applied to the seeded package.json then: before + after match snapshot: package.json — before 1`] = `
+"{
+  "name": "app-protools-shaped",
+  "version": "1.0.0",
+  "packageManager": "pnpm@10.32.1",
+  "scripts": {
+    "install:deps": "npm install",
+    "start": "expo start"
+  },
+  "overrides": {
+    "type-fns": "1.9.9"
+  },
+  "resolutions": {
+    "@commitlint/format": "19.9.9"
+  },
+  "jest": {
+    "preset": "jest-expo",
+    "testEnvironment": "jsdom"
+  },
+  "devDependencies": {
+    "expo": "~51.0.0",
+    "react": "18.2.0",
+    "jest-expo": "^54.0.0",
+    "react-test-renderer": "^19.0.0",
+    "babel-preset-expo": "^12.0.0",
+    "isomorphic-fetch": "^3.0.0"
+  }
+}
+"
+`;

package/dist/practices/tests-expo/best-practice/jest.acceptance.config.ts

@@ -35,6 +35,11 @@ const config: Config = {
   testMatch: ['**/*.acceptance.test.{ts,tsx}', '!**/.agent/.cache/**', '!**/.yalc/**'],
   setupFilesAfterEnv: ['./jest.acceptance.env.ts'],
 
+  // reclaim every temp dir genTempDir made this run (test-fns autoprune). jest needs BOTH keys;
+  // one without the other stamps and never reclaims.
+  globalSetup: 'test-fns/autoprune.setup.jest',
+  globalTeardown: 'test-fns/autoprune.teardown.jest',
+
   // use 50% of threads to leave headroom for other processes
   maxWorkers: '50%', // https://stackoverflow.com/questions/71287710/why-does-jest-run-faster-with-maxworkers-50
 };

package/dist/practices/tests-expo/best-practice/jest.integration.config.ts

@@ -34,6 +34,11 @@ const config: Config = {
   testMatch: ['**/*.integration.test.{ts,tsx}', '!**/.agent/.cache/**', '!**/.yalc/**'],
   setupFilesAfterEnv: ['./jest.integration.env.ts'],
 
+  // reclaim every temp dir genTempDir made this run (test-fns autoprune). jest needs BOTH keys;
+  // one without the other stamps and never reclaims.
+  globalSetup: 'test-fns/autoprune.setup.jest',
+  globalTeardown: 'test-fns/autoprune.teardown.jest',
+
   // use 50% of threads to leave headroom for other processes
   maxWorkers: '50%', // https://stackoverflow.com/questions/71287710/why-does-jest-run-faster-with-maxworkers-50
 };

package/dist/practices/tests-expo/best-practice/jest.integration.env.ts

@@ -1,6 +1,7 @@
 import util from 'node:util';
 
 import { jest } from '@jest/globals';
+import { ConstraintError } from 'helpful-errors';
 
 // provide fetch for the test env, like the browser/native runtime does
 import 'isomorphic-fetch';
@@ -19,4 +20,7 @@ util.inspect.defaultOptions.depth = 5;
  * .why = prevent prod state pollution + financial mutations from test data
  */
 if (process.env.NODE_ENV !== 'test' && process.env.I_KNOW_THE_RISKS !== 'true')
-  throw new Error(`integration-test does not target stage 'test'`);
+  throw new ConstraintError(
+    `integration.test config must be 'test' — set NODE_ENV=test (or I_KNOW_THE_RISKS=true to override)`,
+    { nodeEnv: process.env.NODE_ENV ?? null },
+  );

package/dist/practices/tests-expo/best-practice/jest.unit.config.ts

@@ -45,6 +45,11 @@ const config: Config = {
   ],
   setupFilesAfterEnv: ['./jest.unit.env.ts'],
 
+  // reclaim every temp dir genTempDir made this run (test-fns autoprune). jest needs BOTH keys;
+  // one without the other stamps and never reclaims.
+  globalSetup: 'test-fns/autoprune.setup.jest',
+  globalTeardown: 'test-fns/autoprune.teardown.jest',
+
   // use 50% of threads to leave headroom for other processes
   maxWorkers: '50%', // https://stackoverflow.com/questions/71287710/why-does-jest-run-faster-with-maxworkers-50
 };

package/dist/practices/tests-expo/best-practice/jest.unit.env.ts

@@ -1,5 +1,7 @@
 import util from 'node:util';
 
+import { ConstraintError } from 'helpful-errors';
+
 // provide fetch for the test env, like the browser/native runtime does
 import 'isomorphic-fetch';
 
@@ -15,4 +17,7 @@ util.inspect.defaultOptions.depth = 5;
  * .why = prevent prod state pollution + financial mutations from test data
  */
 if (process.env.NODE_ENV !== 'test' && process.env.I_KNOW_THE_RISKS !== 'true')
-  throw new Error(`unit-test does not target stage 'test'`);
+  throw new ConstraintError(
+    `unit.test config must be 'test' — set NODE_ENV=test (or I_KNOW_THE_RISKS=true to override)`,
+    { nodeEnv: process.env.NODE_ENV ?? null },
+  );