declapract-typescript-ehmpathy 0.49.15 → 0.50.0

package/dist/.test/assets/git/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils-2/declapract.use.yml

@@ -0,0 +1,9 @@
+# .note = declarations dir is symlinked by the test to src/.test/assets/tests-any-only/declarations
+#         the variables stay: the fix reads projectName from this file for the `which` it emits
+declarations: 'declarations/declapract.declare.yml'
+useCase: tests-any-only
+variables:
+  organizationName: 'test-org'
+  projectName: 'svc-images'
+  reviewers:
+    users: ['user1']

package/dist/.test/assets/git/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils-2/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "test-project",
+  "version": "1.0.0"
+}

package/dist/.test/assets/git/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils-3/blackbox/lambdas/addDecoratedImage.acceptance.test.ts

@@ -0,0 +1,19 @@
+import { invokeLambdaForTesting } from 'simple-lambda-testing-methods';
+
+import { locally } from '../_utils/environment';
+
+describe('addDecoratedImage', () => {
+  it('it should be possible to add a decorated image', async () => {
+    const response = await invokeLambdaForTesting({
+      service: 'svc-images',
+      function: 'addDecoratedImage',
+      locally,
+      event: {
+        url: 'https://some.url',
+        description: 'bo vine at his gig, moooooin the lawn',
+        focalArea: null,
+      },
+    });
+    expect(response.image).toHaveProperty('uuid');
+  });
+});

package/dist/.test/assets/git/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils-3/declapract.use.yml

@@ -0,0 +1,9 @@
+# .note = declarations dir is symlinked by the test to src/.test/assets/tests-any-only/declarations
+#         the variables stay: the fix reads projectName from this file for the `which` it emits
+declarations: 'declarations/declapract.declare.yml'
+useCase: tests-any-only
+variables:
+  organizationName: 'test-org'
+  projectName: 'svc-images'
+  reviewers:
+    users: ['user1']

package/dist/.test/assets/git/declarations/practices/tests-any/.test/assets/repo-old-acceptance-utils-3/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "test-project",
+  "version": "1.0.0"
+}

package/dist/.test/assets/git/declarations/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/.test/assets/git/declarations/practices/tests-any/__snapshots__/livedb-wake-branches.declapract.integration.test.ts.snap

@@ -0,0 +1,6 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`the useWakeOfLivedb decide-gate runs its real branches (executed, no live infra) given: the wake command fails when: it fails with a child-process shape (a non-zero exit) then: the wake-failure warn matches snapshot: useWakeOfLivedb wake-failure warn 1`] = `
+"useWakeOfLivedb: 'rhx use.rds.capacity --env prep' failed (non-fatal): {"status":1}
+"
+`;

package/dist/.test/assets/git/declarations/practices/tests-any/__snapshots__/old-acceptance-test-utils.declapract.integration.test.ts.snap

@@ -0,0 +1,162 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`tests-any old-acceptance-test-utils given: [case1] a repo on the old-acceptance-test-utils shape when: [t0] the input (before any fix) then: the file holds the old import, and matches snapshot: old-acceptance-test-utils — before 1`] = `
+"import { SNSEventRecord, SNSMessage, SNSEvent } from 'aws-lambda';
+
+import { exampleEmailClickEvent } from '../../src/.test/assets/exampleEmailClickEvent';
+import { invokeLambda } from '../_utils/invokeLambda';
+
+describe('consumeSESEmailEventFromSNS', () => {
+  it('should be possible to invoke the lambda', async () => {
+    const exampleSnsEvent: SNSEvent = {
+      Records: [
+        {
+          Sns: {
+            Message: JSON.stringify(exampleEmailClickEvent),
+          } as SNSMessage,
+        } as SNSEventRecord,
+      ],
+    };
+    const response = await invokeLambda({
+      name: 'consumeSESEmailEventFromSNS',
+      data: exampleSnsEvent,
+    });
+    expect(response).toBeDefined();
+  });
+});
+"
+`;
+
+exports[`tests-any old-acceptance-test-utils given: [case1] a repo on the old-acceptance-test-utils shape when: [t1] the fix is applied then: no template token leaks, and the file matches snapshot: old-acceptance-test-utils — after 1`] = `
+"import { SNSEventRecord, SNSMessage, SNSEvent } from 'aws-lambda';
+
+import { exampleEmailClickEvent } from '../../src/.test/assets/exampleEmailClickEvent';
+import { runLambdaEndpoint } from 'sdk-aws-lambda';
+import { sdkAwsLambdaEnvAccessContemp } from '@src/access/sdks/sdkAwsLambdaEnvAccessContemp';
+import { log } from '@src/utils/logger';
+import { locally } from '../environment';
+
+describe('consumeSESEmailEventFromSNS', () => {
+  it('should be possible to invoke the lambda', async () => {
+    const exampleSnsEvent: SNSEvent = {
+      Records: [
+        {
+          Sns: {
+            Message: JSON.stringify(exampleEmailClickEvent),
+          } as SNSMessage,
+        } as SNSEventRecord,
+      ],
+    };
+    const response = await runLambdaEndpoint.onSerialized<unknown, Record<string, any>>(
+      {
+        which: { service: 'svc-notifications', function: 'consumeSESEmailEventFromSNS' },
+        event: exampleSnsEvent,
+        at: locally ? 'local' : 'cloud',
+      },
+      { log, env: { access: sdkAwsLambdaEnvAccessContemp() } },
+    );
+    expect(response).toBeDefined();
+  });
+});
+"
+`;
+
+exports[`tests-any old-acceptance-test-utils given: [case2] a repo on the old-acceptance-test-utils-2 shape when: [t0] the input (before any fix) then: the file holds the old import, and matches snapshot: old-acceptance-test-utils-2 — before 1`] = `
+"import { invokeLambdaForTesting } from 'simple-lambda-testing-methods';
+
+import { locally } from '../__test_utils__/environment';
+
+describe('addDecoratedImage', () => {
+  it('it should be possible to add a decorated image', async () => {
+    const response = await invokeLambdaForTesting({
+      service: 'svc-images',
+      function: 'addDecoratedImage',
+      locally,
+      event: {
+        url: 'https://some.url',
+        description: 'bo vine at his gig, moooooin the lawn',
+        focalArea: null,
+      },
+    });
+    expect(response.image).toHaveProperty('uuid');
+  });
+});
+"
+`;
+
+exports[`tests-any old-acceptance-test-utils given: [case2] a repo on the old-acceptance-test-utils-2 shape when: [t1] the fix is applied then: no template token leaks, and the file matches snapshot: old-acceptance-test-utils-2 — after 1`] = `
+"import { runLambdaEndpoint } from 'sdk-aws-lambda';
+import { sdkAwsLambdaEnvAccessContemp } from '@src/access/sdks/sdkAwsLambdaEnvAccessContemp';
+import { log } from '@src/utils/logger';
+
+import { locally } from '../environment';
+
+describe('addDecoratedImage', () => {
+  it('it should be possible to add a decorated image', async () => {
+    const response = await runLambdaEndpoint.onSerialized<unknown, Record<string, any>>(
+      {
+        which: { service: 'svc-images', function: 'addDecoratedImage' },
+        event: {
+          url: 'https://some.url',
+          description: 'bo vine at his gig, moooooin the lawn',
+          focalArea: null,
+        },
+        at: locally ? 'local' : 'cloud',
+      },
+      { log, env: { access: sdkAwsLambdaEnvAccessContemp() } },
+    );
+    expect(response.image).toHaveProperty('uuid');
+  });
+});
+"
+`;
+
+exports[`tests-any old-acceptance-test-utils given: [case3] a repo on the old-acceptance-test-utils-3 shape when: [t0] the input (before any fix) then: the file holds the old import, and matches snapshot: old-acceptance-test-utils-3 — before 1`] = `
+"import { invokeLambdaForTesting } from 'simple-lambda-testing-methods';
+
+import { locally } from '../_utils/environment';
+
+describe('addDecoratedImage', () => {
+  it('it should be possible to add a decorated image', async () => {
+    const response = await invokeLambdaForTesting({
+      service: 'svc-images',
+      function: 'addDecoratedImage',
+      locally,
+      event: {
+        url: 'https://some.url',
+        description: 'bo vine at his gig, moooooin the lawn',
+        focalArea: null,
+      },
+    });
+    expect(response.image).toHaveProperty('uuid');
+  });
+});
+"
+`;
+
+exports[`tests-any old-acceptance-test-utils given: [case3] a repo on the old-acceptance-test-utils-3 shape when: [t1] the fix is applied then: no template token leaks, and the file matches snapshot: old-acceptance-test-utils-3 — after 1`] = `
+"import { runLambdaEndpoint } from 'sdk-aws-lambda';
+import { sdkAwsLambdaEnvAccessContemp } from '@src/access/sdks/sdkAwsLambdaEnvAccessContemp';
+import { log } from '@src/utils/logger';
+
+import { locally } from '../environment';
+
+describe('addDecoratedImage', () => {
+  it('it should be possible to add a decorated image', async () => {
+    const response = await runLambdaEndpoint.onSerialized<unknown, Record<string, any>>(
+      {
+        which: { service: 'svc-images', function: 'addDecoratedImage' },
+        event: {
+          url: 'https://some.url',
+          description: 'bo vine at his gig, moooooin the lawn',
+          focalArea: null,
+        },
+        at: locally ? 'local' : 'cloud',
+      },
+      { log, env: { access: sdkAwsLambdaEnvAccessContemp() } },
+    );
+    expect(response.image).toHaveProperty('uuid');
+  });
+});
+"
+`;

package/dist/.test/assets/git/declarations/practices/tests-any/__snapshots__/test-kind-seam.declapract.integration.test.ts.snap

@@ -0,0 +1,9 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`#679 test-kind presence accepts the \`._.\` seam given: [case] the tests-any integration declaration, on a repo with no test of either form then: the check still fails 1`] = `"expected at least one test file under src/ named *.integration.test.ts or *._.intg.test.ts"`;
+
+exports[`#679 test-kind presence accepts the \`._.\` seam given: [case] the tests-service blackbox acceptance declaration, on a repo with no test of either form then: the check still fails 1`] = `"expected at least one test file under blackbox/ named *.acceptance.test.ts or *._.acpt.test.ts"`;
+
+exports[`#679 test-kind presence accepts the \`._.\` seam given: [case] the tests-service integration declaration, on a repo with no test of either form then: the check still fails 1`] = `"expected at least one test file under src/ named *.integration.test.ts or *._.intg.test.ts"`;
+
+exports[`#679 test-kind presence accepts the \`._.\` seam given: [case] the tests-service lambda acceptance declaration, on a repo with no test of either form then: the check still fails 1`] = `"expected at least one test file under blackbox/lambdas/ named *.acceptance.test.ts or *._.acpt.test.ts"`;

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

@@ -0,0 +1,111 @@
+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 },
+  // #621: the expo integration + acceptance configs compose the livedb wake (via-gateway) too
+  {
+    relPath: 'src/practices/tests-expo/best-practice/jest.integration.config.ts',
+    composite: 'src/practices/tests-expo/best-practice/jest.integration.prepare.ts',
+  },
+  {
+    relPath: 'src/practices/tests-expo/best-practice/jest.acceptance.config.ts',
+    composite: 'src/practices/tests-expo/best-practice/jest.acceptance.prepare.ts',
+  },
+];
+
+/**
+ * .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/.test/assets/git/declarations/practices/tests-any/bad-practices/dev-tool-in-dependencies/.declapract.integration.test.ts

@@ -0,0 +1,69 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useBeforeAll, when } from 'test-fns';
+
+// executeApply evaluates the whole practice
+jest.setTimeout(240_000);
+
+/**
+ * .what = proves `declapract fix` on tests-any removes a stale test-fns from dependencies, so the
+ *         floored devDependencies entry is the one that installs (#657)
+ * .why  = the floor raised devDependencies alone; a `dependencies: 1.4.x` duplicate won the install
+ */
+describe('tests-any dev-tool-in-dependencies — pipeline', () => {
+  given('[case1] a repo with test-fns 1.4.0 in dependencies and 1.15.0 in devDependencies', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-dev-tool-in-deps',
+      clone:
+        './src/practices/tests-any/bad-practices/dev-tool-in-dependencies/.test/assets/demo-repo-with-stale-test-fns-dep',
+      // evaluate tests-any alone against the tiny repo; a symlink of this repo's whole src makes
+      // the practice's src/** globs walk every fixture here (minutes per apply)
+      symlink: [
+        { at: 'declarations', to: './src/.test/assets/tests-any-only/declarations' },
+        { at: 'node_modules', to: 'node_modules' },
+      ],
+    });
+
+    const read = () => fs.readFile(path.join(tempDir, 'package.json'), 'utf-8');
+
+    const state = useBeforeAll(async () => {
+      const config = path.join(tempDir, 'declapract.use.yml');
+      const before = await read();
+      await executeApply({ config, practice: 'tests-any', file: 'package.json' });
+      const after1 = await read();
+      await executeApply({ config, practice: 'tests-any', file: 'package.json' });
+      const after2 = await read();
+      await executeApply({ config, practice: 'tests-any', file: 'package.json' });
+      const after3 = await read();
+      return { before, after1, after2, after3 };
+    }, 230_000);
+
+    when('[t0] declapract fix is applied', () => {
+      then('test-fns is gone from dependencies, and the runtime dep stays', () => {
+        const pkg = JSON.parse(state.after2);
+        expect(pkg.dependencies['test-fns']).toBeUndefined();
+        expect(pkg.dependencies['domain-objects']).toEqual('0.31.0');
+      });
+
+      then('devDependencies holds test-fns at or above the floor', () => {
+        const pkg = JSON.parse(state.after2);
+        expect(pkg.devDependencies['test-fns']).not.toEqual('1.4.0');
+        expect(pkg.devDependencies['test-fns']).not.toEqual('1.15.0');
+        expect(pkg.devDependencies['test-fns']).not.toContain('@declapract{');
+      });
+
+      then('before + after match snapshot', () => {
+        expect(state.before).toMatchSnapshot('package.json — before');
+        expect(state.after2).toMatchSnapshot('package.json — after');
+      });
+    });
+
+    when('[t1] declapract fix is re-applied', () => {
+      then('the package.json is a fixed point once settled', () => {
+        expect(state.after3).toEqual(state.after2);
+      });
+    });
+  });
+});

package/dist/.test/assets/git/declarations/practices/tests-any/bad-practices/dev-tool-in-dependencies/.declapract.readme.md

@@ -0,0 +1,19 @@
+# tests-any dev-tool-in-dependencies bad practice
+
+## what
+
+detects a test tool that tests-any declares in `devDependencies` (`jest`, `@jest/globals`,
+`@types/jest`, `test-fns`, `tsx`, `esbuild-register`) when it also, or only, sits in
+`dependencies`.
+
+## why
+
+the tests-any best-practice floor raises the `devDependencies` entry alone. a stale duplicate in
+`dependencies` wins the install, so plan reports the floor met while the old release lands. jest
+then fails to load a reporter or setup that the old release predates.
+
+## fix
+
+removes each such tool from `dependencies`. where `devDependencies` lacks it, the version moves
+there; where `devDependencies` already holds it, that entry wins and the best-practice floor
+raises it.

package/dist/.test/assets/git/declarations/practices/tests-any/bad-practices/dev-tool-in-dependencies/.test/assets/demo-repo-with-stale-test-fns-dep/declapract.use.yml

@@ -0,0 +1,3 @@
+# .note = declarations dir is symlinked by the test to src/.test/assets/tests-any-only/declarations
+declarations: 'declarations/declapract.declare.yml'
+useCase: tests-any-only

package/dist/.test/assets/git/declarations/practices/tests-any/bad-practices/dev-tool-in-dependencies/.test/assets/demo-repo-with-stale-test-fns-dep/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "test-project",
+  "version": "1.0.0",
+  "dependencies": {
+    "domain-objects": "0.31.0",
+    "test-fns": "1.4.0"
+  },
+  "devDependencies": {
+    "test-fns": "1.15.0"
+  }
+}

package/dist/.test/assets/git/declarations/practices/tests-any/bad-practices/dev-tool-in-dependencies/__snapshots__/.declapract.integration.test.ts.snap

@@ -0,0 +1,43 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`tests-any dev-tool-in-dependencies — pipeline given: [case1] a repo with test-fns 1.4.0 in dependencies and 1.15.0 in devDependencies when: [t0] declapract fix is applied then: before + after match snapshot: package.json — after 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "dependencies": {
+    "domain-objects": "0.31.0"
+  },
+  "devDependencies": {
+    "test-fns": "1.17.0",
+    "@jest/globals": "30.2.0",
+    "@types/jest": "30.0.0",
+    "jest": "30.2.0",
+    "esbuild-register": "3.6.0",
+    "tsx": "4.20.6"
+  },
+  "scripts": {
+    "build:ifstale": "set -eu && if [ -f dist/.build.stamp ] && [ -z \\"$(find src assets package.json pnpm-lock.yaml tsconfig.json tsconfig.build.json app.json app.config.ts -newer dist/.build.stamp -type f ! -name '*.test.ts' ! -name '*.test.tsx' ! -name '*.snap' -print -quit 2>/dev/null)\\" ]; then echo '👌 dist is fresh, build skipped'; else npm run build && touch dist/.build.stamp; fi",
+    "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:ifstale && 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')"
+  }
+}
+"
+`;
+
+exports[`tests-any dev-tool-in-dependencies — pipeline given: [case1] a repo with test-fns 1.4.0 in dependencies and 1.15.0 in devDependencies when: [t0] declapract fix is applied then: before + after match snapshot: package.json — before 1`] = `
+"{
+  "name": "test-project",
+  "version": "1.0.0",
+  "dependencies": {
+    "domain-objects": "0.31.0",
+    "test-fns": "1.4.0"
+  },
+  "devDependencies": {
+    "test-fns": "1.15.0"
+  }
+}
+"
+`;

package/dist/.test/assets/git/declarations/practices/tests-any/bad-practices/dev-tool-in-dependencies/package.json.declapract.ts

@@ -0,0 +1,81 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import { asPackageJSON } from '../../../../utils/asPackageJSON';
+
+/**
+ * .what = detects a test tool the tests-any practice floors in `devDependencies` that ALSO (or
+ *         only) sits in `dependencies`
+ * .why  = the best-practice floor raises the `devDependencies` entry alone. a stale duplicate in
+ *         `dependencies` wins the install, so plan reports the floor met while the old release
+ *         lands, and jest cannot load a reporter or setup that release predates (#657)
+ */
+const PRACTICE = 'tests-any/dev-tool-in-dependencies';
+
+// the test tools tests-any declares in devDependencies (its best-practice package.json)
+export const DEV_TOOLS = [
+  '@jest/globals',
+  '@types/jest',
+  'esbuild-register',
+  'jest',
+  'test-fns',
+  'tsx',
+];
+
+export const check: FileCheckFunction = (contents) => {
+  if (!contents)
+    throw new Error(
+      `does not match bad practice: [${PRACTICE}] package.json has no contents to scan`,
+    );
+
+  const packageJSON = asPackageJSON({ contents }, { practice: PRACTICE });
+  const prodDeps = Object.keys(packageJSON.dependencies ?? {});
+
+  // a dev tool in dependencies = the bad practice
+  if (prodDeps.some((dep) => DEV_TOOLS.includes(dep))) return;
+
+  throw new Error(
+    'does not match bad practice: no tests-any dev tool in dependencies',
+  );
+};
+
+/**
+ * .what = remove each dev tool from prod deps; carry its version into dev deps only where dev
+ *         deps lacks it, so an extant dev deps entry (the one the floor raises) wins
+ * .why  = names the relocation as one intent, via a pure partition (inputs untouched)
+ */
+const withDevToolsMovedToDevDeps = (input: {
+  prodDeps: Record<string, string>;
+  devDeps: Record<string, string>;
+}): { prodDeps: Record<string, string>; devDeps: Record<string, string> } => {
+  const prodEntries = Object.entries(input.prodDeps);
+  const relocated = prodEntries.filter(([dep]) => DEV_TOOLS.includes(dep));
+  const retained = prodEntries.filter(([dep]) => !DEV_TOOLS.includes(dep));
+  return {
+    prodDeps: Object.fromEntries(retained),
+    devDeps: { ...Object.fromEntries(relocated), ...input.devDeps },
+  };
+};
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents };
+
+  const packageJSON = asPackageJSON({ contents }, { practice: PRACTICE });
+
+  // relocate every dev tool out of prod deps
+  const { prodDeps, devDeps } = withDevToolsMovedToDevDeps({
+    prodDeps: { ...packageJSON.dependencies },
+    devDeps: { ...packageJSON.devDependencies },
+  });
+
+  // keep each section's presence: a declared section stays; dev deps is added only when the move
+  // lands a package into it
+  const fixedPackageJSON = {
+    ...packageJSON,
+    ...('dependencies' in packageJSON ? { dependencies: prodDeps } : {}),
+    ...('devDependencies' in packageJSON || Object.keys(devDeps).length > 0
+      ? { devDependencies: devDeps }
+      : {}),
+  };
+
+  return { contents: JSON.stringify(fixedPackageJSON, null, 2) };
+};

package/dist/.test/assets/git/declarations/practices/tests-any/bad-practices/javascript-config-files/.declapract.readme.md

@@ -0,0 +1 @@
+we've migrated to using `.ts` config files for jest config, rather than `.js`

package/dist/.test/assets/git/declarations/practices/tests-any/bad-practices/javascript-config-files/jest.<star>.js.declapract.ts

@@ -0,0 +1,17 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+
+export const check = FileCheckType.EXISTS;
+
+/**
+ * .what = deletes a stale `.js` jest config file
+ * .why  = the go-forward jest config is `.ts` (see .declapract.readme.md). a leftover
+ *         `.js` jest config (e.g. a jsdom `jest.config.js` or a `jest.unit.config.js`)
+ *         is redundant and fights the shipped `.ts` config — the dual-source hazard the
+ *         app-protools-native migration must reconcile. drop the redundant `.js`; the
+ *         best-practice supplies the canonical `.ts` config in the same pass.
+ * .note  = `{ contents: null }` removes the file. idempotent: once gone, the EXISTS
+ *          check no longer detects it, so a re-run is a no-op.
+ */
+export const fix: FileFixFunction = () => {
+  return { contents: null };
+};

package/dist/.test/assets/git/declarations/practices/tests-any/bad-practices/mocks/.declapract.readme.md

@@ -0,0 +1,8 @@
+should not have any `__mock__` directories
+
+these are hard to track down and are too "magical" and affect _all_ tests (i.e., inter test dependency)
+
+just explicitly mocks manually in each test OR root level in setup env with:
+```ts
+jest.mock("...");
+```

package/dist/.test/assets/git/declarations/practices/tests-any/bad-practices/mocks/<star><star>/__mock__/<star>.js

@@ -0,0 +1,3 @@
+/**
+ * bad practice: file exists
+ */

package/dist/.test/assets/git/declarations/practices/tests-any/bad-practices/mocks/<star><star>/__mock__/<star>.ts

@@ -0,0 +1,3 @@
+/**
+ * bad practice: file exists
+ */