declapract-typescript-ehmpathy 0.49.10 → 0.49.12

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/__snapshots__/tsconfig.json.declapract.integration.test.ts.snap

@@ -0,0 +1,19 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`typescript-expo tsconfig.json the emitted tsconfig template matches snapshot: typescript-expo tsconfig.json 1`] = `
+"{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@src/*": ["src/*"],
+      "@assets/*": ["assets/*"]
+    }
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx"
+  ]
+}
+"
+`;

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/best-practice/package.json

@@ -0,0 +1,6 @@
+{
+  "scripts": {
+    "build": "npm run build:web",
+    "build:web": "npx expo export --platform web"
+  }
+}

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/best-practice/package.json.declapract.ts

@@ -0,0 +1,12 @@
+import { FileCheckType } from 'declapract';
+
+/**
+ * .what = the expo half of the typescript triad: the `build` command that metro/EAS
+ *         use instead of tsc.
+ * .why  = an expo app never builds with tsc — metro bundles the native build and
+ *         `npx expo export --platform web` produces the web `dist/`. `build` aliases
+ *         `build:web` so the shared cicd-common `.test.yml` (which runs `npm run build`)
+ *         works on an expo repo, and `.deploy-expo.yml` (which runs `npm run build:web`)
+ *         works too. CONTAINS, so a repo may add its own build variants around these.
+ */
+export const check = FileCheckType.CONTAINS;

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/best-practice/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@src/*": ["src/*"],
+      "@assets/*": ["assets/*"]
+    }
+  },
+  "include": [
+    "**/*.ts",
+    "**/*.tsx"
+  ]
+}

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/best-practice/tsconfig.json.declapract.ts

@@ -0,0 +1,12 @@
+import { FileCheckType } from 'declapract';
+
+/**
+ * .what = the expo tsconfig: extends `expo/tsconfig.base` (jsx, react-native module
+ *         resolution) instead of the node16 `@tsconfig/node20` base.
+ * .why  = CONTAINS, not EQUALS, so an app that has already customized its expo tsconfig
+ *         (extra paths, an app-specific include) is NOT clobbered — the check only asserts
+ *         the expo base + core `@src`/`@assets` paths are present. a greenfield expo repo
+ *         gets this emitted by `declapract fix`; a repo like app-protools-native (already
+ *         `extends: expo/tsconfig.base`) already satisfies it.
+ */
+export const check = FileCheckType.CONTAINS;

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/package.json.declapract.integration.test.ts

@@ -0,0 +1,43 @@
+import { FileCheckType } from 'declapract';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { check } from './best-practice/package.json.declapract';
+
+/**
+ * .why integration = the build-command assertions read the shipped `package.json` template
+ *   from disk via readFileSync — a filesystem boundary. per rule.forbid.unit.remote-boundaries
+ *   a `.test.ts` (unit) may not cross an fs boundary, so this guard (which exists to catch
+ *   DRIFT in the real template's build commands) lives at the integration grain, where a real
+ *   file read is permitted. an inline copy would test a hardcoded string, not the template,
+ *   so it could not catch the drift this guards.
+ */
+describe('typescript-expo package.json', () => {
+  it('declares a CONTAINS check (a repo may add its own build variants)', () => {
+    expect(check).toEqual(FileCheckType.CONTAINS);
+  });
+
+  it('the emitted build command uses metro/EAS (expo export), not tsc', () => {
+    const template = JSON.parse(
+      readFileSync(path.join(__dirname, 'best-practice/package.json'), 'utf-8'),
+    );
+    // `build` aliases build:web so the shared cicd `npm run build` works on expo
+    expect(template.scripts.build).toEqual('npm run build:web');
+    // the web build is expo export, NOT a tsc build (an expo app never builds with tsc)
+    expect(template.scripts['build:web']).toContain('expo export --platform web');
+    expect(template.scripts.build).not.toContain('tsc');
+  });
+
+  it('the emitted build commands match snapshot', () => {
+    // snapshot the governed build commands themselves, so a reshaped command that keeps the
+    // pinned tokens green (a reordered flag, a rephrased alias) reddens a vibecheck in review
+    // (rule.require.contract-snapshot-exhaustiveness)
+    const template = JSON.parse(
+      readFileSync(path.join(__dirname, 'best-practice/package.json'), 'utf-8'),
+    );
+    expect({
+      build: template.scripts.build,
+      'build:web': template.scripts['build:web'],
+    }).toMatchSnapshot('typescript-expo build commands');
+  });
+});

package/dist/.test/assets/expo-migration/declarations/practices/typescript-expo/tsconfig.json.declapract.integration.test.ts

@@ -0,0 +1,43 @@
+import { FileCheckType } from 'declapract';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { check } from './best-practice/tsconfig.json.declapract';
+
+/**
+ * .why integration = the template-content assertions read the shipped `tsconfig.json`
+ *   template from disk via readFileSync — a filesystem boundary. per
+ *   rule.forbid.unit.remote-boundaries a `.test.ts` (unit) may not cross an fs boundary,
+ *   so this guard (which exists to catch DRIFT in the real template) lives at the
+ *   integration grain, where a real file read is permitted. an inline copy would test a
+ *   hardcoded string, not the template, so it could not catch the drift this guards.
+ */
+describe('typescript-expo tsconfig.json', () => {
+  it('declares a CONTAINS check (a consumer may customize around the expo base)', () => {
+    expect(check).toEqual(FileCheckType.CONTAINS);
+  });
+
+  it('the emitted template is expo-shaped, not node', () => {
+    const template = JSON.parse(
+      readFileSync(path.join(__dirname, 'best-practice/tsconfig.json'), 'utf-8'),
+    );
+    // extends the expo base (jsx + react-native resolution), NOT @tsconfig/node20
+    expect(template.extends).toEqual('expo/tsconfig.base');
+    // the core path aliases a consumer relies on
+    expect(template.compilerOptions.paths['@src/*']).toEqual(['src/*']);
+    expect(template.compilerOptions.paths['@assets/*']).toEqual(['assets/*']);
+    // tsx is included (a react-native app has jsx), unlike the node tsconfig
+    expect(template.include).toContain('**/*.tsx');
+  });
+
+  it('the emitted tsconfig template matches snapshot', () => {
+    // snapshot the whole shipped template, so a reshape that keeps the pinned tokens green
+    // (a reordered path alias, a rephrased extends) reddens a vibecheck in review
+    // (rule.require.contract-snapshot-exhaustiveness)
+    const template = readFileSync(
+      path.join(__dirname, 'best-practice/tsconfig.json'),
+      'utf-8',
+    );
+    expect(template).toMatchSnapshot('typescript-expo tsconfig.json');
+  });
+});

package/dist/.test/assets/expo-migration/declarations/useCases.yml

@@ -0,0 +1,21 @@
+# the migration slice of the app-react-native-expo usecase
+# .why = these are the practices that touch a file an already-built expo app repo already
+#        has, so they are the ones whose GRACEFUL migration (rename / union / forget /
+#        merge-not-clobber) must be proven against a real app-protools-native-shaped repo.
+#        config-only practices that merely DROP a net-new file (lint, format, husky, …) add
+#        no migration risk and are already covered by the tests-expo pipeline test; this
+#        fixture isolates the practices that MUTATE an extant repo's files.
+use-cases:
+  app-react-native-expo:
+    practices:
+      - git
+      - rhachet
+      - node
+      - pnpm
+      - directory-structure-src
+      - domain
+      - typescript-any
+      - typescript-expo
+      - tests-any
+      - tests-expo
+      - cicd-app-react-native-expo

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/.github/workflows/.deploy-expo.yml

@@ -0,0 +1,30 @@
+name: .deploy-expo
+
+on:
+  workflow_call:
+    inputs:
+      access:
+        type: string
+        required: true
+
+jobs:
+  deploy-os:
+    name: deploy
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout
+        uses: actions/checkout@v4
+
+      - name: set node-version
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: ".nvmrc"
+
+      - name: cache node_modules
+        uses: actions/cache@v4
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node-${{ hashFiles('package-lock.json') }}
+
+      - name: install
+        run: npm ci

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/.husky/check.lockfile.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# warn the human when the lockfile changed and deps may be stale
+if git diff --name-only HEAD@{1} HEAD | grep -q 'package-lock.json'; then
+  echo "🔒 package-lock.json changed — run npm install"
+fi

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/declapract.use.yml

@@ -0,0 +1,24 @@
+# .note = declarations dir is symlinked by the test to src/.test/assets/expo-migration/declarations
+# .why  = an already-built expo app repo (the app-protools-native shape) on npm + the
+#         deprecated src/logic/ + src/data/ layers, used to prove the whole migration slice
+#         applies gracefully — rename, not delete; union, not clobber; forget, not destroy.
+declarations: 'declarations/declapract.declare.yml'
+useCase: app-react-native-expo
+# .note = the apply evaluates the WHOLE usecase before any file-filter, so EVERY variable
+#         any file in ANY of the ten practices references must be defined here, or evaluation
+#         throws `Variable … was not defined`.
+variables:
+  projectName: app-protools-native
+  organizationName: ahbode
+  infrastructureNamespaceId: aaa000
+  awsAccountId:
+    prep: '111111111111'
+    prod: '222222222222'
+  app:
+    web:
+      domain:
+        prep: protools.prep.ahbode.dev
+        prod: protools.ahbode.dev
+      port:
+        hot: 3447
+        cold: 3449

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/jest.config.js

@@ -0,0 +1,8 @@
+// a stale JS jest config (jsdom) — the exact dual-source hazard the app-protools-native
+// audit names. the go-forward is jest.config.ts (the tests-expo best-practice template),
+// so the tests-any `javascript-config-files` bad-practice must DELETE this on `declapract
+// fix`; the shipped .ts config then stands as the single source.
+module.exports = {
+  testEnvironment: 'jsdom',
+  preset: 'jest-expo',
+};

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/package-lock.json

@@ -0,0 +1,7 @@
+{
+  "name": "app-protools-shaped",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/package.json

@@ -0,0 +1,22 @@
+{
+  "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": "54.0.0"
+  }
+}

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/pnpm-lock.yaml

@@ -0,0 +1,5 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/src/data/dao/daoCustomer.ts

@@ -0,0 +1,9 @@
+// a deprecated data-layer dao. the directory-structure-src migration must move this file
+// data/dao/ -> access/daos/ (the dao-specific rename, not the generic data/ -> access/).
+export interface Customer {
+  id: string;
+  name: string;
+}
+export const daoCustomer = {
+  findById: async (id: string): Promise<Customer> => ({ id, name: 'test' }),
+};

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/src/logic/customer/getCustomer.ts

@@ -0,0 +1,25 @@
+// a deprecated-layer operation that imports from the deprecated data-layer dao
+// via the @src alias (the go-forward import style the relative-imports practice
+// pushes repos toward). the directory-structure-src migration must move this file
+// logic/ -> domain.operations/ AND rewrite the import path data/dao -> access/daos.
+//
+// this file deliberately carries THREE distinct import SHAPES that all reference the
+// deprecated data/ layer, so the pipeline rewrite is proven to handle more than one
+// import per file (the r10 blocker-3 case): a plain value import, a type-only import,
+// and a barrel re-export. every one must land at access/daos, none may keep data/dao.
+import { daoCustomer } from '@src/data/dao/daoCustomer';
+import type { Customer } from '@src/data/dao/daoCustomer';
+export { daoCustomer as daoCustomerReExport } from '@src/data/dao/daoCustomer';
+
+// a `../` RELATIVE import to a peer in the same deprecated layer. relative-imports must
+// rewrite it to the @src alias — but only AFTER the dir-move relocates this file out of
+// logic/. on pass 1 this file still sits under the deprecated logic/ dir, so relative-imports
+// DEFERS (its isDeferredToDeprecatedDirMove guard) while old-logic-dir relocates the file; on
+// pass 2 the file sits at domain.operations/ and relative-imports fires and converts
+// ../shared/formatCustomer -> @src/domain.operations/shared/formatCustomer. proves the
+// branch-new deferred-dir guard end-to-end (the r1 relative-imports blocker).
+import { formatCustomer } from '../shared/formatCustomer';
+
+export const getCustomer = async (input: { id: string }): Promise<Customer> => {
+  return formatCustomer(await daoCustomer.findById(input.id));
+};

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/src/logic/shared/formatCustomer.ts

@@ -0,0 +1,8 @@
+// a peer util in the SAME deprecated layer (src/logic/shared/). getCustomer.ts imports
+// this via a `../shared/formatCustomer` RELATIVE path, so the migration must BOTH relocate
+// this file (logic/shared/ -> domain.operations/shared/) AND rewrite the relative import in
+// its importer to the @src alias — a two-pass settle the relative-imports deferred-dir guard
+// governs. it exists so the pipeline exercises relative-imports end-to-end.
+import type { Customer } from '@src/data/dao/daoCustomer';
+
+export const formatCustomer = (customer: Customer): Customer => customer;

package/dist/.test/assets/expo-migration/repo-app-protools-shaped/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@src/*": ["src/*"],
+      "@assets/*": ["assets/*"],
+      "@app-custom/*": ["src/app-custom/*"]
+    }
+  },
+  "include": ["**/*.ts", "**/*.tsx", ".expo/types/**/*.ts", "expo-env.d.ts"]
+}

package/dist/.test/assets/expo-toolchain/declarations/declapract.declare.yml

@@ -0,0 +1,4 @@
+# minimal declarations for the expo test-toolchain integration test
+declare:
+  practices: practices
+  use-cases: useCases.yml

package/dist/.test/assets/expo-toolchain/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/expo-toolchain/declarations/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/.test/assets/expo-toolchain/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/expo-toolchain/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/expo-toolchain/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/expo-toolchain/declarations/practices/tests-any/bad-practices/mocks/<star><star>/__mock__/<star>.js

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

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

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

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.declapract.integration.test.ts

@@ -0,0 +1,63 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+/**
+ * .what = integration test for old-acceptance-dir-location bad practice
+ * .why = reproduces bug where files with non-ts extensions are silently dropped
+ */
+describe('old-acceptance-dir-location', () => {
+  given('[case1] accept.blackbox/ with various file types', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-old-acceptance-dir',
+      clone: './src/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir',
+      symlink: [{ at: 'src', to: 'src' }],
+    });
+
+    when('[t0] before fix', () => {
+      then('accept.blackbox/ contains files', async () => {
+        const rhachetFile = path.join(
+          tempDir,
+          'accept.blackbox/.test/assets/.rhachet/manifest.json',
+        );
+        const stats = await fs.stat(rhachetFile);
+        expect(stats.isFile()).toBe(true);
+      });
+    });
+
+    when('[t1] declapract fix is applied', () => {
+      useThen('fix is applied', async () => {
+        await executeApply({
+          config: path.join(tempDir, 'declapract.use.yml'),
+          practice: 'tests-any',
+        });
+      });
+
+      then('somefile.ts is moved to blackbox/', async () => {
+        const newPath = path.join(tempDir, 'blackbox/somefile.ts');
+        const stats = await fs.stat(newPath).catch(() => null);
+        expect(stats?.isFile()).toBe(true);
+      });
+
+      then('.rhachet/manifest.json is moved to blackbox/', async () => {
+        const newPath = path.join(
+          tempDir,
+          'blackbox/.test/assets/.rhachet/manifest.json',
+        );
+        const stats = await fs.stat(newPath).catch(() => null);
+        expect(stats?.isFile()).toBe(true);
+      });
+
+      then('.agent/config.yml is moved to blackbox/', async () => {
+        const newPath = path.join(
+          tempDir,
+          'blackbox/.test/assets/.agent/config.yml',
+        );
+        const stats = await fs.stat(newPath).catch(() => null);
+        expect(stats?.isFile()).toBe(true);
+      });
+    });
+  });
+});

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.declapract.readme.md

@@ -0,0 +1,22 @@
+# old-acceptance-dir-location
+
+## .what
+
+detects test files located in `acceptance/` or `accept.blackbox/` directories and migrates them to `blackbox/`.
+
+## .why
+
+the term "blackbox" makes the testing philosophy explicit:
+- blackbox tests interact only through public contracts (APIs, CLIs, SDKs)
+- no access to internal implementation details
+- tests validate behavior from the caller's perspective
+
+the rename from `acceptance/` or `accept.blackbox/` to `blackbox/` clarifies this intent and simplifies the naming.
+
+## .fix
+
+moves all files from `acceptance/` or `accept.blackbox/` to `blackbox/` while preserving the directory structure.
+
+## .note
+
+the `.acceptance.test.ts` file extension is preserved — it communicates the test type while the directory name communicates the testing philosophy.

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/accept.blackbox/.test/assets/.agent/config.yml

@@ -0,0 +1 @@
+key: value

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/accept.blackbox/.test/assets/.rhachet/manifest.json

@@ -0,0 +1 @@
+{}

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/accept.blackbox/somefile.ts

@@ -0,0 +1 @@
+export const x = 1;

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/declapract.declare.yml

@@ -0,0 +1,4 @@
+declare:
+  examples: src/examples
+  practices: src/practices
+  use-cases: src/useCases.yml

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/declapract.use.yml

@@ -0,0 +1,5 @@
+declarations: './'
+useCase: typescript-project
+variables:
+  organizationName: 'test-org'
+  projectName: 'test-project'

package/dist/.test/assets/expo-toolchain/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/package.json

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